src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp
changeset 54423 6c0ab8bd8da5
parent 53519 74a5ef4c81cc
child 54763 2584e5772546
equal deleted inserted replaced
54422:f562f8318ebd 54423:6c0ab8bd8da5
    27 #include "asm/macroAssembler.hpp"
    27 #include "asm/macroAssembler.hpp"
    28 #include "gc/shared/barrierSetAssembler.hpp"
    28 #include "gc/shared/barrierSetAssembler.hpp"
    29 #ifdef COMPILER1
    29 #ifdef COMPILER1
    30 class LIR_Assembler;
    30 class LIR_Assembler;
    31 class ShenandoahPreBarrierStub;
    31 class ShenandoahPreBarrierStub;
    32 class ShenandoahWriteBarrierStub;
    32 class ShenandoahLoadReferenceBarrierStub;
    33 class StubAssembler;
    33 class StubAssembler;
    34 class StubCodeGenerator;
    34 class StubCodeGenerator;
    35 #endif
    35 #endif
    36 
    36 
    37 class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
    37 class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
    38 private:
    38 private:
    39 
    39 
    40   static address _shenandoah_wb;
    40   static address _shenandoah_lrb;
    41 
    41 
    42   void satb_write_barrier_pre(MacroAssembler* masm,
    42   void satb_write_barrier_pre(MacroAssembler* masm,
    43                               Register obj,
    43                               Register obj,
    44                               Register pre_val,
    44                               Register pre_val,
    45                               Register thread,
    45                               Register thread,
    53                                     Register thread,
    53                                     Register thread,
    54                                     Register tmp,
    54                                     Register tmp,
    55                                     bool tosca_live,
    55                                     bool tosca_live,
    56                                     bool expand_call);
    56                                     bool expand_call);
    57 
    57 
    58   void read_barrier(MacroAssembler* masm, Register dst);
    58   void resolve_forward_pointer(MacroAssembler* masm, Register dst);
    59   void read_barrier_impl(MacroAssembler* masm, Register dst);
    59   void resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst);
    60 
    60 
    61   void read_barrier_not_null(MacroAssembler* masm, Register dst);
    61   void load_reference_barrier_not_null(MacroAssembler* masm, Register dst);
    62   void read_barrier_not_null_impl(MacroAssembler* masm, Register dst);
       
    63 
       
    64   void write_barrier(MacroAssembler* masm, Register dst);
       
    65   void write_barrier_impl(MacroAssembler* masm, Register dst);
       
    66 
    62 
    67   void storeval_barrier_impl(MacroAssembler* masm, Register dst, Register tmp);
    63   void storeval_barrier_impl(MacroAssembler* masm, Register dst, Register tmp);
    68 
    64 
    69   address generate_shenandoah_wb(StubCodeGenerator* cgen);
    65   address generate_shenandoah_lrb(StubCodeGenerator* cgen);
    70 
    66 
    71   void save_vector_registers(MacroAssembler* masm);
    67   void save_vector_registers(MacroAssembler* masm);
    72   void restore_vector_registers(MacroAssembler* masm);
    68   void restore_vector_registers(MacroAssembler* masm);
    73 
    69 
    74 public:
    70 public:
    75   static address shenandoah_wb();
    71   static address shenandoah_lrb();
    76 
    72 
    77   void storeval_barrier(MacroAssembler* masm, Register dst, Register tmp);
    73   void storeval_barrier(MacroAssembler* masm, Register dst, Register tmp);
    78 #ifdef COMPILER1
    74 #ifdef COMPILER1
    79   void gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub);
    75   void gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub);
    80   void gen_write_barrier_stub(LIR_Assembler* ce, ShenandoahWriteBarrierStub* stub);
    76   void gen_load_reference_barrier_stub(LIR_Assembler* ce, ShenandoahLoadReferenceBarrierStub* stub);
    81   void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);
    77   void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);
    82 #endif
    78 #endif
       
    79 
       
    80   void load_reference_barrier(MacroAssembler* masm, Register dst);
    83 
    81 
    84   void cmpxchg_oop(MacroAssembler* masm,
    82   void cmpxchg_oop(MacroAssembler* masm,
    85                    Register res, Address addr, Register oldval, Register newval,
    83                    Register res, Address addr, Register oldval, Register newval,
    86                    bool exchange, Register tmp1, Register tmp2);
    84                    bool exchange, Register tmp1, Register tmp2);
    87   virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    85   virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    91   virtual void load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    89   virtual void load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    92                        Register dst, Address src, Register tmp1, Register tmp_thread);
    90                        Register dst, Address src, Register tmp1, Register tmp_thread);
    93   virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    91   virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
    94                         Address dst, Register val, Register tmp1, Register tmp2);
    92                         Address dst, Register val, Register tmp1, Register tmp2);
    95 
    93 
    96 #ifndef _LP64
       
    97   virtual void obj_equals(MacroAssembler* masm,
       
    98                           Address obj1, jobject obj2);
       
    99   virtual void obj_equals(MacroAssembler* masm,
       
   100                           Register obj1, jobject obj2);
       
   101 #endif
       
   102 
       
   103   virtual void obj_equals(MacroAssembler* masm, Register src1, Register src2);
       
   104   virtual void obj_equals(MacroAssembler* masm, Register src1, Address src2);
       
   105 
       
   106   virtual void tlab_allocate(MacroAssembler* masm,
    94   virtual void tlab_allocate(MacroAssembler* masm,
   107                              Register thread, Register obj,
    95                              Register thread, Register obj,
   108                              Register var_size_in_bytes,
    96                              Register var_size_in_bytes,
   109                              int con_size_in_bytes,
    97                              int con_size_in_bytes,
   110                              Register t1, Register t2,
    98                              Register t1, Register t2,
   111                              Label& slow_case);
    99                              Label& slow_case);
   112 
   100 
   113   virtual void resolve(MacroAssembler* masm, DecoratorSet decorators, Register obj);
       
   114 
       
   115   virtual void barrier_stubs_init();
   101   virtual void barrier_stubs_init();
   116 
   102 
   117 };
   103 };
   118 
   104 
   119 #endif // CPU_X86_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_X86_HPP
   105 #endif // CPU_X86_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_X86_HPP