< prev index next >

src/hotspot/cpu/x86/macroAssembler_x86.hpp

Print this page

 322   void resolve_jobject(Register value, Register thread, Register tmp);
 323 
 324   // C 'boolean' to Java boolean: x == 0 ? 0 : 1
 325   void c2bool(Register x);
 326 
 327   // C++ bool manipulation
 328 
 329   void movbool(Register dst, Address src);
 330   void movbool(Address dst, bool boolconst);
 331   void movbool(Address dst, Register src);
 332   void testbool(Register dst);
 333 
 334   void resolve_oop_handle(Register result, Register tmp = rscratch2);
 335   void resolve_weak_handle(Register result, Register tmp);
 336   void load_mirror(Register mirror, Register method, Register tmp = rscratch2);
 337   void load_method_holder_cld(Register rresult, Register rmethod);
 338 
 339   void load_method_holder(Register holder, Register method);
 340 
 341   // oop manipulations
 342   void load_klass(Register dst, Register src, Register tmp);



 343   void store_klass(Register dst, Register src, Register tmp);
 344 








 345   void access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
 346                       Register tmp1, Register thread_tmp);
 347   void access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register src,
 348                        Register tmp1, Register tmp2);
 349 
 350   void load_heap_oop(Register dst, Address src, Register tmp1 = noreg,
 351                      Register thread_tmp = noreg, DecoratorSet decorators = 0);
 352   void load_heap_oop_not_null(Register dst, Address src, Register tmp1 = noreg,
 353                               Register thread_tmp = noreg, DecoratorSet decorators = 0);
 354   void store_heap_oop(Address dst, Register src, Register tmp1 = noreg,
 355                       Register tmp2 = noreg, DecoratorSet decorators = 0);
 356 
 357   // Used for storing NULL. All other oop constants should be
 358   // stored using routines that take a jobject.
 359   void store_heap_oop_null(Address dst);
 360 
 361   void load_prototype_header(Register dst, Register src, Register tmp);
 362 
 363 #ifdef _LP64
 364   void store_klass_gap(Register dst, Register src);

1706   using Assembler::movq;
1707   void movdl(XMMRegister dst, AddressLiteral src);
1708   void movq(XMMRegister dst, AddressLiteral src);
1709 
1710   // Can push value or effective address
1711   void pushptr(AddressLiteral src);
1712 
1713   void pushptr(Address src) { LP64_ONLY(pushq(src)) NOT_LP64(pushl(src)); }
1714   void popptr(Address src) { LP64_ONLY(popq(src)) NOT_LP64(popl(src)); }
1715 
1716   void pushoop(jobject obj);
1717   void pushklass(Metadata* obj);
1718 
1719   // sign extend as need a l to ptr sized element
1720   void movl2ptr(Register dst, Address src) { LP64_ONLY(movslq(dst, src)) NOT_LP64(movl(dst, src)); }
1721   void movl2ptr(Register dst, Register src) { LP64_ONLY(movslq(dst, src)) NOT_LP64(if (dst != src) movl(dst, src)); }
1722 
1723 
1724  public:
1725   // C2 compiled method's prolog code.
1726   void verified_entry(int framesize, int stack_bang_size, bool fp_mode_24b, bool is_stub);
1727 
1728   // clear memory of size 'cnt' qwords, starting at 'base';
1729   // if 'is_large' is set, do not try to produce short loop
1730   void clear_mem(Register base, Register cnt, Register rtmp, XMMRegister xtmp, bool is_large, KRegister mask=knoreg);
1731 
1732   // clear memory initialization sequence for constant size;
1733   void clear_mem(Register base, int cnt, Register rtmp, XMMRegister xtmp, KRegister mask=knoreg);
1734 
1735   // clear memory of size 'cnt' qwords, starting at 'base' using XMM/YMM registers
1736   void xmm_clear_mem(Register base, Register cnt, Register rtmp, XMMRegister xtmp, KRegister mask=knoreg);
1737 
1738   // Fill primitive arrays
1739   void generate_fill(BasicType t, bool aligned,
1740                      Register to, Register value, Register count,
1741                      Register rtmp, XMMRegister xtmp);
1742 
1743   void encode_iso_array(Register src, Register dst, Register len,
1744                         XMMRegister tmp1, XMMRegister tmp2, XMMRegister tmp3,
1745                         XMMRegister tmp4, Register tmp5, Register result, bool ascii);
1746 

