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_AARCH64_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_AARCH64_HPP

    25 #define CPU_AARCH64_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_AARCH64_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   void shenandoah_write_barrier_pre(MacroAssembler* masm,

    50                                     Register obj,

    51                                     Register pre_val,

    52                                     Register thread,

    53                                     Register tmp,

    54                                     bool tosca_live,

    55                                     bool expand_call);

    56 

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

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

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

    60   void read_barrier_not_null_impl(MacroAssembler* masm, Register dst);

    61   void write_barrier(MacroAssembler* masm, Register dst);

    62   void write_barrier_impl(MacroAssembler* masm, Register dst);

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

    64   void asm_acmp_barrier(MacroAssembler* masm, Register op1, Register op2);

    65 

    66   address generate_shenandoah_wb(StubCodeGenerator* cgen);

    67 

    68 public:

    69   static address shenandoah_wb();

    70 

    71 #ifdef COMPILER1

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

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

    74   void generate_c1_pre_barrier_runtime_stub(StubAssembler* sasm);

    75 #endif

    76 

    77   virtual void arraycopy_prologue(MacroAssembler* masm, DecoratorSet decorators, bool is_oop,

    78                                   Register addr, Register count, RegSet saved_regs);

    79   virtual void arraycopy_epilogue(MacroAssembler* masm, DecoratorSet decorators, bool is_oop,

    80                                   Register start, Register end, Register tmp, RegSet saved_regs);

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

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

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

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

    85   virtual void obj_equals(MacroAssembler* masm, Register src1, Register src2);

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

    87   virtual void tlab_allocate(MacroAssembler* masm, Register obj,

    88                              Register var_size_in_bytes,

    89                              int con_size_in_bytes,

    90                              Register t1,

    91                              Register t2,

    92                              Label& slow_case);

    93 

    94   void cmpxchg_oop(MacroAssembler* masm, Register addr, Register expected, Register new_val,

    95                    bool acquire, bool release, bool weak, bool encode,

    96                    Register tmp1, Register tmp2, Register tmp3 = rscratch2,

    97                    Register result = noreg);

    98 

    99   virtual void barrier_stubs_init();

   100 };

   101 

   102 #endif // CPU_AARCH64_GC_SHENANDOAH_SHENANDOAHBARRIERSETASSEMBLER_AARCH64_HPP