Merge branch 'master' into 8212107-vmthread

Author: robehn

make/autoconf/flags-cflags.m4

@@ -134,6 +134,10 @@ AC_DEFUN([FLAGS_SETUP_WARNINGS],
 
       WARNINGS_ENABLE_ALL="-W3"
       DISABLED_WARNINGS="4800"
+      if test "x$TOOLCHAIN_VERSION" = x2017; then
+        # VS2017 incorrectly triggers this warning for constexpr
+        DISABLED_WARNINGS+=" 4307"
+      fi
       ;;
 
     gcc)

make/devkit/Tools.gmk

@@ -125,7 +125,7 @@ else
 endif
 
 GCC := http://ftp.gnu.org/pub/gnu/gcc/$(gcc_ver)/$(gcc_ver).tar.xz
-BINUTILS := http://ftp.gnu.org/pub/gnu/binutils/$(binutils_ver).tar.xz
+BINUTILS := http://ftp.gnu.org/pub/gnu/binutils/$(binutils_ver).tar.gz
 CCACHE := https://github.com/ccache/ccache/releases/download/v$(ccache_ver)/ccache-$(ccache_ver).tar.xz
 MPFR := https://www.mpfr.org/${mpfr_ver}/${mpfr_ver}.tar.bz2
 GMP := http://ftp.gnu.org/pub/gnu/gmp/${gmp_ver}.tar.bz2

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -1004,27 +1004,22 @@ void MacroAssembler::lookup_interface_method(Register recv_klass,
   // }
   Label search, found_method;
 
-  for (int peel = 1; peel >= 0; peel--) {
-    ldr(method_result, Address(scan_temp, itableOffsetEntry::interface_offset_in_bytes()));
-    cmp(intf_klass, method_result);
-
-    if (peel) {
-      br(Assembler::EQ, found_method);
-    } else {
-      br(Assembler::NE, search);
-      // (invert the test to fall through to found_method...)
-    }
-
-    if (!peel)  break;
-
-    bind(search);
-
-    // Check that the previous entry is non-null.  A null entry means that
-    // the receiver class doesn't implement the interface, and wasn't the
-    // same as when the caller was compiled.
-    cbz(method_result, L_no_such_interface);
+  ldr(method_result, Address(scan_temp, itableOffsetEntry::interface_offset_in_bytes()));
+  cmp(intf_klass, method_result);
+  br(Assembler::EQ, found_method);
+  bind(search);
+  // Check that the previous entry is non-null.  A null entry means that
+  // the receiver class doesn't implement the interface, and wasn't the
+  // same as when the caller was compiled.
+  cbz(method_result, L_no_such_interface);
+  if (itableOffsetEntry::interface_offset_in_bytes() != 0) {
     add(scan_temp, scan_temp, scan_step);
+    ldr(method_result, Address(scan_temp, itableOffsetEntry::interface_offset_in_bytes()));
+  } else {
+    ldr(method_result, Address(pre(scan_temp, scan_step)));
   }
+  cmp(intf_klass, method_result);
+  br(Assembler::NE, search);
 
   bind(found_method);
 

src/hotspot/cpu/arm/globalDefinitions_arm.hpp

@@ -55,11 +55,4 @@ const bool HaveVFP = true;
 #define AD_MD_HPP              "adfiles/ad_arm_32.hpp"
 #define C1_LIRGENERATOR_MD_HPP "c1_LIRGenerator_arm.hpp"
 
-#ifdef TARGET_COMPILER_gcc
-#ifdef ARM32
-#undef BREAKPOINT
-#define BREAKPOINT __asm__ volatile ("bkpt")
-#endif
-#endif
-
 #endif // CPU_ARM_GLOBALDEFINITIONS_ARM_HPP

src/hotspot/share/gc/g1/g1ParScanThreadState.cpp

@@ -36,6 +36,16 @@
 #include "oops/access.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/prefetch.inline.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/macros.hpp"
+
+// In fastdebug builds the code size can get out of hand, potentially
+// tripping over compiler limits (which may be bugs, but nevertheless
+// need to be taken into consideration).  A side benefit of limiting
+// inlining is that we get more call frames that might aid debugging.
+// And the fastdebug compile time for this file is much reduced.
+// Explicit NOINLINE to block ATTRIBUTE_FLATTENing.
+#define MAYBE_INLINE_EVACUATION NOT_DEBUG(inline) DEBUG_ONLY(NOINLINE)
 
 G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h,
                                            G1RedirtyCardsQueueSet* rdcqs,
@@ -155,7 +165,9 @@ void G1ParScanThreadState::verify_task(ScannerTask task) const {
 }
 #endif // ASSERT
 
-template <class T> void G1ParScanThreadState::do_oop_evac(T* p) {
+template <class T>
+MAYBE_INLINE_EVACUATION
+void G1ParScanThreadState::do_oop_evac(T* p) {
   // Reference should not be NULL here as such are never pushed to the task queue.
   oop obj = RawAccess<IS_NOT_NULL>::oop_load(p);
 
@@ -194,6 +206,7 @@ template <class T> void G1ParScanThreadState::do_oop_evac(T* p) {
   }
 }
 
+MAYBE_INLINE_EVACUATION
 void G1ParScanThreadState::do_partial_array(PartialArrayScanTask task) {
   oop from_obj = task.to_source_array();
 
@@ -243,6 +256,7 @@ void G1ParScanThreadState::do_partial_array(PartialArrayScanTask task) {
   to_obj_array->oop_iterate_range(&_scanner, start, end);
 }
 
+MAYBE_INLINE_EVACUATION
 void G1ParScanThreadState::dispatch_task(ScannerTask task) {
   verify_task(task);
   if (task.is_narrow_oop_ptr()) {
@@ -388,6 +402,7 @@ void G1ParScanThreadState::undo_allocation(G1HeapRegionAttr dest_attr,
 
 // Private inline function, for direct internal use and providing the
 // implementation of the public not-inline function.
+MAYBE_INLINE_EVACUATION
 oop G1ParScanThreadState::do_copy_to_survivor_space(G1HeapRegionAttr const region_attr,
                                                     oop const old,
                                                     markWord const old_mark) {

src/hotspot/share/gc/g1/g1ParScanThreadState.hpp

@@ -156,7 +156,7 @@ class G1ParScanThreadState : public CHeapObj<mtGC> {
   size_t flush(size_t* surviving_young_words);
 
 private:
-  inline void do_partial_array(PartialArrayScanTask task);
+  void do_partial_array(PartialArrayScanTask task);
 
   HeapWord* allocate_copy_slow(G1HeapRegionAttr* dest_attr,
                                oop old,
@@ -169,14 +169,14 @@ class G1ParScanThreadState : public CHeapObj<mtGC> {
                        size_t word_sz,
                        uint node_index);
 
-  inline oop do_copy_to_survivor_space(G1HeapRegionAttr region_attr,
-                                       oop obj,
-                                       markWord old_mark);
+  oop do_copy_to_survivor_space(G1HeapRegionAttr region_attr,
+                                oop obj,
+                                markWord old_mark);
 
   // This method is applied to the fields of the objects that have just been copied.
-  template <class T> inline void do_oop_evac(T* p);
+  template <class T> void do_oop_evac(T* p);
 
-  inline void dispatch_task(ScannerTask task);
+  void dispatch_task(ScannerTask task);
 
   // Tries to allocate word_sz in the PLAB of the next "generation" after trying to
   // allocate into dest. Previous_plab_refill_failed indicates whether previous

src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp

@@ -204,7 +204,7 @@ oop ShenandoahBarrierSet::load_reference_barrier_native_impl(oop obj, T* load_ad
   }
 
   oop fwd = load_reference_barrier_not_null(obj);
-  if (load_addr != NULL && fwd != obj) {
+  if (ShenandoahSelfFixing && load_addr != NULL && fwd != obj) {
     // Since we are here and we know the load address, update the reference.
     ShenandoahHeap::cas_oop(fwd, load_addr, obj);
   }

src/hotspot/share/opto/addnode.cpp

@@ -743,41 +743,47 @@ Node* OrINode::Identity(PhaseGVN* phase) {
   return AddNode::Identity(phase);
 }
 
-Node *OrINode::Ideal(PhaseGVN *phase, bool can_reshape) {
+// Find shift value for Integer or Long OR.
+Node* rotate_shift(PhaseGVN* phase, Node* lshift, Node* rshift, int mask) {
+  // val << norm_con_shift | val >> ({32|64} - norm_con_shift) => rotate_left val, norm_con_shift
+  const TypeInt* lshift_t = phase->type(lshift)->isa_int();
+  const TypeInt* rshift_t = phase->type(rshift)->isa_int();
+  if (lshift_t != NULL && lshift_t->is_con() &&
+      rshift_t != NULL && rshift_t->is_con() &&
+      ((lshift_t->get_con() & mask) == ((mask + 1) - (rshift_t->get_con() & mask)))) {
+    return phase->intcon(lshift_t->get_con() & mask);
+  }
+  // val << var_shift | val >> ({0|32|64} - var_shift) => rotate_left val, var_shift
+  if (rshift->Opcode() == Op_SubI && rshift->in(2) == lshift && rshift->in(1)->is_Con()){
+    const TypeInt* shift_t = phase->type(rshift->in(1))->isa_int();
+    if (shift_t != NULL && shift_t->is_con() &&
+        (shift_t->get_con() == 0 || shift_t->get_con() == (mask + 1))) {
+      return lshift;
+    }
+  }
+  return NULL;
+}
+
+Node* OrINode::Ideal(PhaseGVN* phase, bool can_reshape) {
   int lopcode = in(1)->Opcode();
   int ropcode = in(2)->Opcode();
   if (Matcher::match_rule_supported(Op_RotateLeft) &&
       lopcode == Op_LShiftI && ropcode == Op_URShiftI && in(1)->in(1) == in(2)->in(1)) {
-     Node *lshift = in(1)->in(2);
-     Node *rshift = in(2)->in(2);
-     // val << norm_con_shift | val >> (32 - norm_con_shift) => rotate_left val , norm_con_shift
-     if (lshift->is_Con() && rshift->is_Con() &&
-         ((lshift->get_int() & 0x1F) == (32 - (rshift->get_int() & 0x1F)))) {
-       return  new RotateLeftNode(in(1)->in(1),
-                 phase->intcon(lshift->get_int() & 0x1F), TypeInt::INT);
-     }
-     // val << var_shift | val >> (0/32 - var_shift) => rotate_left val , var_shift
-     if (rshift->Opcode() == Op_SubI && rshift->in(2) == lshift &&
-         rshift->in(1)->is_Con() &&
-         (rshift->in(1)->get_int() == 0 || rshift->in(1)->get_int() == 32)) {
-       return  new RotateLeftNode(in(1)->in(1), lshift, TypeInt::INT);
+     Node* lshift = in(1)->in(2);
+     Node* rshift = in(2)->in(2);
+     Node* shift = rotate_shift(phase, lshift, rshift, 0x1F);
+     if (shift != NULL) {
+       return new RotateLeftNode(in(1)->in(1), shift, TypeInt::INT);
      }
+     return NULL;
   }
   if (Matcher::match_rule_supported(Op_RotateRight) &&
       lopcode == Op_URShiftI && ropcode == Op_LShiftI && in(1)->in(1) == in(2)->in(1)) {
      Node *rshift = in(1)->in(2);
      Node *lshift = in(2)->in(2);
-     // val >> norm_con_shift | val << (32 - norm_con_shift) => rotate_right val , norm_con_shift
-     if (rshift->is_Con() && lshift->is_Con() &&
-         ((rshift->get_int() & 0x1F) == (32 - (lshift->get_int() & 0x1F)))) {
-       return  new RotateRightNode(in(1)->in(1),
-                 phase->intcon(rshift->get_int() & 0x1F), TypeInt::INT);
-     }
-     // val >> var_shift | val << (0/32 - var_shift) => rotate_right val , var_shift
-     if (lshift->Opcode() == Op_SubI && lshift->in(2) == rshift &&
-         lshift->in(1)->is_Con() &&
-         (lshift->in(1)->get_int() == 0 || lshift->in(1)->get_int() == 32)) {
-       return  new RotateRightNode(in(1)->in(1), rshift, TypeInt::INT);
+     Node* shift = rotate_shift(phase, rshift, lshift, 0x1F);
+     if (shift != NULL) {
+       return new RotateRightNode(in(1)->in(1), shift, TypeInt::INT);
      }
   }
   return NULL;
@@ -824,42 +830,27 @@ Node* OrLNode::Identity(PhaseGVN* phase) {
   return AddNode::Identity(phase);
 }
 
-Node *OrLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
+Node* OrLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
   int lopcode = in(1)->Opcode();
   int ropcode = in(2)->Opcode();
   if (Matcher::match_rule_supported(Op_RotateLeft) &&
       lopcode == Op_LShiftL && ropcode == Op_URShiftL && in(1)->in(1) == in(2)->in(1)) {
-     Node *lshift = in(1)->in(2);
-     Node *rshift = in(2)->in(2);
-     // val << norm_con_shift | val >> (64 - norm_con_shift) => rotate_left val , norm_con_shift
-     if (lshift->is_Con() && rshift->is_Con() &&
-         ((lshift->get_int() & 0x3F) == (64 - (rshift->get_int() & 0x3F)))) {
-       return  new RotateLeftNode(in(1)->in(1),
-                 phase->intcon(lshift->get_int() & 0x3F), TypeLong::LONG);
-     }
-     // val << var_shift | val >> (0/64 - var_shift) => rotate_left val , var_shift
-     if (rshift->Opcode() == Op_SubI && rshift->in(2) == lshift &&
-         rshift->in(1)->is_Con() &&
-         (rshift->in(1)->get_int() == 0 || rshift->in(1)->get_int() == 64)) {
-       return  new RotateLeftNode(in(1)->in(1), lshift, TypeLong::LONG);
-     }
+    Node* lshift = in(1)->in(2);
+    Node* rshift = in(2)->in(2);
+    Node* shift = rotate_shift(phase, lshift, rshift, 0x3F);
+    if (shift != NULL) {
+      return new RotateLeftNode(in(1)->in(1), shift, TypeLong::LONG);
+    }
+    return NULL;
   }
   if (Matcher::match_rule_supported(Op_RotateRight) &&
       lopcode == Op_URShiftL && ropcode == Op_LShiftL && in(1)->in(1) == in(2)->in(1)) {
-     Node *rshift = in(1)->in(2);
-     Node *lshift = in(2)->in(2);
-     // val >> norm_con_shift | val << (64 - norm_con_shift) => rotate_right val , norm_con_shift
-     if (rshift->is_Con() && lshift->is_Con() &&
-         ((rshift->get_int() & 0x3F) == (64 - (lshift->get_int() & 0x3F)))) {
-       return  new RotateRightNode(in(1)->in(1),
-                 phase->intcon(rshift->get_int() & 0x3F), TypeLong::LONG);
-     }
-     // val >> var_shift | val << (0/64 - var_shift) => rotate_right val , var_shift
-     if (lshift->Opcode() == Op_SubI && lshift->in(2) == rshift &&
-         lshift->in(1)->is_Con() &&
-         (lshift->in(1)->get_int() == 0 || lshift->in(1)->get_int() == 64)) {
-       return  new RotateRightNode(in(1)->in(1), rshift, TypeLong::LONG);
-     }
+    Node* rshift = in(1)->in(2);
+    Node* lshift = in(2)->in(2);
+    Node* shift = rotate_shift(phase, rshift, lshift, 0x3F);
+    if (shift != NULL) {
+      return new RotateRightNode(in(1)->in(1), shift, TypeLong::LONG);
+    }
   }
   return NULL;
 }