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

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



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

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

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