181 long toc_distance();
182 public:
183 void load_toc(Register Rtoc);
184 void load_long_pcrelative(Register Rdst, address dataLocation);
185 static int load_long_pcrelative_size() { return 6; }
186 void load_addr_pcrelative(Register Rdst, address dataLocation);
187 static int load_addr_pcrel_size() { return 6; } // Just a LARL.
188
189 // Load a value from memory and test (set CC).
190 void load_and_test_byte (Register dst, const Address &a);
191 void load_and_test_short (Register dst, const Address &a);
192 void load_and_test_int (Register dst, const Address &a);
193 void load_and_test_int2long(Register dst, const Address &a);
194 void load_and_test_long (Register dst, const Address &a);
195
196 // Test a bit in memory. Result is reflected in CC.
197 void testbit(const Address &a, unsigned int bit);
198 // Test a bit in a register. Result is reflected in CC.
199 void testbit(Register r, unsigned int bitPos);
200
201 // Clear a register, i.e. load const zero into reg. Return len (in bytes) of
202 // generated instruction(s).
203 // whole_reg: Clear 64 bits if true, 32 bits otherwise.
204 // set_cc: Use instruction that sets the condition code, if true.
205 int clear_reg(Register r, bool whole_reg = true, bool set_cc = true);
206
207 #ifdef ASSERT
208 int preset_reg(Register r, unsigned long pattern, int pattern_len);
209 #endif
210
211 // Clear (store zeros) a small piece of memory.
212 // CAUTION: Do not use this for atomic memory clearing. Use store_const() instead.
213 // addr: Address descriptor of memory to clear.
214 // Index register will not be used!
215 // size: Number of bytes to clear.
216 void clear_mem(const Address& addr, unsigned size);
217
218 // Move immediate values to memory. Currently supports 32 and 64 bit stores,
219 // but may be extended to 16 bit store operation, if needed.
220 // For details, see implementation in *.cpp file.
819 static int get_oop_base_pow2_offset(uint64_t oop_base);
820 int get_oop_base(Register Rbase, uint64_t oop_base);
821 int get_oop_base_complement(Register Rbase, uint64_t oop_base);
822 void compare_heap_oop(Register Rop1, Address mem, bool maybeNULL);
823 void compare_klass_ptr(Register Rop1, int64_t disp, Register Rbase, bool maybeNULL);
824 void load_heap_oop(Register dest, const Address &a);
825 void load_heap_oop(Register d, int64_t si16, Register s1);
826 void load_heap_oop_not_null(Register d, int64_t si16, Register s1);
827 void store_heap_oop(Register Roop, RegisterOrConstant offset, Register base);
828 void store_heap_oop_not_null(Register Roop, RegisterOrConstant offset, Register base);
829 void store_heap_oop_null(Register zero, RegisterOrConstant offset, Register base);
830 void oop_encoder(Register Rdst, Register Rsrc, bool maybeNULL,
831 Register Rbase = Z_R1, int pow2_offset = -1, bool only32bitValid = false);
832 void oop_decoder(Register Rdst, Register Rsrc, bool maybeNULL,
833 Register Rbase = Z_R1, int pow2_offset = -1);
834
835 void resolve_oop_handle(Register result);
836 void load_mirror(Register mirror, Register method);
837
838 //--------------------------
839 //--- perations on arrays.
840 //--------------------------
841 unsigned int Clear_Array(Register cnt_arg, Register base_pointer_arg, Register src_addr, Register src_len);
842 unsigned int Clear_Array_Const(long cnt, Register base);
843 unsigned int Clear_Array_Const_Big(long cnt, Register base_pointer_arg, Register src_addr, Register src_len);
844 unsigned int CopyRawMemory_AlignedDisjoint(Register src_reg, Register dst_reg,
845 Register cnt_reg,
846 Register tmp1_reg, Register tmp2_reg);
847
848 //-------------------------------------------
849 // Special String Intrinsics Implementation.
850 //-------------------------------------------
851 // Intrinsics for CompactStrings
852 // Compress char[] to byte[]. odd_reg contains cnt. tmp3 is only needed for precise behavior in failure case. Kills dst.
853 unsigned int string_compress(Register result, Register src, Register dst, Register odd_reg,
854 Register even_reg, Register tmp, Register tmp2 = noreg);
855
856 // Kills src.
857 unsigned int has_negatives(Register result, Register src, Register cnt,
858 Register odd_reg, Register even_reg, Register tmp);
859
860 // Inflate byte[] to char[].
861 unsigned int string_inflate_trot(Register src, Register dst, Register cnt, Register tmp);
862 // Odd_reg contains cnt. Kills src.
863 unsigned int string_inflate(Register src, Register dst, Register odd_reg,
864 Register even_reg, Register tmp);
865
866 unsigned int string_compare(Register str1, Register str2, Register cnt1, Register cnt2,
867 Register odd_reg, Register even_reg, Register result, int ae);
868
869 unsigned int array_equals(bool is_array_equ, Register ary1, Register ary2, Register limit,
870 Register odd_reg, Register even_reg, Register result, bool is_byte);
871
872 unsigned int string_indexof(Register result, Register haystack, Register haycnt,
873 Register needle, Register needlecnt, int needlecntval,
874 Register odd_reg, Register even_reg, int ae);
875
876 unsigned int string_indexof_char(Register result, Register haystack, Register haycnt,
877 Register needle, jchar needleChar, Register odd_reg, Register even_reg, bool is_byte);
878
879 // Emit an oop const to the constant pool and set a relocation info
880 // with address current_pc. Return the TOC offset of the constant.
881 int store_const_in_toc(AddressLiteral& val);
882 int store_oop_in_toc(AddressLiteral& oop);
883 // Emit an oop const to the constant pool via store_oop_in_toc, or
884 // emit a scalar const to the constant pool via store_const_in_toc,
|
181 long toc_distance();
182 public:
183 void load_toc(Register Rtoc);
184 void load_long_pcrelative(Register Rdst, address dataLocation);
185 static int load_long_pcrelative_size() { return 6; }
186 void load_addr_pcrelative(Register Rdst, address dataLocation);
187 static int load_addr_pcrel_size() { return 6; } // Just a LARL.
188
189 // Load a value from memory and test (set CC).
190 void load_and_test_byte (Register dst, const Address &a);
191 void load_and_test_short (Register dst, const Address &a);
192 void load_and_test_int (Register dst, const Address &a);
193 void load_and_test_int2long(Register dst, const Address &a);
194 void load_and_test_long (Register dst, const Address &a);
195
196 // Test a bit in memory. Result is reflected in CC.
197 void testbit(const Address &a, unsigned int bit);
198 // Test a bit in a register. Result is reflected in CC.
199 void testbit(Register r, unsigned int bitPos);
200
201 void prefetch_read(Address a);
202 void prefetch_update(Address a);
203
204 // Clear a register, i.e. load const zero into reg. Return len (in bytes) of
205 // generated instruction(s).
206 // whole_reg: Clear 64 bits if true, 32 bits otherwise.
207 // set_cc: Use instruction that sets the condition code, if true.
208 int clear_reg(Register r, bool whole_reg = true, bool set_cc = true);
209
210 #ifdef ASSERT
211 int preset_reg(Register r, unsigned long pattern, int pattern_len);
212 #endif
213
214 // Clear (store zeros) a small piece of memory.
215 // CAUTION: Do not use this for atomic memory clearing. Use store_const() instead.
216 // addr: Address descriptor of memory to clear.
217 // Index register will not be used!
218 // size: Number of bytes to clear.
219 void clear_mem(const Address& addr, unsigned size);
220
221 // Move immediate values to memory. Currently supports 32 and 64 bit stores,
222 // but may be extended to 16 bit store operation, if needed.
223 // For details, see implementation in *.cpp file.
822 static int get_oop_base_pow2_offset(uint64_t oop_base);
823 int get_oop_base(Register Rbase, uint64_t oop_base);
824 int get_oop_base_complement(Register Rbase, uint64_t oop_base);
825 void compare_heap_oop(Register Rop1, Address mem, bool maybeNULL);
826 void compare_klass_ptr(Register Rop1, int64_t disp, Register Rbase, bool maybeNULL);
827 void load_heap_oop(Register dest, const Address &a);
828 void load_heap_oop(Register d, int64_t si16, Register s1);
829 void load_heap_oop_not_null(Register d, int64_t si16, Register s1);
830 void store_heap_oop(Register Roop, RegisterOrConstant offset, Register base);
831 void store_heap_oop_not_null(Register Roop, RegisterOrConstant offset, Register base);
832 void store_heap_oop_null(Register zero, RegisterOrConstant offset, Register base);
833 void oop_encoder(Register Rdst, Register Rsrc, bool maybeNULL,
834 Register Rbase = Z_R1, int pow2_offset = -1, bool only32bitValid = false);
835 void oop_decoder(Register Rdst, Register Rsrc, bool maybeNULL,
836 Register Rbase = Z_R1, int pow2_offset = -1);
837
838 void resolve_oop_handle(Register result);
839 void load_mirror(Register mirror, Register method);
840
841 //--------------------------
842 //--- Operations on arrays.
843 //--------------------------
844 unsigned int Clear_Array(Register cnt_arg, Register base_pointer_arg, Register src_addr, Register src_len);
845 unsigned int Clear_Array_Const(long cnt, Register base);
846 unsigned int Clear_Array_Const_Big(long cnt, Register base_pointer_arg, Register src_addr, Register src_len);
847 unsigned int CopyRawMemory_AlignedDisjoint(Register src_reg, Register dst_reg,
848 Register cnt_reg,
849 Register tmp1_reg, Register tmp2_reg);
850
851 //-------------------------------------------
852 // Special String Intrinsics Implementation.
853 //-------------------------------------------
854 // Intrinsics for CompactStrings
855 // Restores: src, dst
856 // Uses: cnt
857 // Kills: tmp, Z_R0, Z_R1.
858 // Early clobber: result.
859 // Boolean precise controls accuracy of result value.
860 unsigned int string_compress(Register result, Register src, Register dst, Register cnt,
861 Register tmp, bool precise);
862
863 // Inflate byte[] to char[].
864 unsigned int string_inflate_trot(Register src, Register dst, Register cnt, Register tmp);
865
866 // Inflate byte[] to char[].
867 // Restores: src, dst
868 // Uses: cnt
869 // Kills: tmp, Z_R0, Z_R1.
870 unsigned int string_inflate(Register src, Register dst, Register cnt, Register tmp);
871
872 // Inflate byte[] to char[], length known at compile time.
873 // Restores: src, dst
874 // Kills: tmp, Z_R0, Z_R1.
875 // Note:
876 // len is signed int. Counts # characters, not bytes.
877 unsigned int string_inflate_const(Register src, Register dst, Register tmp, int len);
878
879 // Kills src.
880 unsigned int has_negatives(Register result, Register src, Register cnt,
881 Register odd_reg, Register even_reg, Register tmp);
882
883 unsigned int string_compare(Register str1, Register str2, Register cnt1, Register cnt2,
884 Register odd_reg, Register even_reg, Register result, int ae);
885
886 unsigned int array_equals(bool is_array_equ, Register ary1, Register ary2, Register limit,
887 Register odd_reg, Register even_reg, Register result, bool is_byte);
888
889 unsigned int string_indexof(Register result, Register haystack, Register haycnt,
890 Register needle, Register needlecnt, int needlecntval,
891 Register odd_reg, Register even_reg, int ae);
892
893 unsigned int string_indexof_char(Register result, Register haystack, Register haycnt,
894 Register needle, jchar needleChar, Register odd_reg, Register even_reg, bool is_byte);
895
896 // Emit an oop const to the constant pool and set a relocation info
897 // with address current_pc. Return the TOC offset of the constant.
898 int store_const_in_toc(AddressLiteral& val);
899 int store_oop_in_toc(AddressLiteral& oop);
900 // Emit an oop const to the constant pool via store_oop_in_toc, or
901 // emit a scalar const to the constant pool via store_const_in_toc,
|