1893   void copy64_masked_avx(Register dst, Register src, XMMRegister xmm,
1894                          KRegister mask, Register length, Register index,
1895                          Register temp, int shift = Address::times_1, int offset = 0,
1896                          bool use64byteVector = false);
1897 
1898   void copy32_masked_avx(Register dst, Register src, XMMRegister xmm,
1899                          KRegister mask, Register length, Register index,
1900                          Register temp, int shift = Address::times_1, int offset = 0);
1901 
1902   void copy32_avx(Register dst, Register src, Register index, XMMRegister xmm,
1903                   int shift = Address::times_1, int offset = 0);
1904 
1905   void copy64_avx(Register dst, Register src, Register index, XMMRegister xmm,
1906                   bool conjoint, int shift = Address::times_1, int offset = 0,
1907                   bool use64byteVector = false);
1908 #endif // COMPILER2_OR_JVMCI
1909 
1910 #endif // _LP64
1911 
1912   void vallones(XMMRegister dst, int vector_len);



1913 };
1914 
1915 /**
1916  * class SkipIfEqual:
1917  *
1918  * Instantiating this class will result in assembly code being output that will
1919  * jump around any code emitted between the creation of the instance and it's
1920  * automatic destruction at the end of a scope block, depending on the value of
1921  * the flag passed to the constructor, which will be checked at run-time.
1922  */
1923 class SkipIfEqual {
1924  private:
1925   MacroAssembler* _masm;
1926   Label _label;
1927 
1928  public:
1929    SkipIfEqual(MacroAssembler*, const bool* flag_addr, bool value);
1930    ~SkipIfEqual();
1931 };
1932 

 322   void resolve_jobject(Register value, Register thread, Register tmp);
 323 
 324   // C 'boolean' to Java boolean: x == 0 ? 0 : 1
 325   void c2bool(Register x);
 326 
 327   // C++ bool manipulation
 328 
 329   void movbool(Register dst, Address src);
 330   void movbool(Address dst, bool boolconst);
 331   void movbool(Address dst, Register src);
 332   void testbool(Register dst);
 333 
 334   void resolve_oop_handle(Register result, Register tmp = rscratch2);
 335   void resolve_weak_handle(Register result, Register tmp);
 336   void load_mirror(Register mirror, Register method, Register tmp = rscratch2);
 337   void load_method_holder_cld(Register rresult, Register rmethod);
 338 
 339   void load_method_holder(Register holder, Register method);
 340 
 341   // oop manipulations
 342   void load_klass(Register dst, Register src, Register tmp, bool null_check_src = false);
 343 #ifdef _LP64
 344   void load_nklass(Register dst, Register src);
 345 #endif
 346   void store_klass(Register dst, Register src, Register tmp);
 347 
 348   // Compares the Klass pointer of an object to a given Klass (which might be narrow,
 349   // depending on UseCompressedClassPointers).
 350   void cmp_klass(Register klass, Register dst, Register tmp);
 351 
 352   // Compares the Klass pointer of two objects o1 and o2. Result is in the condition flags.
 353   // Uses t1 and t2 as temporary registers.
 354   void cmp_klass(Register src, Register dst, Register tmp1, Register tmp2);
 355 
 356   void access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
 357                       Register tmp1, Register thread_tmp);
 358   void access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register src,
 359                        Register tmp1, Register tmp2);
 360 
 361   void load_heap_oop(Register dst, Address src, Register tmp1 = noreg,
 362                      Register thread_tmp = noreg, DecoratorSet decorators = 0);
 363   void load_heap_oop_not_null(Register dst, Address src, Register tmp1 = noreg,
 364                               Register thread_tmp = noreg, DecoratorSet decorators = 0);
 365   void store_heap_oop(Address dst, Register src, Register tmp1 = noreg,
 366                       Register tmp2 = noreg, DecoratorSet decorators = 0);
 367 
 368   // Used for storing NULL. All other oop constants should be
 369   // stored using routines that take a jobject.
 370   void store_heap_oop_null(Address dst);
 371 
 372   void load_prototype_header(Register dst, Register src, Register tmp);
 373 
 374 #ifdef _LP64
 375   void store_klass_gap(Register dst, Register src);

