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

rev 58062 : 8239081: Shenandoah: Consolidate C1 LRB and native barriers

*** 105,123 ****
  
    __ branch(lir_cond_notEqual, T_INT, slow);
    __ branch_destination(slow->continuation());
  }
  
! LIR_Opr ShenandoahBarrierSetC1::load_reference_barrier(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr) {
    if (ShenandoahLoadRefBarrier) {
!     return load_reference_barrier_impl(gen, obj, addr);
    } else {
      return obj;
    }
  }
  
! LIR_Opr ShenandoahBarrierSetC1::load_reference_barrier_impl(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr) {
    assert(ShenandoahLoadRefBarrier, "Should be enabled");
  
    obj = ensure_in_register(gen, obj, T_OBJECT);
    assert(obj->is_register(), "must be a register at this point");
    addr = ensure_in_register(gen, addr, T_ADDRESS);
--- 105,123 ----
  
    __ branch(lir_cond_notEqual, T_INT, slow);
    __ branch_destination(slow->continuation());
  }
  
! LIR_Opr ShenandoahBarrierSetC1::load_reference_barrier(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr, bool is_native) {
    if (ShenandoahLoadRefBarrier) {
!     return load_reference_barrier_impl(gen, obj, addr, is_native);
    } else {
      return obj;
    }
  }
  
! LIR_Opr ShenandoahBarrierSetC1::load_reference_barrier_impl(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr, bool is_native) {
    assert(ShenandoahLoadRefBarrier, "Should be enabled");
  
    obj = ensure_in_register(gen, obj, T_OBJECT);
    assert(obj->is_register(), "must be a register at this point");
    addr = ensure_in_register(gen, addr, T_ADDRESS);
*** 148,158 ****
      __ logical_and(flag_val, mask_reg, masked_flag);
      flag_val = masked_flag;
    }
    __ cmp(lir_cond_notEqual, flag_val, LIR_OprFact::intConst(0));
  
!   CodeStub* slow = new ShenandoahLoadReferenceBarrierStub(obj, addr, result, tmp1, tmp2);
    __ branch(lir_cond_notEqual, T_INT, slow);
    __ branch_destination(slow->continuation());
  
    return result;
  }
--- 148,158 ----
      __ logical_and(flag_val, mask_reg, masked_flag);
      flag_val = masked_flag;
    }
    __ 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_destination(slow->continuation());
  
    return result;
  }
*** 209,238 ****
    DecoratorSet decorators = access.decorators();
    BasicType type = access.type();
  
    // 2: load a reference from src location and apply LRB if ShenandoahLoadRefBarrier is set
    if (ShenandoahBarrierSet::need_load_reference_barrier(decorators, type)) {
-     if (ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type)) {
-       BarrierSetC1::load_at_resolved(access, result);
-       LIR_OprList* args = new LIR_OprList();
-       LIR_Opr addr = access.resolved_addr();
-       addr = ensure_in_register(gen, addr, T_ADDRESS);
-       args->append(result);
-       args->append(addr);
-       BasicTypeList signature;
-       signature.append(T_OBJECT);
-       signature.append(T_ADDRESS);
-       LIR_Opr call_result = gen->call_runtime(&signature, args,
-                                               CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native),
-                                               objectType, NULL);
-       __ move(call_result, result);
-     } else {
        LIR_Opr tmp = gen->new_register(T_OBJECT);
        BarrierSetC1::load_at_resolved(access, tmp);
!       tmp = load_reference_barrier(gen, tmp, access.resolved_addr());
        __ move(tmp, result);
-     }
    } else {
      BarrierSetC1::load_at_resolved(access, result);
    }
  
    // 3: apply keep-alive barrier if ShenandoahKeepAliveBarrier is set
