Skip to content

Commit 1019581

Browse files
rkennkerkennke
committed
8255691: Shenandoah: Invoke native-LRB only on non-strong refs
Reviewed-by: zgu
1 parent d2812f7 commit 1019581

14 files changed

+81
-80
lines changed

‎src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -262,7 +262,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembl
262262
__ leave();
263263
}
264264

265-
void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler* masm, Register dst, Address load_addr) {
265+
void ShenandoahBarrierSetAssembler::load_reference_barrier_weak(MacroAssembler* masm, Register dst, Address load_addr) {
266266
if (!ShenandoahLoadRefBarrier) {
267267
return;
268268
}
@@ -272,7 +272,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler
272272
Label is_null;
273273
Label done;
274274

275-
__ block_comment("load_reference_barrier_native { ");
275+
__ block_comment("load_reference_barrier_weak { ");
276276

277277
__ cbz(dst, is_null);
278278

@@ -286,7 +286,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler
286286

287287
__ mov(rscratch2, dst);
288288
__ push_call_clobbered_registers();
289-
__ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native));
289+
__ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak));
290290
__ lea(r1, load_addr);
291291
__ mov(r0, rscratch2);
292292
__ blr(lr);
@@ -297,7 +297,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler
297297
__ bind(done);
298298
__ leave();
299299
__ bind(is_null);
300-
__ block_comment("} load_reference_barrier_native");
300+
__ block_comment("} load_reference_barrier_weak");
301301
}
302302

303303
void ShenandoahBarrierSetAssembler::storeval_barrier(MacroAssembler* masm, Register dst, Register tmp) {
@@ -352,8 +352,8 @@ void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet d
352352

353353
BarrierSetAssembler::load_at(masm, decorators, type, dst, src, tmp1, tmp_thread);
354354

355-
if (ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type)) {
356-
load_reference_barrier_native(masm, dst, src);
355+
if (ShenandoahBarrierSet::use_load_reference_barrier_weak(decorators, type)) {
356+
load_reference_barrier_weak(masm, dst, src);
357357
} else {
358358
load_reference_barrier(masm, dst, src);
359359
}
@@ -669,8 +669,8 @@ void ShenandoahBarrierSetAssembler::gen_load_reference_barrier_stub(LIR_Assemble
669669
__ bind(slow_path);
670670
ce->store_parameter(res, 0);
671671
ce->store_parameter(addr, 1);
672-
if (stub->is_native()) {
673-
__ far_call(RuntimeAddress(bs->load_reference_barrier_native_rt_code_blob()->code_begin()));
672+
if (stub->is_weak()) {
673+
__ far_call(RuntimeAddress(bs->load_reference_barrier_weak_rt_code_blob()->code_begin()));
674674
} else {
675675
__ far_call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin()));
676676
}
@@ -728,15 +728,15 @@ void ShenandoahBarrierSetAssembler::generate_c1_pre_barrier_runtime_stub(StubAss
728728
__ epilogue();
729729
}
730730

731-
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_native) {
731+
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_weak) {
732732
__ prologue("shenandoah_load_reference_barrier", false);
733733
// arg0 : object to be resolved
734734

735735
__ push_call_clobbered_registers();
736736
__ load_parameter(0, r0);
737737
__ load_parameter(1, r1);
738-
if (is_native) {
739-
__ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native));
738+
if (is_weak) {
739+
__ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak));
740740
} else if (UseCompressedOops) {
741741
__ mov(lr, CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow));
742742
} else {

‎src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
5959
void resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst, Register tmp = noreg);
6060
void load_reference_barrier(MacroAssembler* masm, Register dst, Address load_addr);
6161
void load_reference_barrier_not_null(MacroAssembler* masm, Register dst, Address load_addr);
62-
void load_reference_barrier_native(MacroAssembler* masm, Register dst, Address load_addr);
62+
void load_reference_barrier_weak(MacroAssembler* masm, Register dst, Address load_addr);
6363

6464
address generate_shenandoah_lrb(StubCodeGenerator* cgen);
6565

@@ -72,7 +72,7 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
7272
void gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub);
7373
void gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub);
7474
void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);
75-
void generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_native);
75+
void generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_weak);
7676
#endif
7777

7878
virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, bool is_oop,

‎src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.cpp

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -336,15 +336,15 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembl
336336
#endif
337337
}
338338

