< prev index next >

src/hotspot/cpu/x86/macroAssembler_x86.hpp

Print this page

 182 
 183   void movdbl(XMMRegister dst, AddressLiteral src);
 184 
 185   void movdbl(XMMRegister dst, Address src) {
 186     if (UseXmmLoadAndClearUpper) { movsd (dst, src); return; }
 187     else                         { movlpd(dst, src); return; }
 188   }
 189   void movdbl(Address dst, XMMRegister src) { movsd(dst, src); }
 190 
 191   void incrementl(AddressLiteral dst);
 192   void incrementl(ArrayAddress dst);
 193 
 194   void incrementq(AddressLiteral dst);
 195 
 196   // Alignment
 197   void align32();
 198   void align64();
 199   void align(int modulus);
 200   void align(int modulus, int target);
 201 

 202   // A 5 byte nop that is safe for patching (see patch_verified_entry)
 203   void fat_nop();
 204 
 205   // Stack frame creation/removal
 206   void enter();
 207   void leave();
 208 
 209   // Support for getting the JavaThread pointer (i.e.; a reference to thread-local information)
 210   // The pointer will be loaded into the thread register.
 211   void get_thread(Register thread);
 212 
 213 #ifdef _LP64
 214   // Support for argument shuffling
 215 
 216   void move32_64(VMRegPair src, VMRegPair dst);
 217   void long_move(VMRegPair src, VMRegPair dst);
 218   void float_move(VMRegPair src, VMRegPair dst);
 219   void double_move(VMRegPair src, VMRegPair dst);
 220   void move_ptr(VMRegPair src, VMRegPair dst);
 221   void object_move(OopMap* map,

 276   void get_vm_result_2(Register metadata_result, Register thread);
 277 
 278   // These always tightly bind to MacroAssembler::call_VM_base
 279   // bypassing the virtual implementation
 280   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, int number_of_arguments = 0, bool check_exceptions = true);
 281   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, bool check_exceptions = true);
 282   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, bool check_exceptions = true);
 283   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions = true);
 284   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4, bool check_exceptions = true);
 285 
 286   void call_VM_leaf0(address entry_point);
 287   void call_VM_leaf(address entry_point,
 288                     int number_of_arguments = 0);
 289   void call_VM_leaf(address entry_point,
 290                     Register arg_1);
 291   void call_VM_leaf(address entry_point,
 292                     Register arg_1, Register arg_2);
 293   void call_VM_leaf(address entry_point,
 294                     Register arg_1, Register arg_2, Register arg_3);
 295 



 296   // These always tightly bind to MacroAssembler::call_VM_leaf_base
 297   // bypassing the virtual implementation
 298   void super_call_VM_leaf(address entry_point);
 299   void super_call_VM_leaf(address entry_point, Register arg_1);
 300   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2);
 301   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3);
 302   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4);
 303 
 304   // last Java Frame (fills frame anchor)
 305   void set_last_Java_frame(Register thread,
 306                            Register last_java_sp,
 307                            Register last_java_fp,
 308                            address last_java_pc);
 309 
 310   // thread in the default location (r15_thread on 64bit)
 311   void set_last_Java_frame(Register last_java_sp,
 312                            Register last_java_fp,
 313                            address last_java_pc);
 314 
 315   void reset_last_Java_frame(Register thread, bool clear_fp);
 316 
 317   // thread in the default location (r15_thread on 64bit)
 318   void reset_last_Java_frame(bool clear_fp);
 319 


 320   // jobjects
 321   void clear_jweak_tag(Register possibly_jweak);
 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);

 501   // Store double value to 'address'. If UseSSE >= 2, the value is stored
 502   // from register xmm0. Otherwise, the value is stored from the FPU stack.
 503   void store_double(Address dst);
 504 
 505 #ifndef _LP64
 506   // Pop ST (ffree & fincstp combined)
 507   void fpop();
 508 
 509   void empty_FPU_stack();
 510 #endif // !_LP64
 511 
 512   void push_IU_state();
 513   void pop_IU_state();
 514 
 515   void push_FPU_state();
 516   void pop_FPU_state();
 517 
 518   void push_CPU_state();
 519   void pop_CPU_state();
 520 







 521   // Round up to a power of two
 522   void round_to(Register reg, int modulus);
 523 
 524   // Callee saved registers handling
 525   void push_callee_saved_registers();
 526   void pop_callee_saved_registers();
 527 
 528   // allocation
 529   void eden_allocate(
 530     Register thread,                   // Current thread
 531     Register obj,                      // result: pointer to object after successful allocation
 532     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 533     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 534     Register t1,                       // temp register
 535     Label&   slow_case                 // continuation point if fast allocation fails
 536   );
 537   void tlab_allocate(
 538     Register thread,                   // Current thread
 539     Register obj,                      // result: pointer to object after successful allocation
 540     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise

 620 
 621   // TODO: verify method and klass metadata (compare against vptr?)
 622   void _verify_method_ptr(Register reg, const char * msg, const char * file, int line) {}
 623   void _verify_klass_ptr(Register reg, const char * msg, const char * file, int line){}
 624 
 625 #define verify_oop(reg) _verify_oop_checked(reg, "broken oop " #reg, __FILE__, __LINE__)
 626 #define verify_oop_msg(reg, msg) _verify_oop_checked(reg, "broken oop " #reg ", " #msg, __FILE__, __LINE__)
 627 #define verify_oop_addr(addr) _verify_oop_addr_checked(addr, "broken oop addr " #addr, __FILE__, __LINE__)
 628 #define verify_method_ptr(reg) _verify_method_ptr(reg, "broken method " #reg, __FILE__, __LINE__)
 629 #define verify_klass_ptr(reg) _verify_klass_ptr(reg, "broken klass " #reg, __FILE__, __LINE__)
 630 
 631   // Verify or restore cpu control state after JNI call
 632   void restore_cpu_control_state_after_jni();
 633 
 634   // prints msg, dumps registers and stops execution
 635   void stop(const char* msg);
 636 
 637   // prints msg and continues
 638   void warn(const char* msg);
 639 




 640   // dumps registers and other state
 641   void print_state();
 642 
 643   static void debug32(int rdi, int rsi, int rbp, int rsp, int rbx, int rdx, int rcx, int rax, int eip, char* msg);
 644   static void debug64(char* msg, int64_t pc, int64_t regs[]);
 645   static void print_state32(int rdi, int rsi, int rbp, int rsp, int rbx, int rdx, int rcx, int rax, int eip);
 646   static void print_state64(int64_t pc, int64_t regs[]);
 647 
 648   void os_breakpoint();
 649 
 650   void untested()                                { stop("untested"); }
 651 
 652   void unimplemented(const char* what = "");
 653 
 654   void should_not_reach_here()                   { stop("should not reach here"); }
 655 
 656   void print_CPU_state();
 657 
 658   // Stack overflow checking
 659   void bang_stack_with_offset(int offset) {

 825   void call(AddressLiteral entry);
 826 
 827   // Emit the CompiledIC call idiom
 828   void ic_call(address entry, jint method_index = 0);
 829 
 830   // Jumps
 831 
 832   // NOTE: these jumps tranfer to the effective address of dst NOT
 833   // the address contained by dst. This is because this is more natural
 834   // for jumps/calls.
 835   void jump(AddressLiteral dst);
 836   void jump_cc(Condition cc, AddressLiteral dst);
 837 
 838   // 32bit can do a case table jump in one instruction but we no longer allow the base
 839   // to be installed in the Address class. This jump will tranfers to the address
 840   // contained in the location described by entry (not the address of entry)
 841   void jump(ArrayAddress entry);
 842 
 843   // Floating
 844 





 845   void andpd(XMMRegister dst, Address src) { Assembler::andpd(dst, src); }
 846   void andpd(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 847   void andpd(XMMRegister dst, XMMRegister src) { Assembler::andpd(dst, src); }
 848 
 849   void andps(XMMRegister dst, XMMRegister src) { Assembler::andps(dst, src); }
 850   void andps(XMMRegister dst, Address src) { Assembler::andps(dst, src); }
 851   void andps(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 852 
 853   void comiss(XMMRegister dst, XMMRegister src) { Assembler::comiss(dst, src); }
 854   void comiss(XMMRegister dst, Address src) { Assembler::comiss(dst, src); }
 855   void comiss(XMMRegister dst, AddressLiteral src);
 856 
 857   void comisd(XMMRegister dst, XMMRegister src) { Assembler::comisd(dst, src); }
 858   void comisd(XMMRegister dst, Address src) { Assembler::comisd(dst, src); }
 859   void comisd(XMMRegister dst, AddressLiteral src);
 860 
 861 #ifndef _LP64
 862   void fadd_s(Address src)        { Assembler::fadd_s(src); }
 863   void fadd_s(AddressLiteral src) { Assembler::fadd_s(as_Address(src)); }
 864 

1152   void evmovdquq(XMMRegister dst, Address src, int vector_len) { Assembler::evmovdquq(dst, src, vector_len); }
1153   void evmovdquq(Address dst, XMMRegister src, int vector_len) { Assembler::evmovdquq(dst, src, vector_len); }
1154   void evmovdquq(XMMRegister dst, AddressLiteral src, int vector_len, Register rscratch);
1155   void evmovdquq(XMMRegister dst, XMMRegister src, int vector_len) {
1156     if (dst->encoding() == src->encoding()) return;
1157     Assembler::evmovdquq(dst, src, vector_len);
1158   }
1159   void evmovdquq(Address dst, KRegister mask, XMMRegister src, bool merge, int vector_len) { Assembler::evmovdquq(dst, mask, src, merge, vector_len); }
1160   void evmovdquq(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len) { Assembler::evmovdquq(dst, mask, src, merge, vector_len); }
1161   void evmovdquq(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len) {
1162     if (dst->encoding() == src->encoding() && mask == k0) return;
1163     Assembler::evmovdquq(dst, mask, src, merge, vector_len);
1164   }
1165   void evmovdquq(XMMRegister dst, KRegister mask, AddressLiteral src, bool merge, int vector_len, Register scratch_reg);
1166 
1167   // Move Aligned Double Quadword
1168   void movdqa(XMMRegister dst, Address src)       { Assembler::movdqa(dst, src); }
1169   void movdqa(XMMRegister dst, XMMRegister src)   { Assembler::movdqa(dst, src); }
1170   void movdqa(XMMRegister dst, AddressLiteral src);
1171 










1172   void movsd(XMMRegister dst, XMMRegister src) { Assembler::movsd(dst, src); }
1173   void movsd(Address dst, XMMRegister src)     { Assembler::movsd(dst, src); }
1174   void movsd(XMMRegister dst, Address src)     { Assembler::movsd(dst, src); }
1175   void movsd(XMMRegister dst, AddressLiteral src);
1176 
1177   void mulpd(XMMRegister dst, XMMRegister src)    { Assembler::mulpd(dst, src); }
1178   void mulpd(XMMRegister dst, Address src)        { Assembler::mulpd(dst, src); }
1179   void mulpd(XMMRegister dst, AddressLiteral src);
1180 
1181   void mulsd(XMMRegister dst, XMMRegister src)    { Assembler::mulsd(dst, src); }
1182   void mulsd(XMMRegister dst, Address src)        { Assembler::mulsd(dst, src); }
1183   void mulsd(XMMRegister dst, AddressLiteral src);
1184 
1185   void mulss(XMMRegister dst, XMMRegister src)    { Assembler::mulss(dst, src); }
1186   void mulss(XMMRegister dst, Address src)        { Assembler::mulss(dst, src); }
1187   void mulss(XMMRegister dst, AddressLiteral src);
1188 
1189   // Carry-Less Multiplication Quadword
1190   void pclmulldq(XMMRegister dst, XMMRegister src) {
1191     // 0x00 - multiply lower 64 bits [0:63]

 182 
 183   void movdbl(XMMRegister dst, AddressLiteral src);
 184 
 185   void movdbl(XMMRegister dst, Address src) {
 186     if (UseXmmLoadAndClearUpper) { movsd (dst, src); return; }
 187     else                         { movlpd(dst, src); return; }
 188   }
 189   void movdbl(Address dst, XMMRegister src) { movsd(dst, src); }
 190 
 191   void incrementl(AddressLiteral dst);
 192   void incrementl(ArrayAddress dst);
 193 
 194   void incrementq(AddressLiteral dst);
 195 
 196   // Alignment
 197   void align32();
 198   void align64();
 199   void align(int modulus);
 200   void align(int modulus, int target);
 201 
 202   void post_call_nop();
 203   // A 5 byte nop that is safe for patching (see patch_verified_entry)
 204   void fat_nop();
 205 
 206   // Stack frame creation/removal
 207   void enter();
 208   void leave();
 209 
 210   // Support for getting the JavaThread pointer (i.e.; a reference to thread-local information)
 211   // The pointer will be loaded into the thread register.
 212   void get_thread(Register thread);
 213 
 214 #ifdef _LP64
 215   // Support for argument shuffling
 216 
 217   void move32_64(VMRegPair src, VMRegPair dst);
 218   void long_move(VMRegPair src, VMRegPair dst);
 219   void float_move(VMRegPair src, VMRegPair dst);
 220   void double_move(VMRegPair src, VMRegPair dst);
 221   void move_ptr(VMRegPair src, VMRegPair dst);
 222   void object_move(OopMap* map,

 277   void get_vm_result_2(Register metadata_result, Register thread);
 278 
 279   // These always tightly bind to MacroAssembler::call_VM_base
 280   // bypassing the virtual implementation
 281   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, int number_of_arguments = 0, bool check_exceptions = true);
 282   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, bool check_exceptions = true);
 283   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, bool check_exceptions = true);
 284   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, bool check_exceptions = true);
 285   void super_call_VM(Register oop_result, Register last_java_sp, address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4, bool check_exceptions = true);
 286 
 287   void call_VM_leaf0(address entry_point);
 288   void call_VM_leaf(address entry_point,
 289                     int number_of_arguments = 0);
 290   void call_VM_leaf(address entry_point,
 291                     Register arg_1);
 292   void call_VM_leaf(address entry_point,
 293                     Register arg_1, Register arg_2);
 294   void call_VM_leaf(address entry_point,
 295                     Register arg_1, Register arg_2, Register arg_3);
 296 
 297   void call_VM_leaf(address entry_point,
 298                     Register arg_1, Register arg_2, Register arg_3, Register arg_4);
 299 
 300   // These always tightly bind to MacroAssembler::call_VM_leaf_base
 301   // bypassing the virtual implementation
 302   void super_call_VM_leaf(address entry_point);
 303   void super_call_VM_leaf(address entry_point, Register arg_1);
 304   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2);
 305   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3);
 306   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4);
 307 
 308   // last Java Frame (fills frame anchor)
 309   void set_last_Java_frame(Register thread,
 310                            Register last_java_sp,
 311                            Register last_java_fp,
 312                            address last_java_pc);
 313 
 314   // thread in the default location (r15_thread on 64bit)
 315   void set_last_Java_frame(Register last_java_sp,
 316                            Register last_java_fp,
 317                            address last_java_pc);
 318 
 319   void reset_last_Java_frame(Register thread, bool clear_fp);
 320 
 321   // thread in the default location (r15_thread on 64bit)
 322   void reset_last_Java_frame(bool clear_fp);
 323 
 324   void oopmap_metadata(int index);
 325 
 326   // jobjects
 327   void clear_jweak_tag(Register possibly_jweak);
 328   void resolve_jobject(Register value, Register thread, Register tmp);
 329 
 330   // C 'boolean' to Java boolean: x == 0 ? 0 : 1
 331   void c2bool(Register x);
 332 
 333   // C++ bool manipulation
 334 
 335   void movbool(Register dst, Address src);
 336   void movbool(Address dst, bool boolconst);
 337   void movbool(Address dst, Register src);
 338   void testbool(Register dst);
 339 
 340   void resolve_oop_handle(Register result, Register tmp = rscratch2);
 341   void resolve_weak_handle(Register result, Register tmp);
 342   void load_mirror(Register mirror, Register method, Register tmp = rscratch2);
 343   void load_method_holder_cld(Register rresult, Register rmethod);
 344 
 345   void load_method_holder(Register holder, Register method);

 507   // Store double value to 'address'. If UseSSE >= 2, the value is stored
 508   // from register xmm0. Otherwise, the value is stored from the FPU stack.
 509   void store_double(Address dst);
 510 
 511 #ifndef _LP64
 512   // Pop ST (ffree & fincstp combined)
 513   void fpop();
 514 
 515   void empty_FPU_stack();
 516 #endif // !_LP64
 517 
 518   void push_IU_state();
 519   void pop_IU_state();
 520 
 521   void push_FPU_state();
 522   void pop_FPU_state();
 523 
 524   void push_CPU_state();
 525   void pop_CPU_state();
 526 
 527   void push_cont_fastpath(Register java_thread);
 528   void pop_cont_fastpath(Register java_thread);
 529   void inc_held_monitor_count(Register java_thread);
 530   void dec_held_monitor_count(Register java_thread);
 531   void reset_held_monitor_count(Register java_thread);
 532   DEBUG_ONLY(void stop_if_in_cont(Register cont_reg, const char* name);)
 533 
 534   // Round up to a power of two
 535   void round_to(Register reg, int modulus);
 536 
 537   // Callee saved registers handling
 538   void push_callee_saved_registers();
 539   void pop_callee_saved_registers();
 540 
 541   // allocation
 542   void eden_allocate(
 543     Register thread,                   // Current thread
 544     Register obj,                      // result: pointer to object after successful allocation
 545     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 546     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 547     Register t1,                       // temp register
 548     Label&   slow_case                 // continuation point if fast allocation fails
 549   );
 550   void tlab_allocate(
 551     Register thread,                   // Current thread
 552     Register obj,                      // result: pointer to object after successful allocation
 553     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise

 633 
 634   // TODO: verify method and klass metadata (compare against vptr?)
 635   void _verify_method_ptr(Register reg, const char * msg, const char * file, int line) {}
 636   void _verify_klass_ptr(Register reg, const char * msg, const char * file, int line){}
 637 
 638 #define verify_oop(reg) _verify_oop_checked(reg, "broken oop " #reg, __FILE__, __LINE__)
 639 #define verify_oop_msg(reg, msg) _verify_oop_checked(reg, "broken oop " #reg ", " #msg, __FILE__, __LINE__)
 640 #define verify_oop_addr(addr) _verify_oop_addr_checked(addr, "broken oop addr " #addr, __FILE__, __LINE__)
 641 #define verify_method_ptr(reg) _verify_method_ptr(reg, "broken method " #reg, __FILE__, __LINE__)
 642 #define verify_klass_ptr(reg) _verify_klass_ptr(reg, "broken klass " #reg, __FILE__, __LINE__)
 643 
 644   // Verify or restore cpu control state after JNI call
 645   void restore_cpu_control_state_after_jni();
 646 
 647   // prints msg, dumps registers and stops execution
 648   void stop(const char* msg);
 649 
 650   // prints msg and continues
 651   void warn(const char* msg);
 652 
 653   void _assert_asm(Condition cc, const char* msg);
 654 #define assert_asm0(cc, msg) _assert_asm(cc, FILE_AND_LINE ": " msg)
 655 #define assert_asm(masm, command, cc, msg) DEBUG_ONLY((masm)->command; (masm)->_assert_asm(cc, FILE_AND_LINE ": " #command " " #cc ": " msg))
 656 
 657   // dumps registers and other state
 658   void print_state();
 659 
 660   static void debug32(int rdi, int rsi, int rbp, int rsp, int rbx, int rdx, int rcx, int rax, int eip, char* msg);
 661   static void debug64(char* msg, int64_t pc, int64_t regs[]);
 662   static void print_state32(int rdi, int rsi, int rbp, int rsp, int rbx, int rdx, int rcx, int rax, int eip);
 663   static void print_state64(int64_t pc, int64_t regs[]);
 664 
 665   void os_breakpoint();
 666 
 667   void untested()                                { stop("untested"); }
 668 
 669   void unimplemented(const char* what = "");
 670 
 671   void should_not_reach_here()                   { stop("should not reach here"); }
 672 
 673   void print_CPU_state();
 674 
 675   // Stack overflow checking
 676   void bang_stack_with_offset(int offset) {

 842   void call(AddressLiteral entry);
 843 
 844   // Emit the CompiledIC call idiom
 845   void ic_call(address entry, jint method_index = 0);
 846 
 847   // Jumps
 848 
 849   // NOTE: these jumps tranfer to the effective address of dst NOT
 850   // the address contained by dst. This is because this is more natural
 851   // for jumps/calls.
 852   void jump(AddressLiteral dst);
 853   void jump_cc(Condition cc, AddressLiteral dst);
 854 
 855   // 32bit can do a case table jump in one instruction but we no longer allow the base
 856   // to be installed in the Address class. This jump will tranfers to the address
 857   // contained in the location described by entry (not the address of entry)
 858   void jump(ArrayAddress entry);
 859 
 860   // Floating
 861 
 862   void push_f(XMMRegister r);
 863   void pop_f(XMMRegister r);
 864   void push_d(XMMRegister r);
 865   void pop_d(XMMRegister r);
 866 
 867   void andpd(XMMRegister dst, Address src) { Assembler::andpd(dst, src); }
 868   void andpd(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 869   void andpd(XMMRegister dst, XMMRegister src) { Assembler::andpd(dst, src); }
 870 
 871   void andps(XMMRegister dst, XMMRegister src) { Assembler::andps(dst, src); }
 872   void andps(XMMRegister dst, Address src) { Assembler::andps(dst, src); }
 873   void andps(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 874 
 875   void comiss(XMMRegister dst, XMMRegister src) { Assembler::comiss(dst, src); }
 876   void comiss(XMMRegister dst, Address src) { Assembler::comiss(dst, src); }
 877   void comiss(XMMRegister dst, AddressLiteral src);
 878 
 879   void comisd(XMMRegister dst, XMMRegister src) { Assembler::comisd(dst, src); }
 880   void comisd(XMMRegister dst, Address src) { Assembler::comisd(dst, src); }
 881   void comisd(XMMRegister dst, AddressLiteral src);
 882 
 883 #ifndef _LP64
 884   void fadd_s(Address src)        { Assembler::fadd_s(src); }
 885   void fadd_s(AddressLiteral src) { Assembler::fadd_s(as_Address(src)); }
 886 

1174   void evmovdquq(XMMRegister dst, Address src, int vector_len) { Assembler::evmovdquq(dst, src, vector_len); }
1175   void evmovdquq(Address dst, XMMRegister src, int vector_len) { Assembler::evmovdquq(dst, src, vector_len); }
1176   void evmovdquq(XMMRegister dst, AddressLiteral src, int vector_len, Register rscratch);
1177   void evmovdquq(XMMRegister dst, XMMRegister src, int vector_len) {
1178     if (dst->encoding() == src->encoding()) return;
1179     Assembler::evmovdquq(dst, src, vector_len);
1180   }
1181   void evmovdquq(Address dst, KRegister mask, XMMRegister src, bool merge, int vector_len) { Assembler::evmovdquq(dst, mask, src, merge, vector_len); }
1182   void evmovdquq(XMMRegister dst, KRegister mask, Address src, bool merge, int vector_len) { Assembler::evmovdquq(dst, mask, src, merge, vector_len); }
1183   void evmovdquq(XMMRegister dst, KRegister mask, XMMRegister src, bool merge, int vector_len) {
1184     if (dst->encoding() == src->encoding() && mask == k0) return;
1185     Assembler::evmovdquq(dst, mask, src, merge, vector_len);
1186   }
1187   void evmovdquq(XMMRegister dst, KRegister mask, AddressLiteral src, bool merge, int vector_len, Register scratch_reg);
1188 
1189   // Move Aligned Double Quadword
1190   void movdqa(XMMRegister dst, Address src)       { Assembler::movdqa(dst, src); }
1191   void movdqa(XMMRegister dst, XMMRegister src)   { Assembler::movdqa(dst, src); }
1192   void movdqa(XMMRegister dst, AddressLiteral src);
1193 
1194   // Move Aligned, possibly non-temporal
1195   void movqa(Address dst, Register src, bool nt);       // 64-bit
1196   void movdqa(Address dst, XMMRegister src, bool nt);   // 128-bit
1197   void vmovdqa(Address dst, XMMRegister src, bool nt);  // 256-bit
1198   void evmovdqa(Address dst, XMMRegister src, int vector_len, bool nt); // 512-bit
1199 
1200   void movdqa(XMMRegister dst, Address src, bool nt);   // 128-bit
1201   void vmovdqa(XMMRegister dst, Address src, bool nt);  // 256-bit
1202   void evmovdqa(XMMRegister dst, Address src, int vector_len, bool nt); // 512-bit
1203 
1204   void movsd(XMMRegister dst, XMMRegister src) { Assembler::movsd(dst, src); }
1205   void movsd(Address dst, XMMRegister src)     { Assembler::movsd(dst, src); }
1206   void movsd(XMMRegister dst, Address src)     { Assembler::movsd(dst, src); }
1207   void movsd(XMMRegister dst, AddressLiteral src);
1208 
1209   void mulpd(XMMRegister dst, XMMRegister src)    { Assembler::mulpd(dst, src); }
1210   void mulpd(XMMRegister dst, Address src)        { Assembler::mulpd(dst, src); }
1211   void mulpd(XMMRegister dst, AddressLiteral src);
1212 
1213   void mulsd(XMMRegister dst, XMMRegister src)    { Assembler::mulsd(dst, src); }
1214   void mulsd(XMMRegister dst, Address src)        { Assembler::mulsd(dst, src); }
1215   void mulsd(XMMRegister dst, AddressLiteral src);
1216 
1217   void mulss(XMMRegister dst, XMMRegister src)    { Assembler::mulss(dst, src); }
1218   void mulss(XMMRegister dst, Address src)        { Assembler::mulss(dst, src); }
1219   void mulss(XMMRegister dst, AddressLiteral src);
1220 
1221   // Carry-Less Multiplication Quadword
1222   void pclmulldq(XMMRegister dst, XMMRegister src) {
1223     // 0x00 - multiply lower 64 bits [0:63]
< prev index next >