--- 209,223 ----
    DecoratorSet decorators = access.decorators();
    BasicType type = access.type();
  
    // 2: load a reference from src location and apply LRB if ShenandoahLoadRefBarrier is set
    if (ShenandoahBarrierSet::need_load_reference_barrier(decorators, type)) {
      LIR_Opr tmp = gen->new_register(T_OBJECT);
      BarrierSetC1::load_at_resolved(access, tmp);
!     bool native = ShenandoahBarrierSet::use_load_reference_barrier_native(decorators, type);
!     tmp = load_reference_barrier(gen, tmp, access.resolved_addr(), native);
      __ move(tmp, result);
    } else {
      BarrierSetC1::load_at_resolved(access, result);
    }
  
    // 3: apply keep-alive barrier if ShenandoahKeepAliveBarrier is set
*** 266,296 ****
      return NULL;
    }
  };
  
  class C1ShenandoahLoadReferenceBarrierCodeGenClosure : public StubAssemblerCodeGenClosure {
    virtual OopMapSet* generate_code(StubAssembler* sasm) {
      ShenandoahBarrierSetAssembler* bs = (ShenandoahBarrierSetAssembler*)BarrierSet::barrier_set()->barrier_set_assembler();
!     bs->generate_c1_load_reference_barrier_runtime_stub(sasm);
      return NULL;
    }
  };
  
  void ShenandoahBarrierSetC1::generate_c1_runtime_stubs(BufferBlob* buffer_blob) {
    C1ShenandoahPreBarrierCodeGenClosure pre_code_gen_cl;
    _pre_barrier_c1_runtime_code_blob = Runtime1::generate_blob(buffer_blob, -1,
                                                                "shenandoah_pre_barrier_slow",
                                                                false, &pre_code_gen_cl);
    if (ShenandoahLoadRefBarrier) {
!     C1ShenandoahLoadReferenceBarrierCodeGenClosure lrb_code_gen_cl;
      _load_reference_barrier_rt_code_blob = Runtime1::generate_blob(buffer_blob, -1,
                                                                    "shenandoah_load_reference_barrier_slow",
                                                                    false, &lrb_code_gen_cl);
-   }
- }
  
! const char* ShenandoahBarrierSetC1::rtcall_name_for_address(address entry) {
!   if (entry == CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_native)) {
!     return "ShenandoahRuntime::load_reference_barrier_native";
    }
-   return NULL;
  }
--- 251,285 ----
      return NULL;
    }
  };
  
  class C1ShenandoahLoadReferenceBarrierCodeGenClosure : public StubAssemblerCodeGenClosure {
+ private:
+   const bool _native;
+ 
+ public:
+   C1ShenandoahLoadReferenceBarrierCodeGenClosure(bool is_native) : _native(is_native) {}
+ 
    virtual OopMapSet* generate_code(StubAssembler* sasm) {
      ShenandoahBarrierSetAssembler* bs = (ShenandoahBarrierSetAssembler*)BarrierSet::barrier_set()->barrier_set_assembler();
!     bs->generate_c1_load_reference_barrier_runtime_stub(sasm, _native);
      return NULL;
    }
  };
  
  void ShenandoahBarrierSetC1::generate_c1_runtime_stubs(BufferBlob* buffer_blob) {
    C1ShenandoahPreBarrierCodeGenClosure pre_code_gen_cl;
    _pre_barrier_c1_runtime_code_blob = Runtime1::generate_blob(buffer_blob, -1,
                                                                "shenandoah_pre_barrier_slow",
                                                                false, &pre_code_gen_cl);
    if (ShenandoahLoadRefBarrier) {
!     C1ShenandoahLoadReferenceBarrierCodeGenClosure lrb_code_gen_cl(false);
      _load_reference_barrier_rt_code_blob = Runtime1::generate_blob(buffer_blob, -1,
                                                                    "shenandoah_load_reference_barrier_slow",
                                                                    false, &lrb_code_gen_cl);
  
!     C1ShenandoahLoadReferenceBarrierCodeGenClosure lrb_native_code_gen_cl(true);
!     _load_reference_barrier_native_rt_code_blob = Runtime1::generate_blob(buffer_blob, -1,
!                                                                    "shenandoah_load_reference_barrier_native_slow",
!                                                                    false, &lrb_native_code_gen_cl);
    }
  }