< 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);

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);

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);
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 >