jdk-sandbox: comparison hotspot/src/share/vm/c1/c1

equal deleted inserted replaced

-:6c7faa516fc6
+:4f0635e148c1
 LIRItem off(x->offset(), this);
 off.load_item();
 src.load_item();
-LIR_Opr reg = rlock_result(x, x->basic_type());
+LIR_Opr value = rlock_result(x, x->basic_type());
-get_Object_unsafe(reg, src.result(), off.result(), type, x->is_volatile());
+get_Object_unsafe(value, src.result(), off.result(), type, x->is_volatile());
 #ifndef SERIALGC
 // We might be reading the value of the referent field of a
 // Reference object in order to attach it back to the live
 // object graph. If G1 is enabled then we need to record
 // We need to generate code similar to the following...
 //
 // if (offset == java_lang_ref_Reference::referent_offset) {
 //   if (src != NULL) {
 //     if (klass(src)->reference_type() != REF_NONE) {
-//       pre_barrier(..., reg, ...);
+//       pre_barrier(..., value, ...);
 //     }
 //   }
 // }
-//
-// The first non-constant check of either the offset or
-// the src operand will be done here; the remainder
-// will take place in the generated code stub.
 if (UseG1GC && type == T_OBJECT) {
-bool gen_code_stub = true;       // Assume we need to generate the slow code stub.
+bool gen_pre_barrier = true;     // Assume we need to generate pre_barrier.
-bool gen_offset_check = true;       // Assume the code stub has to generate the offset guard.
+bool gen_offset_check = true;    // Assume we need to generate the offset guard.
-bool gen_source_check = true;       // Assume the code stub has to check the src object for null.
+bool gen_source_check = true;    // Assume we need to check the src object for null.
+bool gen_type_check = true;      // Assume we need to check the reference_type.
 if (off.is_constant()) {
 jlong off_con = (off.type()->is_int() ?
 (jlong) off.get_jint_constant() :
 off.get_jlong_constant());
 if (off_con != (jlong) java_lang_ref_Reference::referent_offset) {
 // The constant offset is something other than referent_offset.
 // We can skip generating/checking the remaining guards and
 // skip generation of the code stub.
-gen_code_stub = false;
+gen_pre_barrier = false;
 } else {
 // The constant offset is the same as referent_offset -
 // we do not need to generate a runtime offset check.
 gen_offset_check = false;
 }
 }
 // We don't need to generate stub if the source object is an array
-if (gen_code_stub && src.type()->is_array()) {
+if (gen_pre_barrier && src.type()->is_array()) {
-gen_code_stub = false;
+gen_pre_barrier = false;
 }
-if (gen_code_stub) {
+if (gen_pre_barrier) {
 // We still need to continue with the checks.
 if (src.is_constant()) {
 ciObject* src_con = src.get_jobject_constant();
 if (src_con->is_null_object()) {
 // The constant src object is null - We can skip
 // generating the code stub.
-gen_code_stub = false;
+gen_pre_barrier = false;
 } else {
 // Non-null constant source object. We still have to generate
 // the slow stub - but we don't need to generate the runtime
 // null object check.
 gen_source_check = false;
 }
 }
 }
+if (gen_pre_barrier && !PatchALot) {
-if (gen_code_stub) {
+// Can the klass of object be statically determined to be
-// Temoraries.
+// a sub-class of Reference?
-LIR_Opr src_klass = new_register(T_OBJECT);
+ciType* type = src.value()->declared_type();
+if ((type != NULL) && type->is_loaded()) {
-// Get the thread pointer for the pre-barrier
+if (type->is_subtype_of(compilation()->env()->Reference_klass())) {
-LIR_Opr thread = getThreadPointer();
+gen_type_check = false;
+} else if (type->is_klass() &&
-CodeStub* stub;
+!compilation()->env()->Object_klass()->is_subtype_of(type->as_klass())) {
+// Not Reference and not Object klass.
+gen_pre_barrier = false;
+}
+}
+}
+if (gen_pre_barrier) {
+LabelObj* Lcont = new LabelObj();
 // We can have generate one runtime check here. Let's start with
 // the offset check.
 if (gen_offset_check) {
-// if (offset == referent_offset) -> slow code stub
+// if (offset != referent_offset) -> continue
 // If offset is an int then we can do the comparison with the
 // referent_offset constant; otherwise we need to move
 // referent_offset into a temporary register and generate
 // a reg-reg compare.
 } else {
 assert(off.type()->is_long(), "what else?");
 referent_off = new_register(T_LONG);
 __ move(LIR_OprFact::longConst(java_lang_ref_Reference::referent_offset), referent_off);
 }
+__ cmp(lir_cond_notEqual, off.result(), referent_off);
-__ cmp(lir_cond_equal, off.result(), referent_off);
+__ branch(lir_cond_notEqual, as_BasicType(off.type()), Lcont->label());
+}
-// Optionally generate "src == null" check.
+if (gen_source_check) {
-stub = new G1UnsafeGetObjSATBBarrierStub(reg, src.result(),
+// offset is a const and equals referent offset
-src_klass, thread,
+// if (source == null) -> continue
-gen_source_check);
+__ cmp(lir_cond_equal, src.result(), LIR_OprFact::oopConst(NULL));
+__ branch(lir_cond_equal, T_OBJECT, Lcont->label());
-__ branch(lir_cond_equal, as_BasicType(off.type()), stub);
+}
-} else {
+LIR_Opr src_klass = new_register(T_OBJECT);
-if (gen_source_check) {
+if (gen_type_check) {
-// offset is a const and equals referent offset
+// We have determined that offset == referent_offset && src != null.
-// if (source != null) -> slow code stub
+// if (src->_klass->_reference_type == REF_NONE) -> continue
-__ cmp(lir_cond_notEqual, src.result(), LIR_OprFact::oopConst(NULL));
+__ move(new LIR_Address(src.result(), oopDesc::klass_offset_in_bytes(), T_OBJECT), src_klass);
+LIR_Address* reference_type_addr = new LIR_Address(src_klass, in_bytes(instanceKlass::reference_type_offset()), T_BYTE);
-// Since we are generating the "if src == null" guard here,
+LIR_Opr reference_type = new_register(T_INT);
-// there is no need to generate the "src == null" check again.
+__ move(reference_type_addr, reference_type);
-stub = new G1UnsafeGetObjSATBBarrierStub(reg, src.result(),
+__ cmp(lir_cond_equal, reference_type, LIR_OprFact::intConst(REF_NONE));
-src_klass, thread,
+__ branch(lir_cond_equal, T_INT, Lcont->label());
-false);
+}
+{
-__ branch(lir_cond_notEqual, T_OBJECT, stub);
+// We have determined that src->_klass->_reference_type != REF_NONE
-} else {
+// so register the value in the referent field with the pre-barrier.
-// We have statically determined that offset == referent_offset
+pre_barrier(LIR_OprFact::illegalOpr /* addr_opr */,
-// && src != null so we unconditionally branch to code stub
+value  /* pre_val */,
-// to perform the guards and record reg in the SATB log buffer.
+false  /* do_load */,
+false  /* patch */,
-stub = new G1UnsafeGetObjSATBBarrierStub(reg, src.result(),
+NULL   /* info */);
-src_klass, thread,
+}
-false);
+__ branch_destination(Lcont->label());
-__ branch(lir_cond_always, T_ILLEGAL, stub);
-}
-}
-// Continuation point
-__ branch_destination(stub->continuation());
 }
 }
 #endif // SERIALGC
 if (x->is_volatile() && os::is_MP()) __ membar_acquire();

changeset 13486	4f0635e148c1
parent 13391	30245956af37
child 13487	75aa4880b15f