339-
void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler* masm, Register dst, Address src) {
339+
void ShenandoahBarrierSetAssembler::load_reference_barrier_weak(MacroAssembler* masm, Register dst, Address src) {
340340
if (!ShenandoahLoadRefBarrier) {
341341
return;
342342
}
343343

344344
Label done;
345345
Label not_null;
346346
Label slow_path;
347-
__ block_comment("load_reference_barrier_native { ");
347+
__ block_comment("load_reference_barrier_weak { ");
348348

349349
// null check
350350
__ testptr(dst, dst);
@@ -396,7 +396,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler
396396
__ lea(rsi, src);
397397

398398
save_xmm_registers(masm);
399-
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), dst, rsi);
399+
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak), dst, rsi);
400400
restore_xmm_registers(masm);
401401

402402
#ifdef _LP64
@@ -420,7 +420,7 @@ void ShenandoahBarrierSetAssembler::load_reference_barrier_native(MacroAssembler
420420
}
421421

422422
__ bind(done);
423-
__ block_comment("load_reference_barrier_native { ");
423+
__ block_comment("} load_reference_barrier_weak");
424424
}
425425

426426
void ShenandoahBarrierSetAssembler::storeval_barrier(MacroAssembler* masm, Register dst, Register tmp) {
@@ -517,8 +517,8 @@ void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet d
517517

518518
BarrierSetAssembler::load_at(masm, decorators, type, dst, src, tmp1, tmp_thread);
519519

520-
if (ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type)) {
521-
load_reference_barrier_native(masm, dst, src);
520+
if (ShenandoahBarrierSet::use_load_reference_barrier_weak(decorators, type)) {
521+
load_reference_barrier_weak(masm, dst, src);
522522
} else {
523523
load_reference_barrier(masm, dst, src);
524524
}
@@ -870,8 +870,8 @@ void ShenandoahBarrierSetAssembler::gen_load_reference_barrier_stub(LIR_Assemble
870870
__ bind(slow_path);
871871
ce->store_parameter(res, 0);
872872
ce->store_parameter(addr, 1);
873-
if (stub->is_native()) {
874-
__ call(RuntimeAddress(bs->load_reference_barrier_native_rt_code_blob()->code_begin()));
873+
if (stub->is_weak()) {
874+
__ call(RuntimeAddress(bs->load_reference_barrier_weak_rt_code_blob()->code_begin()));
875875
} else {
876876
__ call(RuntimeAddress(bs->load_reference_barrier_rt_code_blob()->code_begin()));
877877
}
@@ -938,7 +938,7 @@ void ShenandoahBarrierSetAssembler::generate_c1_pre_barrier_runtime_stub(StubAss
938938
__ epilogue();
939939
}
940940

941-
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_native) {
941+
void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_weak) {
942942
__ prologue("shenandoah_load_reference_barrier", false);
943943
// arg0 : object to be resolved
944944

@@ -947,8 +947,8 @@ void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_s
947947
#ifdef _LP64
948948
__ load_parameter(0, c_rarg0);
949949
__ load_parameter(1, c_rarg1);
950-
if (is_native) {
951-
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), c_rarg0, c_rarg1);
950+
if (is_weak) {
951+
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak), c_rarg0, c_rarg1);
952952
} else if (UseCompressedOops) {
953953
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow), c_rarg0, c_rarg1);
954954
} else {
@@ -957,8 +957,8 @@ void ShenandoahBarrierSetAssembler::generate_c1_load_reference_barrier_runtime_s
957957
#else
958958
__ load_parameter(0, rax);
959959
__ load_parameter(1, rbx);
960-
if (is_native) {
961-
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native), rax, rbx);
960+
if (is_weak) {
961+
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak), rax, rbx);
962962
} else {
963963
__ call_VM_leaf(CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier), rax, rbx);
964964
}

‎src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -70,11 +70,11 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
7070
void gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub);
7171
void gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub);
7272
void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);
73-
void generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_native);
73+
void generate_c1_load_reference_barrier_runtime_stub(StubAssembler* sasm, bool is_weak);
7474
#endif
7575

7676
void load_reference_barrier(MacroAssembler* masm, Register dst, Address src);
77-
void load_reference_barrier_native(MacroAssembler* masm, Register dst, Address src);
77+
void load_reference_barrier_weak(MacroAssembler* masm, Register dst, Address src);
7878

