jdk-sandbox: comparison hotspot/src/share/vm/opto/library

equal deleted inserted replaced

-:6c7faa516fc6
+:4f0635e148c1
 int classify_unsafe_addr(Node* &base, Node* &offset);
 Node* make_unsafe_address(Node* base, Node* offset);
 // Helper for inline_unsafe_access.
 // Generates the guards that check whether the result of
 // Unsafe.getObject should be recorded in an SATB log buffer.
-void insert_g1_pre_barrier(Node* base_oop, Node* offset, Node* pre_val);
+void insert_pre_barrier(Node* base_oop, Node* offset, Node* pre_val, int nargs, bool need_mem_bar);
 bool inline_unsafe_access(bool is_native_ptr, bool is_store, BasicType type, bool is_volatile);
 bool inline_unsafe_prefetch(bool is_native_ptr, bool is_store, bool is_static);
 bool inline_unsafe_allocate();
 bool inline_unsafe_copyMemory();
 bool inline_native_currentThread();
 case vmIntrinsics::_indexOf:
 case vmIntrinsics::_compareTo:
 case vmIntrinsics::_equals:
 case vmIntrinsics::_equalsC:
 break;  // InlineNatives does not control String.compareTo
+case vmIntrinsics::_Reference_get:
+break;  // InlineNatives does not control Reference.get
 default:
 return NULL;
 }
 }
 case vmIntrinsics::_numberOfTrailingZeros_l:
 if (!Matcher::match_rule_supported(Op_CountTrailingZerosL)) return NULL;
 break;
 case vmIntrinsics::_Reference_get:
-// It is only when G1 is enabled that we absolutely
+// Use the intrinsic version of Reference.get() so that the value in
-// need to use the intrinsic version of Reference.get()
+// the referent field can be registered by the G1 pre-barrier code.
-// so that the value in the referent field, if necessary,
+// Also add memory barrier to prevent commoning reads from this field
-// can be registered by the pre-barrier code.
+// across safepoint since GC can change it value.
-if (!UseG1GC) return NULL;
 break;
 default:
 assert(id <= vmIntrinsics::LAST_COMPILER_INLINE, "caller responsibility");
 assert(id != vmIntrinsics::_Object_init && id != vmIntrinsics::_invoke, "enum out of order?");
 //----------------------------inline_unsafe_access----------------------------
 const static BasicType T_ADDRESS_HOLDER = T_LONG;
-// Helper that guards and inserts a G1 pre-barrier.
+// Helper that guards and inserts a pre-barrier.
-void LibraryCallKit::insert_g1_pre_barrier(Node* base_oop, Node* offset, Node* pre_val) {
+void LibraryCallKit::insert_pre_barrier(Node* base_oop, Node* offset,
-assert(UseG1GC, "should not call this otherwise");
+Node* pre_val, int nargs, bool need_mem_bar) {
 // We could be accessing the referent field of a reference object. If so, when G1
 // is enabled, we need to log the value in the referent field in an SATB buffer.
 // This routine performs some compile time filters and generates suitable
 // runtime filters that guard the pre-barrier code.
+// Also add memory barrier for non volatile load from the referent field
+// to prevent commoning of loads across safepoint.
+if (!UseG1GC && !need_mem_bar)
+return;
 // Some compile time checks.
 // If offset is a constant, is it java_lang_ref_Reference::_reference_offset?
 const TypeX* otype = offset->find_intptr_t_type();
 return;
 }
 const TypeInstPtr* itype = btype->isa_instptr();
 if (itype != NULL) {
-// Can the klass of base_oop be statically determined
+// Can the klass of base_oop be statically determined to be
-// to be _not_ a sub-class of Reference?
+// _not_ a sub-class of Reference and _not_ Object?
 ciKlass* klass = itype->klass();
-if (klass->is_subtype_of(env()->Reference_klass()) &&
+if ( klass->is_loaded() &&
-!env()->Reference_klass()->is_subtype_of(klass)) {
+!klass->is_subtype_of(env()->Reference_klass()) &&
+!env()->Object_klass()->is_subtype_of(klass)) {
 return;
 }
 }
 }
 // The compile time filters did not reject base_oop/offset so
 // we need to generate the following runtime filters
 //
 // if (offset == java_lang_ref_Reference::_reference_offset) {
-//   if (base != null) {
+//   if (instance_of(base, java.lang.ref.Reference)) {
-//     if (instance_of(base, java.lang.ref.Reference)) {
+//     pre_barrier(_, pre_val, ...);
-//       pre_barrier(_, pre_val, ...);
-//     }
 //   }
 // }
 float likely  = PROB_LIKELY(0.999);
 float unlikely  = PROB_UNLIKELY(0.999);
 #define __ ideal.
 Node* referent_off = __ ConX(java_lang_ref_Reference::referent_offset);
 __ if_then(offset, BoolTest::eq, referent_off, unlikely); {
-__ if_then(base_oop, BoolTest::ne, null(), likely); {
 // Update graphKit memory and control from IdealKit.
 sync_kit(ideal);
 Node* ref_klass_con = makecon(TypeKlassPtr::make(env()->Reference_klass()));
+_sp += nargs;  // gen_instanceof might do an uncommon trap
 Node* is_instof = gen_instanceof(base_oop, ref_klass_con);
+_sp -= nargs;
 // Update IdealKit memory and control from graphKit.
 __ sync_kit(this);
 Node* one = __ ConI(1);
+// is_instof == 0 if base_oop == NULL
 __ if_then(is_instof, BoolTest::eq, one, unlikely); {
 // Update graphKit from IdeakKit.
 sync_kit(ideal);
 pre_barrier(false /* do_load */,
 __ ctrl(),
 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
 pre_val /* pre_val */,
 T_OBJECT);
+if (need_mem_bar) {
+// Add memory barrier to prevent commoning reads from this field
+// across safepoint since GC can change its value.
+insert_mem_bar(Op_MemBarCPUOrder);
+}
 // Update IdealKit from graphKit.
 __ sync_kit(this);
 } __ end_if(); // _ref_type != ref_none
-} __ end_if(); // base  != NULL
 } __ end_if(); // offset == referent_offset
 // Final sync IdealKit and GraphKit.
 final_sync(ideal);
 #undef __
 // If we are reading the value of the referent field of a Reference
 // object (either by using Unsafe directly or through reflection)
 // then, if G1 is enabled, we need to record the referent in an
 // SATB log buffer using the pre-barrier mechanism.
-bool need_read_barrier = UseG1GC && !is_native_ptr && !is_store &&
+// Also we need to add memory barrier to prevent commoning reads
+// from this field across safepoint since GC can change its value.
+bool need_read_barrier = !is_native_ptr && !is_store &&
 offset != top() && heap_base_oop != top();
 if (!is_store && type == T_OBJECT) {
 // Attempt to infer a sharper value type from the offset and base type.
 ciKlass* sharpened_klass = NULL;
 case T_FLOAT:
 push(p);
 break;
 case T_OBJECT:
 if (need_read_barrier) {
-insert_g1_pre_barrier(heap_base_oop, offset, p);
+insert_pre_barrier(heap_base_oop, offset, p, nargs, !(is_volatile || need_mem_bar));
 }
 push(p);
 break;
 case T_ADDRESS:
 // Cast to an int type.
 control(),
 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
 result /* pre_val */,
 T_OBJECT);
+// Add memory barrier to prevent commoning reads from this field
+// across safepoint since GC can change its value.
+insert_mem_bar(Op_MemBarCPUOrder);
 push(result);
 return true;
 }

changeset 13486	4f0635e148c1
parent 13391	30245956af37
child 13728	882756847a04