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

equal deleted inserted replaced

-:b245fac3b6a4
+:d8812d0ff387
 Node* LibraryCallKit::generate_current_thread(Node* &tls_output) {
 ciKlass*    thread_klass = env()->Thread_klass();
 const Type* thread_type  = TypeOopPtr::make_from_klass(thread_klass)->cast_to_ptr_type(TypePtr::NotNull);
 Node* thread = _gvn.transform(new (C) ThreadLocalNode());
 Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::threadObj_offset()));
-Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT);
+Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT, MemNode::unordered);
 tls_output = thread;
 return threadObj;
 }
 // of safe & unsafe memory.  Otherwise fails in a CTW of rt.jar
 // around 5701, class sun/reflect/UnsafeBooleanFieldAccessorImpl.
 if (need_mem_bar) insert_mem_bar(Op_MemBarCPUOrder);
 if (!is_store) {
-Node* p = make_load(control(), adr, value_type, type, adr_type, is_volatile);
+Node* p = make_load(control(), adr, value_type, type, adr_type, MemNode::unordered, is_volatile);
 // load value
 switch (type) {
 case T_BOOLEAN:
 case T_CHAR:
 case T_BYTE:
 val = ConvL2X(val);
 val = _gvn.transform(new (C) CastX2PNode(val));
 break;
 }
+MemNode::MemOrd mo = is_volatile ? MemNode::release : MemNode::unordered;
 if (type != T_OBJECT ) {
-(void) store_to_memory(control(), adr, val, type, adr_type, is_volatile);
+(void) store_to_memory(control(), adr, val, type, adr_type, mo, is_volatile);
 } else {
 // Possibly an oop being stored to Java heap or native memory
 if (!TypePtr::NULL_PTR->higher_equal(_gvn.type(heap_base_oop))) {
 // oop to Java heap.
-(void) store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
+(void) store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type, mo);
 } else {
 // We can't tell at compile time if we are storing in the Java heap or outside
 // of it. So we need to emit code to conditionally do the proper type of
 // store.
 #define __ ideal.
 // QQQ who knows what probability is here??
 __ if_then(heap_base_oop, BoolTest::ne, null(), PROB_UNLIKELY(0.999)); {
 // Sync IdealKit and graphKit.
 sync_kit(ideal);
-Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type);
+Node* st = store_oop_to_unknown(control(), heap_base_oop, adr, adr_type, val, type, mo);
 // Update IdealKit memory.
 __ sync_kit(this);
 } __ else_(); {
-__ store(__ ctrl(), adr, val, type, alias_type->index(), is_volatile);
+__ store(__ ctrl(), adr, val, type, alias_type->index(), mo, is_volatile);
 } __ end_if();
 // Final sync IdealKit and GraphKit.
 final_sync(ideal);
 #undef __
 }
 #ifdef _LP64
 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
 Node *newval_enc = _gvn.transform(new (C) EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
 if (kind == LS_xchg) {
 load_store = _gvn.transform(new (C) GetAndSetNNode(control(), mem, adr,
 newval_enc, adr_type, value_type->make_narrowoop()));
 } else {
 assert(kind == LS_cmpxchg, "wrong LoadStore operation");
 Node *oldval_enc = _gvn.transform(new (C) EncodePNode(oldval, oldval->bottom_type()->make_narrowoop()));
 load_store = _gvn.transform(new (C) CompareAndSwapNNode(control(), mem, adr,
 newval_enc, oldval_enc));
 }
 } else
 #endif
 {
 if (kind == LS_xchg) {
 insert_mem_bar(Op_MemBarCPUOrder);
 // Ensure that the store is atomic for longs:
 const bool require_atomic_access = true;
 Node* store;
 if (type == T_OBJECT) // reference stores need a store barrier.
-store = store_oop_to_unknown(control(), base, adr, adr_type, val, type);
+store = store_oop_to_unknown(control(), base, adr, adr_type, val, type, MemNode::release);
 else {
-store = store_to_memory(control(), adr, val, type, adr_type, require_atomic_access);
+store = store_to_memory(control(), adr, val, type, adr_type, MemNode::release, require_atomic_access);
 }
 insert_mem_bar(Op_MemBarCPUOrder);
 return true;
 }
 // Serializable.class or Object[].class.   The runtime will handle it.
 // But we must make an explicit check for initialization.
 Node* insp = basic_plus_adr(kls, in_bytes(InstanceKlass::init_state_offset()));
 // Use T_BOOLEAN for InstanceKlass::_init_state so the compiler
 // can generate code to load it as unsigned byte.
-Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN);
+Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN, MemNode::unordered);
 Node* bits = intcon(InstanceKlass::fully_initialized);
 test = _gvn.transform(new (C) SubINode(inst, bits));
 // The 'test' is non-zero if we need to take a slow path.
 }
 Node* cls = null_check(argument(1), T_OBJECT);
 Node* kls = load_klass_from_mirror(cls, false, NULL, 0);
 kls = null_check(kls, T_OBJECT);
 ByteSize offset = TRACE_ID_OFFSET;
 Node* insp = basic_plus_adr(kls, in_bytes(offset));
-Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG);
+Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG, MemNode::unordered);
 Node* bits = longcon(~0x03l); // ignore bit 0 & 1
 Node* andl = _gvn.transform(new (C) AndLNode(tvalue, bits));
 Node* clsused = longcon(0x01l); // set the class bit
 Node* orl = _gvn.transform(new (C) OrLNode(tvalue, clsused));
 const TypePtr *adr_type = _gvn.type(insp)->isa_ptr();
-store_to_memory(control(), insp, orl, T_LONG, adr_type);
+store_to_memory(control(), insp, orl, T_LONG, adr_type, MemNode::unordered);
 set_result(andl);
 return true;
 }
 bool LibraryCallKit::inline_native_threadID() {
 Node* tls_ptr = NULL;
 Node* cur_thr = generate_current_thread(tls_ptr);
 Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset()));
-Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS);
+Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::thread_id_offset()));
 Node* threadid = NULL;
 size_t thread_id_size = OSThread::thread_id_size();
 if (thread_id_size == (size_t) BytesPerLong) {
-threadid = ConvL2I(make_load(control(), p, TypeLong::LONG, T_LONG));
+threadid = ConvL2I(make_load(control(), p, TypeLong::LONG, T_LONG, MemNode::unordered));
 } else if (thread_id_size == (size_t) BytesPerInt) {
-threadid = make_load(control(), p, TypeInt::INT, T_INT);
+threadid = make_load(control(), p, TypeInt::INT, T_INT, MemNode::unordered);
 } else {
 ShouldNotReachHere();
 }
 set_result(threadid);
 return true;
 generate_slow_guard(bol_thr, slow_region);
 // (b) Interrupt bit on TLS must be false.
 Node* p = basic_plus_adr(top()/*!oop*/, tls_ptr, in_bytes(JavaThread::osthread_offset()));
-Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS);
+Node* osthread = make_load(NULL, p, TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 p = basic_plus_adr(top()/*!oop*/, osthread, in_bytes(OSThread::interrupted_offset()));
 // Set the control input on the field _interrupted read to prevent it floating up.
-Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT);
+Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT, MemNode::unordered);
 Node* cmp_bit = _gvn.transform(new (C) CmpINode(int_bit, intcon(0)));
 Node* bol_bit = _gvn.transform(new (C) BoolNode(cmp_bit, BoolTest::ne));
 IfNode* iff_bit = create_and_map_if(control(), bol_bit, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
 //---------------------------load_mirror_from_klass----------------------------
 // Given a klass oop, load its java mirror (a java.lang.Class oop).
 Node* LibraryCallKit::load_mirror_from_klass(Node* klass) {
 Node* p = basic_plus_adr(klass, in_bytes(Klass::java_mirror_offset()));
-return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT);
+return make_load(NULL, p, TypeInstPtr::MIRROR, T_OBJECT, MemNode::unordered);
 }
 //-----------------------load_klass_from_mirror_common-------------------------
 // Given a java mirror (a java.lang.Class oop), load its corresponding klass oop.
 // Test the klass oop for null (signifying a primitive Class like Integer.TYPE),
 // Fall through if (mods & mask) == bits, take the guard otherwise.
 Node* LibraryCallKit::generate_access_flags_guard(Node* kls, int modifier_mask, int modifier_bits, RegionNode* region) {
 // Branch around if the given klass has the given modifier bit set.
 // Like generate_guard, adds a new path onto the region.
 Node* modp = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
-Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT);
+Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT, MemNode::unordered);
 Node* mask = intcon(modifier_mask);
 Node* bits = intcon(modifier_bits);
 Node* mbit = _gvn.transform(new (C) AndINode(mods, mask));
 Node* cmp  = _gvn.transform(new (C) CmpINode(mbit, bits));
 Node* bol  = _gvn.transform(new (C) BoolNode(cmp, BoolTest::ne));
 query_value = gen_instanceof(obj, kls, safe_for_replace);
 break;
 case vmIntrinsics::_getModifiers:
 p = basic_plus_adr(kls, in_bytes(Klass::modifier_flags_offset()));
-query_value = make_load(NULL, p, TypeInt::INT, T_INT);
+query_value = make_load(NULL, p, TypeInt::INT, T_INT, MemNode::unordered);
 break;
 case vmIntrinsics::_isInterface:
 // (To verify this code sequence, check the asserts in JVM_IsInterface.)
 if (generate_interface_guard(kls, region) != NULL)
 case vmIntrinsics::_getComponentType:
 if (generate_array_guard(kls, region) != NULL) {
 // Be sure to pin the oop load to the guard edge just created:
 Node* is_array_ctrl = region->in(region->req()-1);
 Node* cma = basic_plus_adr(kls, in_bytes(ArrayKlass::component_mirror_offset()));
-Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
+Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT, MemNode::unordered);
 phi->add_req(cmo);
 }
 query_value = null();  // non-array case is null
 break;
 case vmIntrinsics::_getClassAccessFlags:
 p = basic_plus_adr(kls, in_bytes(Klass::access_flags_offset()));
-query_value = make_load(NULL, p, TypeInt::INT, T_INT);
+query_value = make_load(NULL, p, TypeInt::INT, T_INT, MemNode::unordered);
 break;
 default:
 fatal_unexpected_iid(id);
 break;
 // Get the Method* out of the appropriate vtable entry.
 int entry_offset  = (InstanceKlass::vtable_start_offset() +
 vtable_index*vtableEntry::size()) * wordSize +
 vtableEntry::method_offset_in_bytes();
 Node* entry_addr  = basic_plus_adr(obj_klass, entry_offset);
-Node* target_call = make_load(NULL, entry_addr, TypePtr::NOTNULL, T_ADDRESS);
+Node* target_call = make_load(NULL, entry_addr, TypePtr::NOTNULL, T_ADDRESS, MemNode::unordered);
 // Compare the target method with the expected method (e.g., Object.hashCode).
 const TypePtr* native_call_addr = TypeMetadataPtr::make(method);
 Node* native_call = makecon(native_call_addr);
 generate_virtual_guard(obj_klass, slow_region);
 }
 // Get the header out of the object, use LoadMarkNode when available
 Node* header_addr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
