diff --git a/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp b/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp index f0ed9687f112d..7476c234697bd 100644 --- a/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp +++ b/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp @@ -184,7 +184,6 @@ Node* BarrierSetC2::load_at_resolved(C2Access& access, const Type* val_type) con DecoratorSet decorators = access.decorators(); Node* adr = access.addr().node(); - const TypePtr* adr_type = access.addr().type(); bool mismatched = (decorators & C2_MISMATCHED) != 0; bool requires_atomic_access = (decorators & MO_UNORDERED) == 0; @@ -207,7 +206,7 @@ Node* BarrierSetC2::load_at_resolved(C2Access& access, const Type* val_type) con Compile* C = Compile::current(); Node* mem = kit->immutable_memory(); load = LoadNode::make(kit->gvn(), control, mem, adr, - adr_type, val_type, access.type(), mo, dep, requires_atomic_access, + val_type, access.type(), mo, dep, requires_atomic_access, unaligned, mismatched, unsafe, access.barrier_data()); load = kit->gvn().transform(load); } else { @@ -221,8 +220,8 @@ Node* BarrierSetC2::load_at_resolved(C2Access& access, const Type* val_type) con Node* control = control_dependent ? opt_access.ctl() : nullptr; MergeMemNode* mm = opt_access.mem(); PhaseGVN& gvn = opt_access.gvn(); - Node* mem = mm->memory_at(gvn.C->get_alias_index(adr_type)); - load = LoadNode::make(gvn, control, mem, adr, adr_type, val_type, access.type(), mo, dep, + Node* mem = mm->memory_at(gvn.C->get_alias_index(access.addr().type())); + load = LoadNode::make(gvn, control, mem, adr, val_type, access.type(), mo, dep, requires_atomic_access, unaligned, mismatched, unsafe, access.barrier_data()); load = gvn.transform(load); } diff --git a/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp b/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp index 536cd6da1ef8c..880522f555e8b 100644 --- a/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp +++ b/src/hotspot/share/gc/shared/c2/cardTableBarrierSetC2.cpp @@ -91,9 +91,6 @@ void CardTableBarrierSetC2::post_barrier(GraphKit* kit, // Combine card table base and card offset Node* card_adr = __ AddP(__ top(), byte_map_base_node(kit), card_offset); - // Get the alias_index for raw card-mark memory - int adr_type = Compile::AliasIdxRaw; - // Dirty card value to store Node* dirty = __ ConI(CardTable::dirty_card_val()); @@ -105,12 +102,12 @@ void CardTableBarrierSetC2::post_barrier(GraphKit* kit, // UseCondCardMark enables MP "polite" conditional card mark // stores. In theory we could relax the load from ctrl() to // no_ctrl, but that doesn't buy much latitude. - Node* card_val = __ load( __ ctrl(), card_adr, TypeInt::BYTE, T_BYTE, adr_type); + Node* card_val = __ load( __ ctrl(), card_adr, TypeInt::BYTE, T_BYTE); __ if_then(card_val, BoolTest::ne, dirty); } // Smash dirty value into card - __ store(__ ctrl(), card_adr, dirty, T_BYTE, adr_type, MemNode::unordered); + __ store(__ ctrl(), card_adr, dirty, T_BYTE, MemNode::unordered); if (UseCondCardMark) { __ end_if(); diff --git a/src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp b/src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp index f12b3dc5fa84a..f872ab5380692 100644 --- a/src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp +++ b/src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp @@ -215,7 +215,7 @@ void ShenandoahBarrierSetC2::satb_write_barrier_pre(GraphKit* kit, // Now some of the values Node* marking; Node* gc_state = __ AddP(no_base, tls, __ ConX(in_bytes(ShenandoahThreadLocalData::gc_state_offset()))); - Node* ld = __ load(__ ctrl(), gc_state, TypeInt::BYTE, T_BYTE, Compile::AliasIdxRaw); + Node* ld = __ load(__ ctrl(), gc_state, TypeInt::BYTE, T_BYTE); marking = __ AndI(ld, __ ConI(ShenandoahHeap::MARKING)); assert(ShenandoahBarrierC2Support::is_gc_state_load(ld), "Should match the shape"); @@ -223,7 +223,7 @@ void ShenandoahBarrierSetC2::satb_write_barrier_pre(GraphKit* kit, __ if_then(marking, BoolTest::ne, zero, unlikely); { BasicType index_bt = TypeX_X->basic_type(); assert(sizeof(size_t) == type2aelembytes(index_bt), "Loading Shenandoah SATBMarkQueue::_index with wrong size."); - Node* index = __ load(__ ctrl(), index_adr, TypeX_X, index_bt, Compile::AliasIdxRaw); + Node* index = __ load(__ ctrl(), index_adr, TypeX_X, index_bt); if (do_load) { // load original value @@ -233,7 +233,7 @@ void ShenandoahBarrierSetC2::satb_write_barrier_pre(GraphKit* kit, // if (pre_val != nullptr) __ if_then(pre_val, BoolTest::ne, kit->null()); { - Node* buffer = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw); + Node* buffer = __ load(__ ctrl(), buffer_adr, TypeRawPtr::NOTNULL, T_ADDRESS); // is the queue for this thread full? __ if_then(index, BoolTest::ne, zeroX, likely); { @@ -243,9 +243,9 @@ void ShenandoahBarrierSetC2::satb_write_barrier_pre(GraphKit* kit, // Now get the buffer location we will log the previous value into and store it Node *log_addr = __ AddP(no_base, buffer, next_index); - __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw, MemNode::unordered); + __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, MemNode::unordered); // update the index - __ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw, MemNode::unordered); + __ store(__ ctrl(), index_adr, next_index, index_bt, MemNode::unordered); } __ else_(); { @@ -483,7 +483,7 @@ void ShenandoahBarrierSetC2::post_barrier(GraphKit* kit, Node* curr_ct_holder_offset = __ ConX(in_bytes(ShenandoahThreadLocalData::card_table_offset())); Node* curr_ct_holder_addr = __ AddP(__ top(), tls, curr_ct_holder_offset); - Node* curr_ct_base_addr = __ load( __ ctrl(), curr_ct_holder_addr, TypeRawPtr::NOTNULL, T_ADDRESS, Compile::AliasIdxRaw); + Node* curr_ct_base_addr = __ load( __ ctrl(), curr_ct_holder_addr, TypeRawPtr::NOTNULL, T_ADDRESS); // Divide by card size Node* card_offset = __ URShiftX( cast, __ ConI(CardTable::card_shift()) ); @@ -491,8 +491,6 @@ void ShenandoahBarrierSetC2::post_barrier(GraphKit* kit, // Combine card table base and card offset Node* card_adr = __ AddP(__ top(), curr_ct_base_addr, card_offset); - // Get the alias_index for raw card-mark memory - int adr_type = Compile::AliasIdxRaw; Node* zero = __ ConI(0); // Dirty card value if (UseCondCardMark) { @@ -503,12 +501,12 @@ void ShenandoahBarrierSetC2::post_barrier(GraphKit* kit, // UseCondCardMark enables MP "polite" conditional card mark // stores. In theory we could relax the load from ctrl() to // no_ctrl, but that doesn't buy much latitude. - Node* card_val = __ load( __ ctrl(), card_adr, TypeInt::BYTE, T_BYTE, adr_type); + Node* card_val = __ load( __ ctrl(), card_adr, TypeInt::BYTE, T_BYTE); __ if_then(card_val, BoolTest::ne, zero); } // Smash zero into card - __ store(__ ctrl(), card_adr, zero, T_BYTE, adr_type, MemNode::unordered); + __ store(__ ctrl(), card_adr, zero, T_BYTE, MemNode::unordered); if (UseCondCardMark) { __ end_if(); diff --git a/src/hotspot/share/opto/callnode.cpp b/src/hotspot/share/opto/callnode.cpp index 3527e46c24b7c..e32ac23a98ff8 100644 --- a/src/hotspot/share/opto/callnode.cpp +++ b/src/hotspot/share/opto/callnode.cpp @@ -1661,12 +1661,13 @@ void AllocateNode::compute_MemBar_redundancy(ciMethod* initializer) _is_allocation_MemBar_redundant = true; } } + Node *AllocateNode::make_ideal_mark(PhaseGVN *phase, Node* obj, Node* control, Node* mem) { Node* mark_node = nullptr; if (UseCompactObjectHeaders) { Node* klass_node = in(AllocateNode::KlassNode); Node* proto_adr = phase->transform(new AddPNode(klass_node, klass_node, phase->MakeConX(in_bytes(Klass::prototype_header_offset())))); - mark_node = LoadNode::make(*phase, control, mem, proto_adr, TypeRawPtr::BOTTOM, TypeX_X, TypeX_X->basic_type(), MemNode::unordered); + mark_node = LoadNode::make(*phase, control, mem, proto_adr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered); } else { // For now only enable fast locking for non-array types mark_node = phase->MakeConX(markWord::prototype().value()); diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp index 20feca26ede55..a80769c1a362e 100644 --- a/src/hotspot/share/opto/graphKit.cpp +++ b/src/hotspot/share/opto/graphKit.cpp @@ -1576,7 +1576,7 @@ Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type = nullptr; // debug-mode-only argument DEBUG_ONLY(adr_type = C->get_adr_type(adr_idx)); Node* mem = memory(adr_idx); - Node* ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo, control_dependency, require_atomic_access, unaligned, mismatched, unsafe, barrier_data); + Node* ld = LoadNode::make(_gvn, ctl, mem, adr, t, bt, mo, control_dependency, require_atomic_access, unaligned, mismatched, unsafe, barrier_data); ld = _gvn.transform(ld); if (((bt == T_OBJECT) && C->do_escape_analysis()) || C->eliminate_boxing()) { // Improve graph before escape analysis and boxing elimination. @@ -2979,8 +2979,7 @@ void GraphKit::guard_klass_being_initialized(Node* klass) { int init_state_off = in_bytes(InstanceKlass::init_state_offset()); Node* adr = basic_plus_adr(top(), klass, init_state_off); Node* init_state = LoadNode::make(_gvn, nullptr, immutable_memory(), adr, - adr->bottom_type()->is_ptr(), TypeInt::BYTE, - T_BYTE, MemNode::acquire); + TypeInt::BYTE, T_BYTE, MemNode::acquire); init_state = _gvn.transform(init_state); Node* being_initialized_state = makecon(TypeInt::make(InstanceKlass::being_initialized)); @@ -2998,8 +2997,7 @@ void GraphKit::guard_init_thread(Node* klass) { Node* adr = basic_plus_adr(top(), klass, init_thread_off); Node* init_thread = LoadNode::make(_gvn, nullptr, immutable_memory(), adr, - adr->bottom_type()->is_ptr(), TypePtr::NOTNULL, - T_ADDRESS, MemNode::unordered); + TypePtr::NOTNULL, T_ADDRESS, MemNode::unordered); init_thread = _gvn.transform(init_thread); Node* cur_thread = _gvn.transform(new ThreadLocalNode()); diff --git a/src/hotspot/share/opto/idealKit.cpp b/src/hotspot/share/opto/idealKit.cpp index dd7e9ae52b778..82ad9cdd3828f 100644 --- a/src/hotspot/share/opto/idealKit.cpp +++ b/src/hotspot/share/opto/idealKit.cpp @@ -347,23 +347,22 @@ Node* IdealKit::load(Node* ctl, Node* adr, const Type* t, BasicType bt, - int adr_idx, bool require_atomic_access, MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency) { - + int adr_idx = C->get_alias_index(_gvn.type(adr)->isa_ptr()); assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" ); const TypePtr* adr_type = nullptr; // debug-mode-only argument DEBUG_ONLY(adr_type = C->get_adr_type(adr_idx)); Node* mem = memory(adr_idx); - Node* ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo, control_dependency, require_atomic_access); + Node* ld = LoadNode::make(_gvn, ctl, mem, adr, t, bt, mo, control_dependency, require_atomic_access); return transform(ld); } Node* IdealKit::store(Node* ctl, Node* adr, Node *val, BasicType bt, - int adr_idx, MemNode::MemOrd mo, bool require_atomic_access, bool mismatched) { + int adr_idx = C->get_alias_index(_gvn.type(adr)->isa_ptr()); assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory"); const TypePtr* adr_type = nullptr; DEBUG_ONLY(adr_type = C->get_adr_type(adr_idx)); diff --git a/src/hotspot/share/opto/idealKit.hpp b/src/hotspot/share/opto/idealKit.hpp index 9916701fad722..242e924b5a49a 100644 --- a/src/hotspot/share/opto/idealKit.hpp +++ b/src/hotspot/share/opto/idealKit.hpp @@ -219,7 +219,6 @@ class IdealKit: public StackObj { Node* adr, const Type* t, BasicType bt, - int adr_idx, bool require_atomic_access = false, MemNode::MemOrd mo = MemNode::unordered, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest); @@ -229,7 +228,6 @@ class IdealKit: public StackObj { Node* adr, Node* val, BasicType bt, - int adr_idx, MemNode::MemOrd mo, bool require_atomic_access = false, bool mismatched = false); diff --git a/src/hotspot/share/opto/library_call.cpp b/src/hotspot/share/opto/library_call.cpp index 8a31711f85e0e..95987bc13b962 100644 --- a/src/hotspot/share/opto/library_call.cpp +++ b/src/hotspot/share/opto/library_call.cpp @@ -974,7 +974,7 @@ Node* LibraryCallKit::current_thread_helper(Node*& tls_output, ByteSize handle_o Node* thread_obj_handle = (is_immutable - ? LoadNode::make(_gvn, nullptr, immutable_memory(), p, p->bottom_type()->is_ptr(), + ? LoadNode::make(_gvn, nullptr, immutable_memory(), p, TypeRawPtr::NOTNULL, T_ADDRESS, MemNode::unordered) : make_load(nullptr, p, p->bottom_type()->is_ptr(), T_ADDRESS, MemNode::unordered)); thread_obj_handle = _gvn.transform(thread_obj_handle); @@ -3005,7 +3005,7 @@ bool LibraryCallKit::inline_native_notify_jvmti_funcs(address funcAddr, const ch Node* ONE = ideal.ConI(1); Node* hide = is_start ? ideal.ConI(0) : (is_end ? ideal.ConI(1) : _gvn.transform(argument(1))); Node* addr = makecon(TypeRawPtr::make((address)&JvmtiVTMSTransitionDisabler::_VTMS_notify_jvmti_events)); - Node* notify_jvmti_enabled = ideal.load(ideal.ctrl(), addr, TypeInt::BOOL, T_BOOLEAN, Compile::AliasIdxRaw); + Node* notify_jvmti_enabled = ideal.load(ideal.ctrl(), addr, TypeInt::BOOL, T_BOOLEAN); ideal.if_then(notify_jvmti_enabled, BoolTest::eq, ONE); { sync_kit(ideal); @@ -3087,10 +3087,10 @@ bool LibraryCallKit::inline_native_classID() { __ if_then(kls, BoolTest::ne, null()); { Node* kls_trace_id_addr = basic_plus_adr(kls, in_bytes(KLASS_TRACE_ID_OFFSET)); - Node* kls_trace_id_raw = ideal.load(ideal.ctrl(), kls_trace_id_addr,TypeLong::LONG, T_LONG, Compile::AliasIdxRaw); + Node* kls_trace_id_raw = ideal.load(ideal.ctrl(), kls_trace_id_addr,TypeLong::LONG, T_LONG); Node* epoch_address = makecon(TypeRawPtr::make(JfrIntrinsicSupport::epoch_address())); - Node* epoch = ideal.load(ideal.ctrl(), epoch_address, TypeInt::BOOL, T_BOOLEAN, Compile::AliasIdxRaw); + Node* epoch = ideal.load(ideal.ctrl(), epoch_address, TypeInt::BOOL, T_BOOLEAN); epoch = _gvn.transform(new LShiftLNode(longcon(1), epoch)); Node* mask = _gvn.transform(new LShiftLNode(epoch, intcon(META_SHIFT))); mask = _gvn.transform(new OrLNode(mask, epoch)); @@ -3115,7 +3115,7 @@ bool LibraryCallKit::inline_native_classID() { TypeRawPtr::BOTTOM, TypeInstKlassPtr::OBJECT_OR_NULL)); __ if_then(array_kls, BoolTest::ne, null()); { Node* array_kls_trace_id_addr = basic_plus_adr(array_kls, in_bytes(KLASS_TRACE_ID_OFFSET)); - Node* array_kls_trace_id_raw = ideal.load(ideal.ctrl(), array_kls_trace_id_addr, TypeLong::LONG, T_LONG, Compile::AliasIdxRaw); + Node* array_kls_trace_id_raw = ideal.load(ideal.ctrl(), array_kls_trace_id_addr, TypeLong::LONG, T_LONG); Node* array_kls_trace_id = _gvn.transform(new URShiftLNode(array_kls_trace_id_raw, ideal.ConI(TRACE_ID_SHIFT))); ideal.set(result, _gvn.transform(new AddLNode(array_kls_trace_id, longcon(1)))); } __ else_(); { @@ -3124,9 +3124,9 @@ bool LibraryCallKit::inline_native_classID() { } __ end_if(); Node* signaled_flag_address = makecon(TypeRawPtr::make(JfrIntrinsicSupport::signal_address())); - Node* signaled = ideal.load(ideal.ctrl(), signaled_flag_address, TypeInt::BOOL, T_BOOLEAN, Compile::AliasIdxRaw, true, MemNode::acquire); + Node* signaled = ideal.load(ideal.ctrl(), signaled_flag_address, TypeInt::BOOL, T_BOOLEAN, true, MemNode::acquire); __ if_then(signaled, BoolTest::ne, ideal.ConI(1)); { - ideal.store(ideal.ctrl(), signaled_flag_address, ideal.ConI(1), T_BOOLEAN, Compile::AliasIdxRaw, MemNode::release, true); + ideal.store(ideal.ctrl(), signaled_flag_address, ideal.ConI(1), T_BOOLEAN, MemNode::release, true); } __ end_if(); } __ end_if(); diff --git a/src/hotspot/share/opto/macro.cpp b/src/hotspot/share/opto/macro.cpp index c6ed2411fe306..a9ca4af0c9309 100644 --- a/src/hotspot/share/opto/macro.cpp +++ b/src/hotspot/share/opto/macro.cpp @@ -1166,8 +1166,7 @@ bool PhaseMacroExpand::eliminate_boxing_node(CallStaticJavaNode *boxing) { Node* PhaseMacroExpand::make_load(Node* ctl, Node* mem, Node* base, int offset, const Type* value_type, BasicType bt) { Node* adr = basic_plus_adr(base, offset); - const TypePtr* adr_type = adr->bottom_type()->is_ptr(); - Node* value = LoadNode::make(_igvn, ctl, mem, adr, adr_type, value_type, bt, MemNode::unordered); + Node* value = LoadNode::make(_igvn, ctl, mem, adr, value_type, bt, MemNode::unordered); transform_later(value); return value; } diff --git a/src/hotspot/share/opto/macroArrayCopy.cpp b/src/hotspot/share/opto/macroArrayCopy.cpp index e2209fddbdfa0..639523c80a926 100644 --- a/src/hotspot/share/opto/macroArrayCopy.cpp +++ b/src/hotspot/share/opto/macroArrayCopy.cpp @@ -1027,7 +1027,7 @@ bool PhaseMacroExpand::generate_block_arraycopy(Node** ctrl, MergeMemNode** mem, uint d_alias_idx = C->get_alias_index(adr_type); bool is_mismatched = (basic_elem_type != T_INT); Node* sval = transform_later( - LoadNode::make(_igvn, *ctrl, (*mem)->memory_at(s_alias_idx), sptr, s_adr_type, + LoadNode::make(_igvn, *ctrl, (*mem)->memory_at(s_alias_idx), sptr, TypeInt::INT, T_INT, MemNode::unordered, LoadNode::DependsOnlyOnTest, false /*require_atomic_access*/, false /*unaligned*/, is_mismatched)); Node* st = transform_later( diff --git a/src/hotspot/share/opto/memnode.cpp b/src/hotspot/share/opto/memnode.cpp index 24b81b894cb1a..c6b5347b6707d 100644 --- a/src/hotspot/share/opto/memnode.cpp +++ b/src/hotspot/share/opto/memnode.cpp @@ -944,9 +944,10 @@ bool LoadNode::is_immutable_value(Node* adr) { //----------------------------LoadNode::make----------------------------------- // Polymorphic factory method: -Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, BasicType bt, MemOrd mo, +Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const Type* rt, BasicType bt, MemOrd mo, ControlDependency control_dependency, bool require_atomic_access, bool unaligned, bool mismatched, bool unsafe, uint8_t barrier_data) { Compile* C = gvn.C; + const TypePtr* adr_type = gvn.type(adr)->isa_ptr(); // sanity check the alias category against the created node type assert(!(adr_type->isa_oopptr() && @@ -1352,7 +1353,7 @@ Node* LoadNode::convert_to_unsigned_load(PhaseGVN& gvn) { return nullptr; } return LoadNode::make(gvn, in(MemNode::Control), in(MemNode::Memory), in(MemNode::Address), - raw_adr_type(), rt, bt, _mo, _control_dependency, + rt, bt, _mo, _control_dependency, false /*require_atomic_access*/, is_unaligned_access(), is_mismatched_access()); } @@ -1372,7 +1373,7 @@ Node* LoadNode::convert_to_signed_load(PhaseGVN& gvn) { return nullptr; } return LoadNode::make(gvn, in(MemNode::Control), in(MemNode::Memory), in(MemNode::Address), - raw_adr_type(), rt, bt, _mo, _control_dependency, + rt, bt, _mo, _control_dependency, false /*require_atomic_access*/, is_unaligned_access(), is_mismatched_access()); } @@ -1400,7 +1401,7 @@ Node* LoadNode::convert_to_reinterpret_load(PhaseGVN& gvn, const Type* rt) { bool require_atomic_access = (op == Op_LoadL && ((LoadLNode*)this)->require_atomic_access()) || (op == Op_LoadD && ((LoadDNode*)this)->require_atomic_access()); return LoadNode::make(gvn, in(MemNode::Control), in(MemNode::Memory), in(MemNode::Address), - raw_adr_type(), rt, bt, _mo, _control_dependency, + rt, bt, _mo, _control_dependency, require_atomic_access, is_unaligned_access(), is_mismatched); } diff --git a/src/hotspot/share/opto/memnode.hpp b/src/hotspot/share/opto/memnode.hpp index 810a9fe9445de..552b62d21f5f7 100644 --- a/src/hotspot/share/opto/memnode.hpp +++ b/src/hotspot/share/opto/memnode.hpp @@ -233,8 +233,7 @@ class LoadNode : public MemNode { } // Polymorphic factory method: - static Node* make(PhaseGVN& gvn, Node* c, Node* mem, Node* adr, - const TypePtr* at, const Type* rt, BasicType bt, + static Node* make(PhaseGVN& gvn, Node* c, Node* mem, Node* adr, const Type* rt, BasicType bt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false, bool unaligned = false, bool mismatched = false, bool unsafe = false, uint8_t barrier_data = 0); diff --git a/src/hotspot/share/opto/stringopts.cpp b/src/hotspot/share/opto/stringopts.cpp index 793145e078d6d..4b79daadef88d 100644 --- a/src/hotspot/share/opto/stringopts.cpp +++ b/src/hotspot/share/opto/stringopts.cpp @@ -1539,7 +1539,7 @@ void PhaseStringOpts::copy_constant_string(GraphKit& kit, IdealKit& ideal, ciTyp for (int i = 0; i < length; i++) { Node* adr = kit.array_element_address(dst_array, index, T_BYTE); Node* val = __ ConI(src_array->byte_at(i)); - __ store(__ ctrl(), adr, val, T_BYTE, byte_adr_idx, MemNode::unordered); + __ store(__ ctrl(), adr, val, T_BYTE, MemNode::unordered); index = __ AddI(index, __ ConI(1)); } } @@ -1557,7 +1557,7 @@ void PhaseStringOpts::copy_constant_string(GraphKit& kit, IdealKit& ideal, ciTyp } else { val = readChar(src_array, i++); } - __ store(__ ctrl(), adr, __ ConI(val), T_CHAR, byte_adr_idx, MemNode::unordered, false /* require_atomic_access */, + __ store(__ ctrl(), adr, __ ConI(val), T_CHAR, MemNode::unordered, false /* require_atomic_access */, true /* mismatched */); index = __ AddI(index, __ ConI(2)); } @@ -1637,7 +1637,7 @@ Node* PhaseStringOpts::copy_char(GraphKit& kit, Node* val, Node* dst_array, Node } if (!dcon || dbyte) { // Destination is Latin1. Store a byte. - __ store(__ ctrl(), adr, val, T_BYTE, byte_adr_idx, MemNode::unordered); + __ store(__ ctrl(), adr, val, T_BYTE, MemNode::unordered); __ set(end, __ AddI(start, __ ConI(1))); } if (!dcon) { @@ -1645,7 +1645,7 @@ Node* PhaseStringOpts::copy_char(GraphKit& kit, Node* val, Node* dst_array, Node } if (!dcon || !dbyte) { // Destination is UTF16. Store a char. - __ store(__ ctrl(), adr, val, T_CHAR, byte_adr_idx, MemNode::unordered, false /* require_atomic_access */, + __ store(__ ctrl(), adr, val, T_CHAR, MemNode::unordered, false /* require_atomic_access */, true /* mismatched */); __ set(end, __ AddI(start, __ ConI(2))); }