src/hotspot/cpu/ppc/macroAssembler_ppc.hpp

*** 26,16 ***
--- 26,20 ---
  #ifndef CPU_PPC_MACROASSEMBLER_PPC_HPP
  #define CPU_PPC_MACROASSEMBLER_PPC_HPP
  
  #include "asm/assembler.hpp"
  #include "oops/accessDecorators.hpp"
+ #include "runtime/signature.hpp"
  #include "utilities/macros.hpp"
  
  // MacroAssembler extends Assembler by a few frequently used macros.
  
  class ciTypeArray;
  class OopMap;
+ class ciInlineKlass;
+ class SigEntry;
+ class VMRegPair;
  
  class MacroAssembler: public Assembler {
   public:
    MacroAssembler(CodeBuffer* code) : Assembler(code) {}
  

*** 392,10 ***
--- 396,15 ---
    enum { trampoline_stub_size = 6 * 4 };
    address trampoline_call(AddressLiteral target,
                            Register Rmethod_toc = noreg,
                            bool scratch_emit = false);
  
+   // Inline type specific methods
+ #include "asm/macroAssembler_common.hpp"
+ 
+   void save_stack_increment(int sp_inc, int frame_size);
+ 
   protected:
  
    // It is imperative that all calls into the VM are handled via the
    // call_VM macros. They make sure that the stack linkage is setup
    // correctly. call_VM's correspond to ENTRY/ENTRY_X entry points

*** 811,10 ***
--- 820,42 ---
    void load_method_holder(Register holder, Register method);
  
    void decode_klass_not_null(Register dst, Register src = noreg);
    Register encode_klass_not_null(Register dst, Register src = noreg);
  
+   // markWord tests, kills markWord reg
+   void test_markword_is_inline_type(Register markword, Label& is_inline_type);
+ 
+   // inlineKlass queries, kills temp_reg
+   void test_oop_is_not_inline_type(Register object, Label& not_inline_type, bool can_be_null = true);
+ 
+   void test_field_is_null_free_inline_type(Register flags, Label& is_null_free);
+   void test_field_is_not_null_free_inline_type(Register flags, Label& not_null_free);
+   void test_field_is_flat(Register flags, Label& is_flat);
+ 
+   // Check oops for special arrays, i.e. flat arrays and/or null-free arrays
+   void test_oop_prototype_bit(Register oop, Register temp_reg, int32_t test_bit, bool jmp_set, Label& jmp_label, bool maybe_far = false);
+   void test_flat_array_oop(Register oop, Register temp_reg, Label& is_flat_array, bool maybe_far = false);
+   void test_non_flat_array_oop(Register oop, Register temp_reg, Label& is_non_flat_array);
+   void test_null_free_array_oop(Register oop, Register temp_reg, Label& is_null_free_array, bool maybe_far = false);
+   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 load_metadata(Register dst, Register src);
+ 
+   void flat_field_copy(DecoratorSet decorators, Register src, Register dst, Register inline_layout_info);
+ 
+   void load_prototype_header(Register dst, Register src);
+ 
+   void inline_layout_info(Register holder_klass, Register index, Register 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, Register t1);
+ 
    // SIGTRAP-based range checks for arrays.
    inline void trap_range_check_l(Register a, Register b);
    inline void trap_range_check_l(Register a, int si16);
    static bool is_trap_range_check_l(int x) {
      return (is_tw (x, traptoLessThanUnsigned, -1/*any reg*/, -1/*any reg*/) ||

*** 840,10 ***
--- 881,11 ---
    }
  
    void clear_memory_unrolled(Register base_ptr, int cnt_dwords, Register tmp = R0, int offset = 0);
    void clear_memory_constlen(Register base_ptr, int cnt_dwords, Register tmp = R0);
    void clear_memory_doubleword(Register base_ptr, Register cnt_dwords, Register tmp = R0, long const_cnt = -1);
+   void fill_words(Register base, Register cnt, Register value);
  
    // Emitters for BigInteger.multiplyToLen intrinsic.
    inline void multiply64(Register dest_hi, Register dest_lo,
                           Register x, Register y);
    void add2_with_carry(Register dest_hi, Register dest_lo,

*** 1008,8 ***
--- 1050,11 ---
    void untested             (const char* msg = nullptr) { stop(stop_untested,           msg); }
    void unimplemented        (const char* msg = nullptr) { stop(stop_unimplemented,      msg); }
    void should_not_reach_here(const char* msg = nullptr) { stop(stop_shouldnotreachhere, msg); }
  
    void zap_from_to(Register low, int before, Register high, int after, Register val, Register addr) PRODUCT_RETURN;
+ 
+   // Inline type specific methods
+   #include "asm/macroAssembler_common.hpp"
  };
  
  #endif // CPU_PPC_MACROASSEMBLER_PPC_HPP