1 /*

     2  * Copyright (c) 2018, Red Hat, Inc. All rights reserved.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.

     7  *

     8  * This code is distributed in the hope that it will be useful, but WITHOUT

     9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    11  * version 2 for more details (a copy is included in the LICENSE file that

    12  * accompanied this code).

    13  *

    14  * You should have received a copy of the GNU General Public License version

    15  * 2 along with this work; if not, write to the Free Software Foundation,

    16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    17  *

    18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    19  * or visit www.oracle.com if you need additional information or have any

    20  * questions.

    21  *

    22  */

    23 

    24 #ifndef CPU_X86_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_X86_HPP

    25 #define CPU_X86_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_X86_HPP

    26 

    27 #include "asm/macroAssembler.hpp"

    28 #include "gc/shared/barrierSetAssembler.hpp"

    29 #ifdef COMPILER1

    30 class LIR_Assembler;

    31 class ShenandoahPreBarrierStub;

    32 class ShenandoahWriteBarrierStub;

    33 class StubAssembler;

    34 class StubCodeGenerator;

    35 #endif

    36 

    37 class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {

    38 private:

    39 

    40   static address _shenandoah_wb;

    41 

    42   void satb_write_barrier_pre(MacroAssembler* masm,

    43                               Register obj,

    44                               Register pre_val,

    45                               Register thread,

    46                               Register tmp,

    47                               bool tosca_live,

    48                               bool expand_call);

    49 

    50   void shenandoah_write_barrier_pre(MacroAssembler* masm,

    51                                     Register obj,

    52                                     Register pre_val,

    53                                     Register thread,

    54                                     Register tmp,

    55                                     bool tosca_live,

    56                                     bool expand_call);

    57 

    58   void read_barrier(MacroAssembler* masm, Register dst);

    59   void read_barrier_impl(MacroAssembler* masm, Register dst);

    60 

    61   void read_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 

    67   void storeval_barrier(MacroAssembler* masm, Register dst, Register tmp);

    68   void storeval_barrier_impl(MacroAssembler* masm, Register dst, Register tmp);

    69 

    70   address generate_shenandoah_wb(StubCodeGenerator* cgen);

    71 

    72   void save_vector_registers(MacroAssembler* masm);

    73   void restore_vector_registers(MacroAssembler* masm);

    74 

    75 public:

    76   static address shenandoah_wb();

    77 

    78 #ifdef COMPILER1

    79   void gen_pre_barrier_stub(LIR_Assembler* ce, ShenandoahPreBarrierStub* stub);

    80   void gen_write_barrier_stub(LIR_Assembler* ce, ShenandoahWriteBarrierStub* stub);

    81   void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);

    82 #endif

    83 

    84   void cmpxchg_oop(MacroAssembler* masm,

    85                    Register res, Address addr, Register oldval, Register newval,

    86                    bool exchange, bool encode, Register tmp1, Register tmp2);

    87   virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, BasicType type,

    88                                   Register src, Register dst, Register count);

    89   virtual void arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, BasicType type,

    90                                   Register src, Register dst, Register count);

    91   virtual void load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,

    92                        Register dst, Address src, Register tmp1, Register tmp_thread);

    93   virtual void store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,

    94                         Address dst, Register val, Register tmp1, Register tmp2);

    95 

    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,

   107                              Register thread, Register obj,

   108                              Register var_size_in_bytes,

   109                              int con_size_in_bytes,

   110                              Register t1, Register t2,

   111                              Label& slow_case);

   112 

   113   virtual void resolve(MacroAssembler* masm, DecoratorSet decorators, Register obj);

   114 

   115   virtual void barrier_stubs_init();

   116 

   117 };

   118 

   119 #endif // CPU_X86_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_X86_HPP