stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8245957: Remove unused LIR_OpBranch::type after SPARC port removal

Browse Source 
Removed LIR_OpBranch::type after the only remaining usage was removed with the SPARC port removal.

Reviewed-by: kvn, mdoerr
This commit is contained in:
Tobias Hartmann 2020-06-02 09:57:57 +02:00
parent 5793b0633a
commit f822eed55c
13 changed files with 76 additions and 80 deletions

8
src/hotspot/cpu/aarch64/c1_LIRGenerator_aarch64.cpp

@ -459,7 +459,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) {
if (need_zero_check) {
CodeEmitInfo* info = state_for(x);
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_LONG, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
}
rlock_result(x);
@ -534,7 +534,7 @@ void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) {
if (need_zero_check) {
CodeEmitInfo* info = state_for(x);
__ cmp(lir_cond_equal, right_arg->result(), LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_INT, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
}
LIR_Opr ill = LIR_OprFact::illegalOpr;
@ -1384,9 +1384,9 @@ void LIRGenerator::do_If(If* x) {
profile_branch(x, cond);
move_to_phi(x->state());
if (x->x()->type()->is_float_kind()) {
__ branch(lir_cond(cond), right->type(), x->tsux(), x->usux());
__ branch(lir_cond(cond), x->tsux(), x->usux());
} else {
__ branch(lir_cond(cond), right->type(), x->tsux());
__ branch(lir_cond(cond), x->tsux());
}
assert(x->default_sux() == x->fsux(), "wrong destination above");
__ jump(x->default_sux());

10
src/hotspot/cpu/arm/c1_LIRGenerator_arm.cpp

@ -390,7 +390,7 @@ void LIRGenerator::CardTableBarrierSet_post_barrier_helper(LIR_OprDesc* addr, LI
LabelObj* L_already_dirty = new LabelObj();
__ cmp(lir_cond_equal, cur_value, LIR_OprFact::intConst(CardTable::dirty_card_val()));
__ branch(lir_cond_equal, T_BYTE, L_already_dirty->label());
__ branch(lir_cond_equal, L_already_dirty->label());
set_card(tmp, card_addr);
__ branch_destination(L_already_dirty->label());
} else {
@ -539,7 +539,7 @@ void LIRGenerator::do_ArithmeticOp_FPU(ArithmeticOp* x) {
void LIRGenerator::make_div_by_zero_check(LIR_Opr right_arg, BasicType type, CodeEmitInfo* info) {
assert(right_arg->is_register(), "must be");
__ cmp(lir_cond_equal, right_arg, make_constant(type, 0));
__ branch(lir_cond_equal, type, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
}
@ -1227,7 +1227,7 @@ void LIRGenerator::do_soft_float_compare(If* x) {
LIR_OprFact::intConst(0) : LIR_OprFact::intConst(1));
profile_branch(x, cond);
move_to_phi(x->state());
__ branch(lir_cond_equal, T_INT, x->tsux());
__ branch(lir_cond_equal, x->tsux());
}
#endif // __SOFTFP__
@ -1285,9 +1285,9 @@ void LIRGenerator::do_If(If* x) {
profile_branch(x, cond);
move_to_phi(x->state());
if (x->x()->type()->is_float_kind()) {
__ branch(lir_cond(cond), right->type(), x->tsux(), x->usux());
__ branch(lir_cond(cond), x->tsux(), x->usux());
} else {
__ branch(lir_cond(cond), right->type(), x->tsux());
__ branch(lir_cond(cond), x->tsux());
}
assert(x->default_sux() == x->fsux(), "wrong destination above");
__ jump(x->default_sux());

8
src/hotspot/cpu/ppc/c1_LIRGenerator_ppc.cpp

@ -440,7 +440,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) {
if (divisor->is_register()) {
CodeEmitInfo* null_check_info = state_for(x);
__ cmp(lir_cond_equal, divisor, LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_LONG, new DivByZeroStub(null_check_info));
__ branch(lir_cond_equal, new DivByZeroStub(null_check_info));
} else {
jlong const_divisor = divisor->as_constant_ptr()->as_jlong();
if (const_divisor == 0) {
@ -494,7 +494,7 @@ void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) {
if (divisor->is_register()) {
CodeEmitInfo* null_check_info = state_for(x);
__ cmp(lir_cond_equal, divisor, LIR_OprFact::intConst(0));
__ branch(lir_cond_equal, T_INT, new DivByZeroStub(null_check_info));
__ branch(lir_cond_equal, new DivByZeroStub(null_check_info));
} else {
jint const_divisor = divisor->as_constant_ptr()->as_jint();
if (const_divisor == 0) {
@ -1171,9 +1171,9 @@ void LIRGenerator::do_If(If* x) {
profile_branch(x, cond);
move_to_phi(x->state());
if (x->x()->type()->is_float_kind()) {
__ branch(lir_cond(cond), right->type(), x->tsux(), x->usux());
__ branch(lir_cond(cond), x->tsux(), x->usux());
} else {
__ branch(lir_cond(cond), right->type(), x->tsux());
__ branch(lir_cond(cond), x->tsux());
}
assert(x->default_sux() == x->fsux(), "wrong destination above");
__ jump(x->default_sux());

8
src/hotspot/cpu/s390/c1_LIRGenerator_s390.cpp

@ -385,7 +385,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) {
if (!ImplicitDiv0Checks) {
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_LONG, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
// Idiv/irem cannot trap (passing info would generate an assertion).
info = NULL;
}
@ -461,7 +461,7 @@ void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) {
if (!ImplicitDiv0Checks) {
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::intConst(0));
__ branch(lir_cond_equal, T_INT, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
// Idiv/irem cannot trap (passing info would generate an assertion).
info = NULL;
}
@ -988,9 +988,9 @@ void LIRGenerator::do_If (If* x) {
profile_branch(x, cond);
move_to_phi(x->state());
if (x->x()->type()->is_float_kind()) {
__ branch(lir_cond(cond), right->type(), x->tsux(), x->usux());
__ branch(lir_cond(cond), x->tsux(), x->usux());
} else {
__ branch(lir_cond(cond), right->type(), x->tsux());
__ branch(lir_cond(cond), x->tsux());
}
assert(x->default_sux() == x->fsux(), "wrong destination above");
__ jump(x->default_sux());

8
src/hotspot/cpu/x86/c1_LIRGenerator_x86.cpp

@ -481,7 +481,7 @@ void LIRGenerator::do_ArithmeticOp_Long(ArithmeticOp* x) {
__ move(right.result(), cc->at(0));
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::longConst(0));
__ branch(lir_cond_equal, T_LONG, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
address entry = NULL;
switch (x->op()) {
@ -565,7 +565,7 @@ void LIRGenerator::do_ArithmeticOp_Int(ArithmeticOp* x) {
if (!ImplicitDiv0Checks) {
__ cmp(lir_cond_equal, right.result(), LIR_OprFact::intConst(0));
__ branch(lir_cond_equal, T_INT, new DivByZeroStub(info));
__ branch(lir_cond_equal, new DivByZeroStub(info));
// Idiv/irem cannot trap (passing info would generate an assertion).
info = NULL;
}
@ -1503,9 +1503,9 @@ void LIRGenerator::do_If(If* x) {
profile_branch(x, cond);
move_to_phi(x->state());
if (x->x()->type()->is_float_kind()) {
__ branch(lir_cond(cond), right->type(), x->tsux(), x->usux());
__ branch(lir_cond(cond), x->tsux(), x->usux());
} else {
__ branch(lir_cond(cond), right->type(), x->tsux());
__ branch(lir_cond(cond), x->tsux());
}
assert(x->default_sux() == x->fsux(), "wrong destination above");
__ jump(x->default_sux());

11
src/hotspot/share/c1/c1_LIR.cpp

@ -236,30 +236,27 @@ void LIR_Op2::verify() const {
}
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block)
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BlockBegin* block)
: LIR_Op(lir_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)
, _cond(cond)
, _type(type)
, _label(block->label())
, _block(block)
, _ublock(NULL)
, _stub(NULL) {
}
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, CodeStub* stub) :
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, CodeStub* stub) :
LIR_Op(lir_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)
, _cond(cond)
, _type(type)
, _label(stub->entry())
, _block(NULL)
, _ublock(NULL)
, _stub(stub) {
}
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block, BlockBegin* ublock)
LIR_OpBranch::LIR_OpBranch(LIR_Condition cond, BlockBegin* block, BlockBegin* ublock)
: LIR_Op(lir_cond_float_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*)NULL)
, _cond(cond)
, _type(type)
, _label(block->label())
, _block(block)
, _ublock(ublock)
@ -1403,7 +1400,7 @@ void LIR_List::null_check(LIR_Opr opr, CodeEmitInfo* info, bool deoptimize_on_nu
// Emit an explicit null check and deoptimize if opr is null
CodeStub* deopt = new DeoptimizeStub(info, Deoptimization::Reason_null_check, Deoptimization::Action_none);
cmp(lir_cond_equal, opr, LIR_OprFact::oopConst(NULL));
branch(lir_cond_equal, T_OBJECT, deopt);
branch(lir_cond_equal, deopt);
} else {
// Emit an implicit null check
append(new LIR_Op1(lir_null_check, opr, info));

37
src/hotspot/share/c1/c1_LIR.hpp

@ -1404,30 +1404,27 @@ class LIR_OpBranch: public LIR_Op {
private:
LIR_Condition _cond;
BasicType _type;
Label* _label;
BlockBegin* _block; // if this is a branch to a block, this is the block
BlockBegin* _ublock; // if this is a float-branch, this is the unorderd block
CodeStub* _stub; // if this is a branch to a stub, this is the stub
public:
LIR_OpBranch(LIR_Condition cond, BasicType type, Label* lbl)
LIR_OpBranch(LIR_Condition cond, Label* lbl)
: LIR_Op(lir_branch, LIR_OprFact::illegalOpr, (CodeEmitInfo*) NULL)
, _cond(cond)
, _type(type)
, _label(lbl)
, _block(NULL)
, _ublock(NULL)
, _stub(NULL) { }
LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block);
LIR_OpBranch(LIR_Condition cond, BasicType type, CodeStub* stub);
LIR_OpBranch(LIR_Condition cond, BlockBegin* block);
LIR_OpBranch(LIR_Condition cond, CodeStub* stub);
// for unordered comparisons
LIR_OpBranch(LIR_Condition cond, BasicType type, BlockBegin* block, BlockBegin* ublock);
LIR_OpBranch(LIR_Condition cond, BlockBegin* block, BlockBegin* ublock);
LIR_Condition cond() const { return _cond; }
BasicType type() const { return _type; }
Label* label() const { return _label; }
BlockBegin* block() const { return _block; }
BlockBegin* ublock() const { return _ublock; }
@ -2176,23 +2173,25 @@ class LIR_List: public CompilationResourceObj {
// jump is an unconditional branch
void jump(BlockBegin* block) {
append(new LIR_OpBranch(lir_cond_always, T_ILLEGAL, block));
append(new LIR_OpBranch(lir_cond_always, block));
}
void jump(CodeStub* stub) {
append(new LIR_OpBranch(lir_cond_always, T_ILLEGAL, stub));
append(new LIR_OpBranch(lir_cond_always, stub));
}
void branch(LIR_Condition cond, BasicType type, Label* lbl) { append(new LIR_OpBranch(cond, type, lbl)); }
void branch(LIR_Condition cond, BasicType type, BlockBegin* block) {
assert(type != T_FLOAT && type != T_DOUBLE, "no fp comparisons");
append(new LIR_OpBranch(cond, type, block));
void branch(LIR_Condition cond, Label* lbl) {
append(new LIR_OpBranch(cond, lbl));
}
void branch(LIR_Condition cond, BasicType type, CodeStub* stub) {
assert(type != T_FLOAT && type != T_DOUBLE, "no fp comparisons");
append(new LIR_OpBranch(cond, type, stub));
// Should not be used for fp comparisons
void branch(LIR_Condition cond, BlockBegin* block) {
append(new LIR_OpBranch(cond, block));
}
void branch(LIR_Condition cond, BasicType type, BlockBegin* block, BlockBegin* unordered) {
assert(type == T_FLOAT || type == T_DOUBLE, "fp comparisons only");
append(new LIR_OpBranch(cond, type, block, unordered));
// Should not be used for fp comparisons
void branch(LIR_Condition cond, CodeStub* stub) {
append(new LIR_OpBranch(cond, stub));
}
// Should only be used for fp comparisons
void branch(LIR_Condition cond, BlockBegin* block, BlockBegin* unordered) {
append(new LIR_OpBranch(cond, block, unordered));
}
void shift_left(LIR_Opr value, LIR_Opr count, LIR_Opr dst, LIR_Opr tmp);

46
src/hotspot/share/c1/c1_LIRGenerator.cpp

@ -478,11 +478,11 @@ void LIRGenerator::array_range_check(LIR_Opr array, LIR_Opr index,
if (index->is_constant()) {
cmp_mem_int(lir_cond_belowEqual, array, arrayOopDesc::length_offset_in_bytes(),
index->as_jint(), null_check_info);
__ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
__ branch(lir_cond_belowEqual, stub); // forward branch
} else {
cmp_reg_mem(lir_cond_aboveEqual, index, array,
arrayOopDesc::length_offset_in_bytes(), T_INT, null_check_info);
__ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
__ branch(lir_cond_aboveEqual, stub); // forward branch
}
}
@ -491,11 +491,11 @@ void LIRGenerator::nio_range_check(LIR_Opr buffer, LIR_Opr index, LIR_Opr result
CodeStub* stub = new RangeCheckStub(info, index);
if (index->is_constant()) {
cmp_mem_int(lir_cond_belowEqual, buffer, java_nio_Buffer::limit_offset(), index->as_jint(), info);
__ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
__ branch(lir_cond_belowEqual, stub); // forward branch
} else {
cmp_reg_mem(lir_cond_aboveEqual, index, buffer,
java_nio_Buffer::limit_offset(), T_INT, info);
__ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
__ branch(lir_cond_aboveEqual, stub); // forward branch
}
__ move(index, result);
}
@ -686,7 +686,7 @@ void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, bool is_unr
oopDesc::header_size(), instance_size, klass_reg, !klass->is_initialized(), slow_path);
} else {
CodeStub* slow_path = new NewInstanceStub(klass_reg, dst, klass, info, Runtime1::new_instance_id);
__ branch(lir_cond_always, T_ILLEGAL, slow_path);
__ branch(lir_cond_always, slow_path);
__ branch_destination(slow_path->continuation());
}
}
@ -1591,7 +1591,7 @@ void LIRGenerator::do_StoreIndexed(StoreIndexed* x) {
if (GenerateRangeChecks && needs_range_check) {
if (use_length) {
__ cmp(lir_cond_belowEqual, length.result(), index.result());
__ branch(lir_cond_belowEqual, T_INT, new RangeCheckStub(range_check_info, index.result(), array.result()));
__ branch(lir_cond_belowEqual, new RangeCheckStub(range_check_info, index.result(), array.result()));
} else {
array_range_check(array.result(), index.result(), null_check_info, range_check_info);
// range_check also does the null check
@ -1780,11 +1780,11 @@ void LIRGenerator::do_NIOCheckIndex(Intrinsic* x) {
LIR_Opr buf_obj = access_resolve(IS_NOT_NULL | ACCESS_READ, buf.result());
if (index.result()->is_constant()) {
cmp_mem_int(lir_cond_belowEqual, buf_obj, java_nio_Buffer::limit_offset(), index.result()->as_jint(), info);
__ branch(lir_cond_belowEqual, T_INT, stub);
__ branch(lir_cond_belowEqual, stub);
} else {
cmp_reg_mem(lir_cond_aboveEqual, index.result(), buf_obj,
java_nio_Buffer::limit_offset(), T_INT, info);
__ branch(lir_cond_aboveEqual, T_INT, stub);
__ branch(lir_cond_aboveEqual, stub);
}
__ move(index.result(), result);
} else {
@ -1858,12 +1858,12 @@ void LIRGenerator::do_LoadIndexed(LoadIndexed* x) {
if (GenerateRangeChecks && needs_range_check) {
if (StressLoopInvariantCodeMotion && range_check_info->deoptimize_on_exception()) {
__ branch(lir_cond_always, T_ILLEGAL, new RangeCheckStub(range_check_info, index.result(), array.result()));
__ branch(lir_cond_always, new RangeCheckStub(range_check_info, index.result(), array.result()));
} else if (use_length) {
// TODO: use a (modified) version of array_range_check that does not require a
// constant length to be loaded to a register
__ cmp(lir_cond_belowEqual, length.result(), index.result());
__ branch(lir_cond_belowEqual, T_INT, new RangeCheckStub(range_check_info, index.result(), array.result()));
__ branch(lir_cond_belowEqual, new RangeCheckStub(range_check_info, index.result(), array.result()));
} else {
array_range_check(array.result(), index.result(), null_check_info, range_check_info);
// The range check performs the null check, so clear it out for the load
@ -2239,18 +2239,18 @@ void LIRGenerator::do_SwitchRanges(SwitchRangeArray* x, LIR_Opr value, BlockBegi
BlockBegin* dest = one_range->sux();
if (low_key == high_key) {
__ cmp(lir_cond_equal, value, low_key);
__ branch(lir_cond_equal, T_INT, dest);
__ branch(lir_cond_equal, dest);
} else if (high_key - low_key == 1) {
__ cmp(lir_cond_equal, value, low_key);
__ branch(lir_cond_equal, T_INT, dest);
__ branch(lir_cond_equal, dest);
__ cmp(lir_cond_equal, value, high_key);
__ branch(lir_cond_equal, T_INT, dest);
__ branch(lir_cond_equal, dest);
} else {
LabelObj* L = new LabelObj();
__ cmp(lir_cond_less, value, low_key);
__ branch(lir_cond_less, T_INT, L->label());
__ branch(lir_cond_less, L->label());
__ cmp(lir_cond_lessEqual, value, high_key);
__ branch(lir_cond_lessEqual, T_INT, dest);
__ branch(lir_cond_lessEqual, dest);
__ branch_destination(L->label());
}
}
@ -2370,7 +2370,7 @@ void LIRGenerator::do_TableSwitch(TableSwitch* x) {
} else {
for (int i = 0; i < len; i++) {
__ cmp(lir_cond_equal, value, i + lo_key);
__ branch(lir_cond_equal, T_INT, x->sux_at(i));
__ branch(lir_cond_equal, x->sux_at(i));
}
__ jump(x->default_sux());
}
@ -2429,7 +2429,7 @@ void LIRGenerator::do_LookupSwitch(LookupSwitch* x) {
int len = x->length();
for (int i = 0; i < len; i++) {
__ cmp(lir_cond_equal, value, x->key_at(i));
__ branch(lir_cond_equal, T_INT, x->sux_at(i));
__ branch(lir_cond_equal, x->sux_at(i));
}
__ jump(x->default_sux());
}
@ -2981,7 +2981,7 @@ void LIRGenerator::do_getEventWriter(Intrinsic* x) {
LIR_Opr result = rlock_result(x);
__ move_wide(jobj_addr, result);
__ cmp(lir_cond_equal, result, LIR_OprFact::oopConst(NULL));
__ branch(lir_cond_equal, T_OBJECT, L_end->label());
__ branch(lir_cond_equal, L_end->label());
LIR_Opr jobj = new_register(T_OBJECT);
__ move(result, jobj);
@ -3342,7 +3342,7 @@ void LIRGenerator::decrement_age(CodeEmitInfo* info) {
CodeStub* deopt = new DeoptimizeStub(info, Deoptimization::Reason_tenured,
Deoptimization::Action_make_not_entrant);
__ cmp(lir_cond_lessEqual, result, LIR_OprFact::intConst(0));
__ branch(lir_cond_lessEqual, T_INT, deopt);
__ branch(lir_cond_lessEqual, deopt);
}
}
@ -3389,9 +3389,9 @@ void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
if (freq == 0) {
if (!step->is_constant()) {
__ cmp(lir_cond_notEqual, step, LIR_OprFact::intConst(0));
__ branch(lir_cond_notEqual, T_ILLEGAL, overflow);
__ branch(lir_cond_notEqual, overflow);
} else {
__ branch(lir_cond_always, T_ILLEGAL, overflow);
__ branch(lir_cond_always, overflow);
}
} else {
LIR_Opr mask = load_immediate(freq, T_INT);
@ -3402,7 +3402,7 @@ void LIRGenerator::increment_event_counter_impl(CodeEmitInfo* info,
}
__ logical_and(result, mask, result);
__ cmp(lir_cond_equal, result, LIR_OprFact::intConst(0));
__ branch(lir_cond_equal, T_INT, overflow);
__ branch(lir_cond_equal, overflow);
}
__ branch_destination(overflow->continuation());
}
@ -3516,7 +3516,7 @@ void LIRGenerator::do_RangeCheckPredicate(RangeCheckPredicate *x) {
CodeStub* stub = new PredicateFailedStub(info);
__ cmp(lir_cond(cond), left, right);
__ branch(lir_cond(cond), right->type(), stub);
__ branch(lir_cond(cond), stub);
}
}

4
src/hotspot/share/gc/g1/c1/g1BarrierSetC1.cpp

@ -103,7 +103,7 @@ void G1BarrierSetC1::pre_barrier(LIRAccess& access, LIR_Opr addr_opr,
slow = new G1PreBarrierStub(pre_val);
}
__ branch(lir_cond_notEqual, T_INT, slow);
__ branch(lir_cond_notEqual, slow);
__ branch_destination(slow->continuation());
}
@ -171,7 +171,7 @@ void G1BarrierSetC1::post_barrier(LIRAccess& access, LIR_OprDesc* addr, LIR_OprD
__ cmp(lir_cond_notEqual, xor_shift_res, LIR_OprFact::intptrConst(NULL_WORD));
CodeStub* slow = new G1PostBarrierStub(addr, new_val);
__ branch(lir_cond_notEqual, LP64_ONLY(T_LONG) NOT_LP64(T_INT), slow);
__ branch(lir_cond_notEqual, slow);
__ branch_destination(slow->continuation());
}

8
src/hotspot/share/gc/shared/c1/barrierSetC1.cpp

@ -193,7 +193,7 @@ void BarrierSetC1::load_at_resolved(LIRAccess& access, LIR_Opr result) {
if (mask_boolean) {
LabelObj* equalZeroLabel = new LabelObj();
__ cmp(lir_cond_equal, result, 0);
__ branch(lir_cond_equal, T_BOOLEAN, equalZeroLabel->label());
__ branch(lir_cond_equal, equalZeroLabel->label());
__ move(LIR_OprFact::intConst(1), result);
__ branch_destination(equalZeroLabel->label());
}
@ -321,13 +321,13 @@ void BarrierSetC1::generate_referent_check(LIRAccess& access, LabelObj* cont) {
__ move(LIR_OprFact::longConst(java_lang_ref_Reference::referent_offset()), referent_off);
}
__ cmp(lir_cond_notEqual, offset, referent_off);
__ branch(lir_cond_notEqual, offset->type(), cont->label());
__ branch(lir_cond_notEqual, cont->label());
}
if (gen_source_check) {
// offset is a const and equals referent offset
// if (source == null) -> continue
__ cmp(lir_cond_equal, base_reg, LIR_OprFact::oopConst(NULL));
__ branch(lir_cond_equal, T_OBJECT, cont->label());
__ branch(lir_cond_equal, cont->label());
}
LIR_Opr src_klass = gen->new_register(T_METADATA);
if (gen_type_check) {
@ -338,7 +338,7 @@ void BarrierSetC1::generate_referent_check(LIRAccess& access, LabelObj* cont) {
LIR_Opr reference_type = gen->new_register(T_INT);
__ move(reference_type_addr, reference_type);
__ cmp(lir_cond_equal, reference_type, LIR_OprFact::intConst(REF_NONE));
__ branch(lir_cond_equal, T_INT, cont->label());
__ branch(lir_cond_equal, cont->label());
}
}
}

2
src/hotspot/share/gc/shared/c1/cardTableBarrierSetC1.cpp

@ -89,7 +89,7 @@ void CardTableBarrierSetC1::post_barrier(LIRAccess& access, LIR_OprDesc* addr, L
LabelObj* L_already_dirty = new LabelObj();
__ cmp(lir_cond_equal, cur_value, dirty);
__ branch(lir_cond_equal, T_BYTE, L_already_dirty->label());
__ branch(lir_cond_equal, L_already_dirty->label());
__ move(dirty, card_addr);
__ branch_destination(L_already_dirty->label());
} else {

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

@ -103,7 +103,7 @@ void ShenandoahBarrierSetC1::pre_barrier(LIRGenerator* gen, CodeEmitInfo* info,
slow = new ShenandoahPreBarrierStub(pre_val);
}
__ branch(lir_cond_notEqual, T_INT, slow);
__ branch(lir_cond_notEqual, slow);
__ branch_destination(slow->continuation());
}
@ -149,7 +149,7 @@ LIR_Opr ShenandoahBarrierSetC1::load_reference_barrier_impl(LIRGenerator* gen, L
__ cmp(lir_cond_notEqual, flag_val, LIR_OprFact::intConst(0));
CodeStub* slow = new ShenandoahLoadReferenceBarrierStub(obj, addr, result, tmp1, tmp2, is_native);
__ branch(lir_cond_notEqual, T_INT, slow);
__ branch(lir_cond_notEqual, slow);
__ branch_destination(slow->continuation());
return result;

2
src/hotspot/share/gc/z/c1/zBarrierSetC1.cpp

@ -149,7 +149,7 @@ void ZBarrierSetC1::load_barrier(LIRAccess& access, LIR_Opr result) const {
// Slow path
const address runtime_stub = load_barrier_on_oop_field_preloaded_runtime_stub(access.decorators());
CodeStub* const stub = new ZLoadBarrierStubC1(access, result, runtime_stub);
__ branch(lir_cond_notEqual, T_ADDRESS, stub);
__ branch(lir_cond_notEqual, stub);
__ branch_destination(stub->continuation());
}