src/hotspot/cpu/riscv/macroAssembler_riscv.hpp

*** 30,10 ***
--- 30,13 ---
  #include "asm/assembler.inline.hpp"
  #include "code/vmreg.hpp"
  #include "metaprogramming/enableIf.hpp"
  #include "oops/compressedOops.hpp"
  #include "utilities/powerOfTwo.hpp"
+ #include "runtime/signature.hpp"
+ 
+ class ciInlineKlass;
  
  // MacroAssembler extends Assembler by frequently used macros.
  //
  // Instructions for which a 'better' code sequence exists depending
  // on arguments should also go in here.

*** 136,10 ***
--- 139,11 ---
    void call_VM_leaf(address entry_point,
                      Register arg_0, Register arg_1, Register arg_2);
  
    // These always tightly bind to MacroAssembler::call_VM_base
    // bypassing the virtual implementation
+   void super_call_VM_leaf(address entry_point);
    void super_call_VM_leaf(address entry_point, Register arg_0);
    void super_call_VM_leaf(address entry_point, Register arg_0, Register arg_1);
    void super_call_VM_leaf(address entry_point, Register arg_0, Register arg_1, Register arg_2);
    void super_call_VM_leaf(address entry_point, Register arg_0, Register arg_1, Register arg_2, Register arg_3);
  

*** 194,10 ***
--- 198,11 ---
    void access_load_at(BasicType type, DecoratorSet decorators, Register dst,
                        Address src, Register tmp1, Register tmp2);
    void access_store_at(BasicType type, DecoratorSet decorators, Address dst,
                         Register val, Register tmp1, Register tmp2, Register tmp3);
    void load_klass(Register dst, Register src, Register tmp = t0);
+   void load_prototype_header(Register dst, Register src, Register tmp = t0);
    void load_narrow_klass_compact(Register dst, Register src);
    void store_klass(Register dst, Register src, Register tmp = t0);
    void cmp_klass_beq(Register obj, Register klass,
                       Register tmp1, Register tmp2,
                       Label &L, bool is_far = false);

*** 246,10 ***
--- 251,33 ---
  
    virtual void null_check(Register reg, int offset = -1);
    static bool needs_explicit_null_check(intptr_t offset);
    static bool uses_implicit_null_check(void* address);
  
+   void test_field_is_null_free_inline_type(Register flags, Register temp_reg, Label& is_null_free);
+   void test_field_is_not_null_free_inline_type(Register flags, Register temp_reg, Label& not_null_free_inline_type);
+   void test_field_is_flat(Register flags, Register temp_reg, Label& is_flat);
+ 
+   void test_markword_is_inline_type(Register markword, Label& is_inline_type);
+   void test_oop_is_not_inline_type(Register object, Register tmp, Label& not_inline_type, bool can_be_null = true);
+   void test_oop_prototype_bit(Register oop, Register temp_reg, int32_t tst_bit, bool jmp_set, Label& jmp_label);
+   void test_flat_array_oop(Register klass, Register temp_reg, Label& is_flat_array);
+   void test_null_free_array_oop(Register oop, Register temp_reg, Label& is_null_free_array);
+   void test_non_flat_array_oop(Register oop, Register temp_reg, Label&is_non_flat_array);
+   void test_non_null_free_array_oop(Register oop, Register temp_reg, Label&is_non_null_free_array);
+ 
+   // Check array klass layout helper for flat or null-free arrays...
+   void test_flat_array_layout(Register lh, Label& is_flat_array);
+ 
+   void inline_layout_info(Register holder_klass, Register index, Register layout_info);
+ 
+   void flat_field_copy(DecoratorSet decorators, Register src, Register dst, Register inline_layout_info);
+ 
+   // inline type data payload offsets...
+   void payload_offset(Register inline_klass, Register offset);
+   void payload_address(Register oop, Register data, Register inline_klass);
+ 
    // interface method calling
    void lookup_interface_method(Register recv_klass,
                                 Register intf_klass,
                                 RegisterOrConstant itable_index,
                                 Register method_result,

*** 288,10 ***
--- 316,11 ---
      }
      return adr;
    }
  
    // allocation
+ 
    void tlab_allocate(
      Register obj,                   // result: pointer to object after successful allocation
      Register var_size_in_bytes,     // object size in bytes if unknown at compile time; invalid otherwise
      int      con_size_in_bytes,     // object size in bytes if   known at compile time
      Register tmp1,                  // temp register

*** 1276,10 ***
--- 1305,12 ---
  
    // Frame creation and destruction shared between JITs.
    void build_frame(int framesize);
    void remove_frame(int framesize);
  
+   void verified_entry(Compile* C, int sp_inc);
+ 
    void reserved_stack_check();
  
    void get_polling_page(Register dest, relocInfo::relocType rtype);
    void read_polling_page(Register r, int32_t offset, relocInfo::relocType rtype);
  

*** 1348,10 ***
--- 1379,11 ---
  
    void clinit_barrier(Register klass, Register tmp, Label* L_fast_path = nullptr, Label* L_slow_path = nullptr);
  
    void load_method_holder_cld(Register result, Register method);
    void load_method_holder(Register holder, Register method);
+   void load_metadata(Register dst, Register src);
  
    void compute_index(Register str1, Register trailing_zeros, Register match_mask,
                       Register result, Register char_tmp, Register tmp,
                       bool haystack_isL);
    void compute_match_mask(Register src, Register pattern, Register match_mask,

*** 1804,10 ***
--- 1836,14 ---
    static bool is_membar(address addr) {
      return (Bytes::get_native_u4(addr) & 0x7f) == 0b1111 && extract_funct3(addr) == 0;
    }
    static uint32_t get_membar_kind(address addr);
    static void set_membar_kind(address addr, uint32_t order_kind);
+ 
+  public:
+   // Inline type specific methods
+   #include "asm/macroAssembler_common.hpp"
  };
  
  #ifdef ASSERT
  inline bool AbstractAssembler::pd_check_instruction_mark() { return false; }
  #endif