7979
void cmpxchg_oop(MacroAssembler* masm,
8080
Register res, Address addr, Register oldval, Register newval,

‎src/hotspot/share/gc/shenandoah/c1/shenandoahBarrierSetC1.cpp

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -211,8 +211,8 @@ void ShenandoahBarrierSetC1::load_at_resolved(LIRAccess& access, LIR_Opr result)
211211
if (ShenandoahBarrierSet::need_load_reference_barrier(decorators, type)) {
212212
LIR_Opr tmp = gen->new_register(T_OBJECT);
213213
BarrierSetC1::load_at_resolved(access, tmp);
214-
bool is_native = ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type);
215-
tmp = load_reference_barrier(gen, tmp, access.resolved_addr(), is_native);
214+
bool is_weak = ShenandoahBarrierSet::use_load_reference_barrier_weak(decorators, type);
215+
tmp = load_reference_barrier(gen, tmp, access.resolved_addr(), is_weak);
216216
__ move(tmp, result);
217217
} else {
218218
BarrierSetC1::load_at_resolved(access, result);
@@ -251,14 +251,14 @@ class C1ShenandoahPreBarrierCodeGenClosure : public StubAssemblerCodeGenClosure
251251

252252
class C1ShenandoahLoadReferenceBarrierCodeGenClosure : public StubAssemblerCodeGenClosure {
253253
private:
254-
const bool _is_native;
254+
const bool _is_weak;
255255

256256
public:
257-
C1ShenandoahLoadReferenceBarrierCodeGenClosure(bool is_native) : _is_native(is_native) {}
257+
C1ShenandoahLoadReferenceBarrierCodeGenClosure(bool is_weak) : _is_weak(is_weak) {}
258258

259259
virtual OopMapSet* generate_code(StubAssembler* sasm) {
260260
ShenandoahBarrierSetAssembler* bs = (ShenandoahBarrierSetAssembler*)BarrierSet::barrier_set()->barrier_set_assembler();
261-
bs->generate_c1_load_reference_barrier_runtime_stub(sasm, _is_native);
261+
bs->generate_c1_load_reference_barrier_runtime_stub(sasm, _is_weak);
262262
return NULL;
263263
}
264264
};
@@ -274,9 +274,9 @@ void ShenandoahBarrierSetC1::generate_c1_runtime_stubs(BufferBlob* buffer_blob)
274274
"shenandoah_load_reference_barrier_slow",
275275
false, &lrb_code_gen_cl);
276276

277-
C1ShenandoahLoadReferenceBarrierCodeGenClosure lrb_native_code_gen_cl(true);
278-
_load_reference_barrier_native_rt_code_blob = Runtime1::generate_blob(buffer_blob, -1,
279-
"shenandoah_load_reference_barrier_native_slow",
280-
false, &lrb_native_code_gen_cl);
277+
C1ShenandoahLoadReferenceBarrierCodeGenClosure lrb_weak_code_gen_cl(true);
278+
_load_reference_barrier_weak_rt_code_blob = Runtime1::generate_blob(buffer_blob, -1,
279+
"shenandoah_load_reference_barrier_weak_slow",
280+
false, &lrb_weak_code_gen_cl);
281281
}
282282
}