1717   using Assembler::movq;
1718   void movdl(XMMRegister dst, AddressLiteral src);
1719   void movq(XMMRegister dst, AddressLiteral src);
1720 
1721   // Can push value or effective address
1722   void pushptr(AddressLiteral src);
1723 
1724   void pushptr(Address src) { LP64_ONLY(pushq(src)) NOT_LP64(pushl(src)); }
1725   void popptr(Address src) { LP64_ONLY(popq(src)) NOT_LP64(popl(src)); }
1726 
1727   void pushoop(jobject obj);
1728   void pushklass(Metadata* obj);
1729 
1730   // sign extend as need a l to ptr sized element
1731   void movl2ptr(Register dst, Address src) { LP64_ONLY(movslq(dst, src)) NOT_LP64(movl(dst, src)); }
1732   void movl2ptr(Register dst, Register src) { LP64_ONLY(movslq(dst, src)) NOT_LP64(if (dst != src) movl(dst, src)); }
1733 
1734 
1735  public:
1736   // C2 compiled method's prolog code.
1737   void verified_entry(int framesize, int stack_bang_size, bool fp_mode_24b, bool is_stub, int max_monitors);
1738 
1739   // clear memory of size 'cnt' qwords, starting at 'base';
1740   // if 'is_large' is set, do not try to produce short loop
1741   void clear_mem(Register base, Register cnt, Register rtmp, XMMRegister xtmp, bool is_large, KRegister mask=knoreg);
1742 
1743   // clear memory initialization sequence for constant size;
1744   void clear_mem(Register base, int cnt, Register rtmp, XMMRegister xtmp, KRegister mask=knoreg);
1745 
1746   // clear memory of size 'cnt' qwords, starting at 'base' using XMM/YMM registers
1747   void xmm_clear_mem(Register base, Register cnt, Register rtmp, XMMRegister xtmp, KRegister mask=knoreg);
1748 
1749   // Fill primitive arrays
1750   void generate_fill(BasicType t, bool aligned,
1751                      Register to, Register value, Register count,
1752                      Register rtmp, XMMRegister xtmp);
1753 
1754   void encode_iso_array(Register src, Register dst, Register len,
1755                         XMMRegister tmp1, XMMRegister tmp2, XMMRegister tmp3,
1756                         XMMRegister tmp4, Register tmp5, Register result, bool ascii);
1757 

1904   void copy64_masked_avx(Register dst, Register src, XMMRegister xmm,
1905                          KRegister mask, Register length, Register index,
1906                          Register temp, int shift = Address::times_1, int offset = 0,
1907                          bool use64byteVector = false);
1908 
1909   void copy32_masked_avx(Register dst, Register src, XMMRegister xmm,
1910                          KRegister mask, Register length, Register index,
1911                          Register temp, int shift = Address::times_1, int offset = 0);
1912 
1913   void copy32_avx(Register dst, Register src, Register index, XMMRegister xmm,
1914                   int shift = Address::times_1, int offset = 0);
1915 
1916   void copy64_avx(Register dst, Register src, Register index, XMMRegister xmm,
1917                   bool conjoint, int shift = Address::times_1, int offset = 0,
1918                   bool use64byteVector = false);
1919 #endif // COMPILER2_OR_JVMCI
1920 
1921 #endif // _LP64
1922 
1923   void vallones(XMMRegister dst, int vector_len);
1924 
1925   void fast_lock_impl(Register obj, Register hdr, Register thread, Register tmp, Label& slow, bool rt_check_stack = true);
1926   void fast_unlock_impl(Register obj, Register hdr, Register tmp, Label& slow);
1927 };
1928 
1929 /**
1930  * class SkipIfEqual:
1931  *
1932  * Instantiating this class will result in assembly code being output that will
1933  * jump around any code emitted between the creation of the instance and it's
1934  * automatic destruction at the end of a scope block, depending on the value of
1935  * the flag passed to the constructor, which will be checked at run-time.
1936  */
1937 class SkipIfEqual {
1938  private:
1939   MacroAssembler* _masm;
1940   Label _label;
1941 
1942  public:
1943    SkipIfEqual(MacroAssembler*, const bool* flag_addr, bool value);
1944    ~SkipIfEqual();
1945 };
1946 
< prev index next >