< prev index next >

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

Print this page
rev 58062 : 8239081: Shenandoah: Consolidate C1 LRB and native barriers


  77       visitor->do_input(_addr);
  78       visitor->do_temp(_pre_val);
  79     } else {
  80       visitor->do_slow_case();
  81       visitor->do_input(_pre_val);
  82     }
  83   }
  84 #ifndef PRODUCT
  85   virtual void print_name(outputStream* out) const { out->print("ShenandoahPreBarrierStub"); }
  86 #endif // PRODUCT
  87 };
  88 
  89 class ShenandoahLoadReferenceBarrierStub: public CodeStub {
  90   friend class ShenandoahBarrierSetC1;
  91 private:
  92   LIR_Opr _obj;
  93   LIR_Opr _addr;
  94   LIR_Opr _result;
  95   LIR_Opr _tmp1;
  96   LIR_Opr _tmp2;
  97 
  98 public:
  99   ShenandoahLoadReferenceBarrierStub(LIR_Opr obj, LIR_Opr addr, LIR_Opr result, LIR_Opr tmp1, LIR_Opr tmp2) :
 100     _obj(obj), _addr(addr), _result(result), _tmp1(tmp1), _tmp2(tmp2)
 101   {
 102     assert(_obj->is_register(), "should be register");
 103     assert(_addr->is_register(), "should be register");
 104     assert(_result->is_register(), "should be register");
 105     assert(_tmp1->is_register(), "should be register");
 106     assert(_tmp2->is_register(), "should be register");
 107   }
 108 
 109   LIR_Opr obj() const { return _obj; }
 110   LIR_Opr addr() const { return _addr; }
 111   LIR_Opr result() const { return _result; }
 112   LIR_Opr tmp1() const { return _tmp1; }
 113   LIR_Opr tmp2() const { return _tmp2; }

 114 
 115   virtual void emit_code(LIR_Assembler* e);
 116   virtual void visit(LIR_OpVisitState* visitor) {
 117     visitor->do_slow_case();
 118     visitor->do_input(_obj);
 119     visitor->do_temp(_obj);
 120     visitor->do_input(_addr);
 121     visitor->do_temp(_addr);
 122     visitor->do_temp(_result);
 123     visitor->do_temp(_tmp1);
 124     visitor->do_temp(_tmp2);
 125   }
 126 #ifndef PRODUCT
 127   virtual void print_name(outputStream* out) const { out->print("ShenandoahLoadReferenceBarrierStub"); }
 128 #endif // PRODUCT
 129 };
 130 
 131 class LIR_OpShenandoahCompareAndSwap : public LIR_Op {
 132  friend class LIR_OpVisitState;
 133 


 173   virtual void emit_code(LIR_Assembler* masm);
 174 
 175   virtual void print_instr(outputStream* out) const {
 176     addr()->print(out);      out->print(" ");
 177     cmp_value()->print(out); out->print(" ");
 178     new_value()->print(out); out->print(" ");
 179     tmp1()->print(out);      out->print(" ");
 180     tmp2()->print(out);      out->print(" ");
 181   }
 182 #ifndef PRODUCT
 183   virtual const char* name() const {
 184     return "shenandoah_cas_obj";
 185   }
 186 #endif // PRODUCT
 187 };
 188 
 189 class ShenandoahBarrierSetC1 : public BarrierSetC1 {
 190 private:
 191   CodeBlob* _pre_barrier_c1_runtime_code_blob;
 192   CodeBlob* _load_reference_barrier_rt_code_blob;

 193 
 194   void pre_barrier(LIRGenerator* gen, CodeEmitInfo* info, DecoratorSet decorators, LIR_Opr addr_opr, LIR_Opr pre_val);
 195 
 196   LIR_Opr load_reference_barrier(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr);
 197   LIR_Opr storeval_barrier(LIRGenerator* gen, LIR_Opr obj, CodeEmitInfo* info, DecoratorSet decorators);
 198 
 199   LIR_Opr load_reference_barrier_impl(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr);
 200 
 201   LIR_Opr ensure_in_register(LIRGenerator* gen, LIR_Opr obj, BasicType type);
 202 
 203 public:
 204   ShenandoahBarrierSetC1();
 205 
 206   CodeBlob* pre_barrier_c1_runtime_code_blob() {
 207     assert(_pre_barrier_c1_runtime_code_blob != NULL, "");
 208     return _pre_barrier_c1_runtime_code_blob;
 209   }
 210 
 211   CodeBlob* load_reference_barrier_rt_code_blob() {
 212     assert(_load_reference_barrier_rt_code_blob != NULL, "");
 213     return _load_reference_barrier_rt_code_blob;
 214   }
 215 




 216 protected:
 217 
 218   virtual void store_at_resolved(LIRAccess& access, LIR_Opr value);
 219   virtual LIR_Opr resolve_address(LIRAccess& access, bool resolve_in_register);
 220   virtual void load_at_resolved(LIRAccess& access, LIR_Opr result);
 221 
 222   virtual LIR_Opr atomic_cmpxchg_at_resolved(LIRAccess& access, LIRItem& cmp_value, LIRItem& new_value);
 223 
 224   virtual LIR_Opr atomic_xchg_at_resolved(LIRAccess& access, LIRItem& value);
 225 
 226 public:
 227 
 228   virtual void generate_c1_runtime_stubs(BufferBlob* buffer_blob);
 229   virtual const char* rtcall_name_for_address(address entry);
 230 };
 231 
 232 #endif // SHARE_GC_SHENANDOAH_C1_SHENANDOAHBARRIERSETC1_HPP


  77       visitor->do_input(_addr);
  78       visitor->do_temp(_pre_val);
  79     } else {
  80       visitor->do_slow_case();
  81       visitor->do_input(_pre_val);
  82     }
  83   }
  84 #ifndef PRODUCT
  85   virtual void print_name(outputStream* out) const { out->print("ShenandoahPreBarrierStub"); }
  86 #endif // PRODUCT
  87 };
  88 
  89 class ShenandoahLoadReferenceBarrierStub: public CodeStub {
  90   friend class ShenandoahBarrierSetC1;
  91 private:
  92   LIR_Opr _obj;
  93   LIR_Opr _addr;
  94   LIR_Opr _result;
  95   LIR_Opr _tmp1;
  96   LIR_Opr _tmp2;
  97   bool _is_native;
  98 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)
 101   {
 102     assert(_obj->is_register(), "should be register");
 103     assert(_addr->is_register(), "should be register");
 104     assert(_result->is_register(), "should be register");
 105     assert(_tmp1->is_register(), "should be register");
 106     assert(_tmp2->is_register(), "should be register");
 107   }
 108 
 109   LIR_Opr obj() const { return _obj; }
 110   LIR_Opr addr() const { return _addr; }
 111   LIR_Opr result() const { return _result; }
 112   LIR_Opr tmp1() const { return _tmp1; }
 113   LIR_Opr tmp2() const { return _tmp2; }
 114   bool is_native() const { return _is_native; }
 115 
 116   virtual void emit_code(LIR_Assembler* e);
 117   virtual void visit(LIR_OpVisitState* visitor) {
 118     visitor->do_slow_case();
 119     visitor->do_input(_obj);
 120     visitor->do_temp(_obj);
 121     visitor->do_input(_addr);
 122     visitor->do_temp(_addr);
 123     visitor->do_temp(_result);
 124     visitor->do_temp(_tmp1);
 125     visitor->do_temp(_tmp2);
 126   }
 127 #ifndef PRODUCT
 128   virtual void print_name(outputStream* out) const { out->print("ShenandoahLoadReferenceBarrierStub"); }
 129 #endif // PRODUCT
 130 };
 131 
 132 class LIR_OpShenandoahCompareAndSwap : public LIR_Op {
 133  friend class LIR_OpVisitState;
 134 


 174   virtual void emit_code(LIR_Assembler* masm);
 175 
 176   virtual void print_instr(outputStream* out) const {
 177     addr()->print(out);      out->print(" ");
 178     cmp_value()->print(out); out->print(" ");
 179     new_value()->print(out); out->print(" ");
 180     tmp1()->print(out);      out->print(" ");
 181     tmp2()->print(out);      out->print(" ");
 182   }
 183 #ifndef PRODUCT
 184   virtual const char* name() const {
 185     return "shenandoah_cas_obj";
 186   }
 187 #endif // PRODUCT
 188 };
 189 
 190 class ShenandoahBarrierSetC1 : public BarrierSetC1 {
 191 private:
 192   CodeBlob* _pre_barrier_c1_runtime_code_blob;
 193   CodeBlob* _load_reference_barrier_rt_code_blob;
 194   CodeBlob* _load_reference_barrier_native_rt_code_blob;
 195 
 196   void pre_barrier(LIRGenerator* gen, CodeEmitInfo* info, DecoratorSet decorators, LIR_Opr addr_opr, LIR_Opr pre_val);
 197 
 198   LIR_Opr load_reference_barrier(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr, bool is_native);
 199   LIR_Opr storeval_barrier(LIRGenerator* gen, LIR_Opr obj, CodeEmitInfo* info, DecoratorSet decorators);
 200 
 201   LIR_Opr load_reference_barrier_impl(LIRGenerator* gen, LIR_Opr obj, LIR_Opr addr, bool is_native);
 202 
 203   LIR_Opr ensure_in_register(LIRGenerator* gen, LIR_Opr obj, BasicType type);
 204 
 205 public:
 206   ShenandoahBarrierSetC1();
 207 
 208   CodeBlob* pre_barrier_c1_runtime_code_blob() {
 209     assert(_pre_barrier_c1_runtime_code_blob != NULL, "");
 210     return _pre_barrier_c1_runtime_code_blob;
 211   }
 212 
 213   CodeBlob* load_reference_barrier_rt_code_blob() {
 214     assert(_load_reference_barrier_rt_code_blob != NULL, "");
 215     return _load_reference_barrier_rt_code_blob;
 216   }
 217 
 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;
 221   }
 222 protected:
 223 
 224   virtual void store_at_resolved(LIRAccess& access, LIR_Opr value);
 225   virtual LIR_Opr resolve_address(LIRAccess& access, bool resolve_in_register);
 226   virtual void load_at_resolved(LIRAccess& access, LIR_Opr result);
 227 
 228   virtual LIR_Opr atomic_cmpxchg_at_resolved(LIRAccess& access, LIRItem& cmp_value, LIRItem& new_value);
 229 
 230   virtual LIR_Opr atomic_xchg_at_resolved(LIRAccess& access, LIRItem& value);
 231 
 232 public:
 233 
 234   virtual void generate_c1_runtime_stubs(BufferBlob* buffer_blob);

 235 };
 236 
 237 #endif // SHARE_GC_SHENANDOAH_C1_SHENANDOAHBARRIERSETC1_HPP
< prev index next >