‎src/hotspot/share/gc/shenandoah/c1/shenandoahBarrierSetC1.hpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -94,10 +94,10 @@ class ShenandoahLoadReferenceBarrierStub: public CodeStub {
9494
LIR_Opr _result;
9595
LIR_Opr _tmp1;
9696
LIR_Opr _tmp2;
97-
bool _is_native;
97+
bool _is_weak;
9898
public:
99-
ShenandoahLoadReferenceBarrierStub(LIR_Opr obj, LIR_Opr addr, LIR_Opr result, LIR_Opr tmp1, LIR_Opr tmp2, bool is_native) :
100-
_obj(obj), _addr(addr), _result(result), _tmp1(tmp1), _tmp2(tmp2), _is_native(is_native)
99+
ShenandoahLoadReferenceBarrierStub(LIR_Opr obj, LIR_Opr addr, LIR_Opr result, LIR_Opr tmp1, LIR_Opr tmp2, bool is_weak) :
100+
_obj(obj), _addr(addr), _result(result), _tmp1(tmp1), _tmp2(tmp2), _is_weak(is_weak)
101101
{
102102
assert(_obj->is_register(), "should be register");
103103
assert(_addr->is_register(), "should be register");
@@ -111,7 +111,7 @@ class ShenandoahLoadReferenceBarrierStub: public CodeStub {
111111
LIR_Opr result() const { return _result; }
112112
LIR_Opr tmp1() const { return _tmp1; }
113113
LIR_Opr tmp2() const { return _tmp2; }
114-
bool is_native() const { return _is_native; }
114+
bool is_weak() const { return _is_weak; }
115115

116116
virtual void emit_code(LIR_Assembler* e);
117117
virtual void visit(LIR_OpVisitState* visitor) {
@@ -191,7 +191,7 @@ class ShenandoahBarrierSetC1 : public BarrierSetC1 {
191191
private:
192192
CodeBlob* _pre_barrier_c1_runtime_code_blob;
193193
CodeBlob* _load_reference_barrier_rt_code_blob;
194-
CodeBlob* _load_reference_barrier_native_rt_code_blob;
194+
CodeBlob* _load_reference_barrier_weak_rt_code_blob;
195195

196196
void pre_barrier(LIRGenerator* gen, CodeEmitInfo* info, DecoratorSet decorators, LIR_Opr addr_opr, LIR_Opr pre_val);
197197

@@ -215,9 +215,9 @@ class ShenandoahBarrierSetC1 : public BarrierSetC1 {
215215
return _load_reference_barrier_rt_code_blob;
216216
}
217217

218-
CodeBlob* load_reference_barrier_native_rt_code_blob() {
219-
assert(_load_reference_barrier_native_rt_code_blob != NULL, "");
220-
return _load_reference_barrier_native_rt_code_blob;
218+
CodeBlob* load_reference_barrier_weak_rt_code_blob() {
219+
assert(_load_reference_barrier_weak_rt_code_blob != NULL, "");
220+
return _load_reference_barrier_weak_rt_code_blob;
221221
}
222222
protected:
223223

‎src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -305,7 +305,7 @@ bool ShenandoahBarrierSetC2::is_shenandoah_lrb_call(Node* call) {
305305
address entry_point = call->as_CallLeaf()->entry_point();
306306
return (entry_point == CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier)) ||
307307
(entry_point == CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow)) ||
308-
(entry_point == CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native));
308+
(entry_point == CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak));
309309
}
310310

311311
bool ShenandoahBarrierSetC2::is_shenandoah_marking_if(PhaseTransform *phase, Node* n) {
@@ -547,7 +547,7 @@ Node* ShenandoahBarrierSetC2::load_at_resolved(C2Access& access, const Type* val
547547
if (ShenandoahBarrierSet::need_load_reference_barrier(decorators, type)) {
548548
load = new ShenandoahLoadReferenceBarrierNode(NULL,
549549
load,
550-
ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type));
550+
ShenandoahBarrierSet::use_load_reference_barrier_weak(decorators, type));
551551
if (access.is_parse_access()) {
552552
load = static_cast<C2ParseAccess &>(access).kit()->gvn().transform(load);
553553
} else {
@@ -1063,12 +1063,12 @@ Node* ShenandoahBarrierSetC2::ideal_node(PhaseGVN* phase, Node* n, bool can_resh
10631063
// If one input is NULL, then step over the barriers (except LRB native) on the other input
10641064
if (in1->bottom_type() == TypePtr::NULL_PTR &&
10651065
!((in2->Opcode() == Op_ShenandoahLoadReferenceBarrier) &&
1066-
((ShenandoahLoadReferenceBarrierNode*)in2)->is_native())) {
1066+
((ShenandoahLoadReferenceBarrierNode*)in2)->is_weak())) {
10671067
in2 = step_over_gc_barrier(in2);
10681068
}
10691069
if (in2->bottom_type() == TypePtr::NULL_PTR &&
10701070
!((in1->Opcode() == Op_ShenandoahLoadReferenceBarrier) &&
1071-
((ShenandoahLoadReferenceBarrierNode*)in1)->is_native())) {
1071+
((ShenandoahLoadReferenceBarrierNode*)in1)->is_weak())) {
10721072
in1 = step_over_gc_barrier(in1);
10731073
}
10741074

‎src/hotspot/share/gc/shenandoah/c2/shenandoahSupport.cpp

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -956,7 +956,7 @@ void ShenandoahBarrierC2Support::test_in_cset(Node*& ctrl, Node*& not_cset_ctrl,
956956
phase->register_new_node(cset_bool, old_ctrl);
957957
}
958958

959-
void ShenandoahBarrierC2Support::call_lrb_stub(Node*& ctrl, Node*& val, Node* load_addr, Node*& result_mem, Node* raw_mem, bool is_native, PhaseIdealLoop* phase) {
959+
void ShenandoahBarrierC2Support::call_lrb_stub(Node*& ctrl, Node*& val, Node* load_addr, Node*& result_mem, Node* raw_mem, bool is_weak, PhaseIdealLoop* phase) {
960960
IdealLoopTree*loop = phase->get_loop(ctrl);
961961
const TypePtr* obj_type = phase->igvn().type(val)->is_oopptr();
962962

@@ -971,9 +971,9 @@ void ShenandoahBarrierC2Support::call_lrb_stub(Node*& ctrl, Node*& val, Node* lo
971971
CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_narrow) :
972972
CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier);
973973

974-
address calladdr = is_native ? CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native)
975-
: target;
976-
const char* name = is_native ? "load_reference_barrier_native" : "load_reference_barrier";
974+
address calladdr = is_weak ? CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak)
975+
: target;
976+
const char* name = is_weak ? "load_reference_barrier_native" : "load_reference_barrier";
977977
Node* call = new CallLeafNode(ShenandoahBarrierSetC2::shenandoah_load_reference_barrier_Type(), calladdr, name, TypeRawPtr::BOTTOM);
978978

979979
call->init_req(TypeFunc::Control, ctrl);
@@ -1338,7 +1338,7 @@ void ShenandoahBarrierC2Support::pin_and_expand(PhaseIdealLoop* phase) {
13381338
// even for non-cset objects to prevent ressurrection of such objects.
13391339
// Wires !in_cset(obj) to slot 2 of region and phis
13401340
Node* not_cset_ctrl = NULL;
1341-
if (!lrb->is_native()) {
1341+
if (!lrb->is_weak()) {
13421342
test_in_cset(ctrl, not_cset_ctrl, val, raw_mem, phase);
13431343
}
13441344
if (not_cset_ctrl != NULL) {
@@ -1389,7 +1389,7 @@ void ShenandoahBarrierC2Support::pin_and_expand(PhaseIdealLoop* phase) {
13891389
}
13901390
}
13911391
}
1392-
call_lrb_stub(ctrl, val, addr, result_mem, raw_mem, lrb->is_native(), phase);
1392+
call_lrb_stub(ctrl, val, addr, result_mem, raw_mem, lrb->is_weak(), phase);
13931393
region->init_req(_evac_path, ctrl);
13941394
val_phi->init_req(_evac_path, val);
13951395
raw_mem_phi->init_req(_evac_path, result_mem);
@@ -2879,26 +2879,26 @@ void MemoryGraphFixer::fix_memory_uses(Node* mem, Node* replacement, Node* rep_p
28792879
}
28802880
}
28812881

2882-
ShenandoahLoadReferenceBarrierNode::ShenandoahLoadReferenceBarrierNode(Node* ctrl, Node* obj, bool native)
2883-
: Node(ctrl, obj), _native(native) {
2882+
ShenandoahLoadReferenceBarrierNode::ShenandoahLoadReferenceBarrierNode(Node* ctrl, Node* obj, bool weak)
2883+
: Node(ctrl, obj), _weak(weak) {
28842884
ShenandoahBarrierSetC2::bsc2()->state()->add_load_reference_barrier(this);
28852885
}
28862886

2887-
bool ShenandoahLoadReferenceBarrierNode::is_native() const {
2888-
return _native;
2887+
bool ShenandoahLoadReferenceBarrierNode::is_weak() const {
2888+
return _weak;
28892889
}
28902890

28912891
uint ShenandoahLoadReferenceBarrierNode::size_of() const {
28922892
return sizeof(*this);
28932893
}
28942894

28952895
uint ShenandoahLoadReferenceBarrierNode::hash() const {
2896-
return Node::hash() + (_native ? 1 : 0);
2896+
return Node::hash() + (_weak ? 1 : 0);
28972897
}
28982898

28992899
bool ShenandoahLoadReferenceBarrierNode::cmp( const Node &n ) const {
29002900
return Node::cmp(n) && n.Opcode() == Op_ShenandoahLoadReferenceBarrier &&
2901-
_native == ((const ShenandoahLoadReferenceBarrierNode&)n)._native;
2901+
_weak == ((const ShenandoahLoadReferenceBarrierNode&)n)._weak;
29022902
}
29032903

29042904
const Type* ShenandoahLoadReferenceBarrierNode::bottom_type() const {

0 commit comments

Comments
 (0)