-Node* header = make_load(control(), header_addr, TypeX_X, TypeX_X->basic_type());
+Node* header = make_load(control(), header_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
 // Test the header to see if it is unlocked.
 Node *lock_mask      = _gvn.MakeConX(markOopDesc::biased_lock_mask_in_place);
 Node *lmasked_header = _gvn.transform(new (C) AndXNode(header, lock_mask));
 Node *unlocked_val   = _gvn.MakeConX(markOopDesc::unlocked_value);
 start = _gvn.transform(new(C) AndXNode(start, MakeConX(~to_clear)));
 if (bump_bit != 0) {
 // Store a zero to the immediately preceding jint:
 Node* x1 = _gvn.transform(new(C) AddXNode(start, MakeConX(-bump_bit)));
 Node* p1 = basic_plus_adr(dest, x1);
-mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT);
+mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT, MemNode::unordered);
 mem = _gvn.transform(mem);
 }
 }
 Node* end = dest_size; // pre-rounded
 mem = ClearArrayNode::clear_memory(control(), mem, dest,
 // This is a common case, since abase can be odd mod 8.
 if (((src_off | dest_off) & (BytesPerLong-1)) == BytesPerInt &&
 ((src_off ^ dest_off) & (BytesPerLong-1)) == 0) {
 Node* sptr = basic_plus_adr(src,  src_off);
 Node* dptr = basic_plus_adr(dest, dest_off);
-Node* sval = make_load(control(), sptr, TypeInt::INT, T_INT, adr_type);
+Node* sval = make_load(control(), sptr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
-store_to_memory(control(), dptr, sval, T_INT, adr_type);
+store_to_memory(control(), dptr, sval, T_INT, adr_type, MemNode::unordered);
 src_off += BytesPerInt;
 dest_off += BytesPerInt;
 } else {
 return false;
 }
 // for the target array.  This is an optimistic check.  It will
 // look in each non-null element's class, at the desired klass's
 // super_check_offset, for the desired klass.
 int sco_offset = in_bytes(Klass::super_check_offset_offset());
 Node* p3 = basic_plus_adr(dest_elem_klass, sco_offset);
-Node* n3 = new(C) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr());
+Node* n3 = new(C) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr(), TypeInt::INT, MemNode::unordered);
 Node* check_offset = ConvI2X(_gvn.transform(n3));
 Node* check_value  = dest_elem_klass;
 Node* src_start  = array_element_address(src,  src_offset,  T_OBJECT);
 Node* dest_start = array_element_address(dest, dest_offset, T_OBJECT);
 result = _gvn.transform(new (C) AndINode(result, intcon(0xFF)));
 Node* base = makecon(TypeRawPtr::make(StubRoutines::crc_table_addr()));
 Node* offset = _gvn.transform(new (C) LShiftINode(result, intcon(0x2)));
 Node* adr = basic_plus_adr(top(), base, ConvI2X(offset));
-result = make_load(control(), adr, TypeInt::INT, T_INT);
+result = make_load(control(), adr, TypeInt::INT, T_INT, MemNode::unordered);
 crc = _gvn.transform(new (C) URShiftINode(crc, intcon(8)));
 result = _gvn.transform(new (C) XorINode(crc, result));
 result = _gvn.transform(new (C) XorINode(result, M1));
 set_result(result);
 ciInstanceKlass* klass = env()->Object_klass();
 const TypeOopPtr* object_type = TypeOopPtr::make_from_klass(klass);
 Node* no_ctrl = NULL;
-Node* result = make_load(no_ctrl, adr, object_type, T_OBJECT);
+Node* result = make_load(no_ctrl, adr, object_type, T_OBJECT, MemNode::unordered);
 // Use the pre-barrier to record the value in the referent field
 pre_barrier(false /* do_load */,
 control(),
 NULL /* obj */, NULL /* adr */, max_juint /* alias_idx */, NULL /* val */, NULL /* val_type */,
 // Build the resultant type of the load
 const Type *type = TypeOopPtr::make_from_klass(field_klass->as_klass());
 // Build the load.
-Node* loadedField = make_load(NULL, adr, type, bt, adr_type, is_vol);
+Node* loadedField = make_load(NULL, adr, type, bt, adr_type, MemNode::unordered, is_vol);
 return loadedField;
 }
 //------------------------------inline_aescrypt_Block-----------------------

changeset 22845	d8812d0ff387
parent 21207	1331f7d48dd8
child 22855	d637fd28a6c3