< prev index next >

src/hotspot/cpu/x86/macroAssembler_x86.hpp

Print this page




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

 199   // A 5 byte nop that is safe for patching (see patch_verified_entry)
 200   void fat_nop();
 201 
 202   // Stack frame creation/removal
 203   void enter();
 204   void leave();
 205 
 206   // Support for getting the JavaThread pointer (i.e.; a reference to thread-local information)
 207   // The pointer will be loaded into the thread register.
 208   void get_thread(Register thread);
 209 
 210 
 211   // Support for VM calls
 212   //
 213   // It is imperative that all calls into the VM are handled via the call_VM macros.
 214   // They make sure that the stack linkage is setup correctly. call_VM's correspond
 215   // to ENTRY/ENTRY_X entry points while call_VM_leaf's correspond to LEAF entry points.
 216 
 217 
 218   void call_VM(Register oop_result,


 281   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2);
 282   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3);
 283   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4);
 284 
 285   // last Java Frame (fills frame anchor)
 286   void set_last_Java_frame(Register thread,
 287                            Register last_java_sp,
 288                            Register last_java_fp,
 289                            address last_java_pc);
 290 
 291   // thread in the default location (r15_thread on 64bit)
 292   void set_last_Java_frame(Register last_java_sp,
 293                            Register last_java_fp,
 294                            address last_java_pc);
 295 
 296   void reset_last_Java_frame(Register thread, bool clear_fp);
 297 
 298   // thread in the default location (r15_thread on 64bit)
 299   void reset_last_Java_frame(bool clear_fp);
 300 


 301   // jobjects
 302   void clear_jweak_tag(Register possibly_jweak);
 303   void resolve_jobject(Register value, Register thread, Register tmp);
 304 
 305   // C 'boolean' to Java boolean: x == 0 ? 0 : 1
 306   void c2bool(Register x);
 307 
 308   // C++ bool manipulation
 309 
 310   void movbool(Register dst, Address src);
 311   void movbool(Address dst, bool boolconst);
 312   void movbool(Address dst, Register src);
 313   void testbool(Register dst);
 314 
 315   void resolve_oop_handle(Register result, Register tmp = rscratch2);
 316   void resolve_weak_handle(Register result, Register tmp);
 317   void load_mirror(Register mirror, Register method, Register tmp = rscratch2);
 318   void load_method_holder_cld(Register rresult, Register rmethod);
 319 
 320   void load_method_holder(Register holder, Register method);


 491   // from register xmm0. Otherwise, the value is stored from the FPU stack.
 492   void store_double(Address dst);
 493 
 494   // pushes double TOS element of FPU stack on CPU stack; pops from FPU stack
 495   void push_fTOS();
 496 
 497   // pops double TOS element from CPU stack and pushes on FPU stack
 498   void pop_fTOS();
 499 
 500   void empty_FPU_stack();
 501 
 502   void push_IU_state();
 503   void pop_IU_state();
 504 
 505   void push_FPU_state();
 506   void pop_FPU_state();
 507 
 508   void push_CPU_state();
 509   void pop_CPU_state();
 510 




 511   // Round up to a power of two
 512   void round_to(Register reg, int modulus);
 513 
 514   // Callee saved registers handling
 515   void push_callee_saved_registers();
 516   void pop_callee_saved_registers();
 517 
 518   // allocation
 519   void eden_allocate(
 520     Register thread,                   // Current thread
 521     Register obj,                      // result: pointer to object after successful allocation
 522     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 523     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 524     Register t1,                       // temp register
 525     Label&   slow_case                 // continuation point if fast allocation fails
 526   );
 527   void tlab_allocate(
 528     Register thread,                   // Current thread
 529     Register obj,                      // result: pointer to object after successful allocation
 530     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise


 867   // for jumps/calls.
 868   void call(AddressLiteral entry);
 869 
 870   // Emit the CompiledIC call idiom
 871   void ic_call(address entry, jint method_index = 0);
 872 
 873   // Jumps
 874 
 875   // NOTE: these jumps tranfer to the effective address of dst NOT
 876   // the address contained by dst. This is because this is more natural
 877   // for jumps/calls.
 878   void jump(AddressLiteral dst);
 879   void jump_cc(Condition cc, AddressLiteral dst);
 880 
 881   // 32bit can do a case table jump in one instruction but we no longer allow the base
 882   // to be installed in the Address class. This jump will tranfers to the address
 883   // contained in the location described by entry (not the address of entry)
 884   void jump(ArrayAddress entry);
 885 
 886   // Floating





 887 
 888   void andpd(XMMRegister dst, Address src) { Assembler::andpd(dst, src); }
 889   void andpd(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 890   void andpd(XMMRegister dst, XMMRegister src) { Assembler::andpd(dst, src); }
 891 
 892   void andps(XMMRegister dst, XMMRegister src) { Assembler::andps(dst, src); }
 893   void andps(XMMRegister dst, Address src) { Assembler::andps(dst, src); }
 894   void andps(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 895 
 896   void comiss(XMMRegister dst, XMMRegister src) { Assembler::comiss(dst, src); }
 897   void comiss(XMMRegister dst, Address src) { Assembler::comiss(dst, src); }
 898   void comiss(XMMRegister dst, AddressLiteral src);
 899 
 900   void comisd(XMMRegister dst, XMMRegister src) { Assembler::comisd(dst, src); }
 901   void comisd(XMMRegister dst, Address src) { Assembler::comisd(dst, src); }
 902   void comisd(XMMRegister dst, AddressLiteral src);
 903 
 904   void fadd_s(Address src)        { Assembler::fadd_s(src); }
 905   void fadd_s(AddressLiteral src) { Assembler::fadd_s(as_Address(src)); }
 906 




 179     else                       { movsd (dst, src); return; }
 180   }
 181 
 182   void movdbl(XMMRegister dst, AddressLiteral src);
 183 
 184   void movdbl(XMMRegister dst, Address src) {
 185     if (UseXmmLoadAndClearUpper) { movsd (dst, src); return; }
 186     else                         { movlpd(dst, src); return; }
 187   }
 188   void movdbl(Address dst, XMMRegister src) { movsd(dst, src); }
 189 
 190   void incrementl(AddressLiteral dst);
 191   void incrementl(ArrayAddress dst);
 192 
 193   void incrementq(AddressLiteral dst);
 194 
 195   // Alignment
 196   void align(int modulus);
 197   void align(int modulus, int target);
 198 
 199   void post_call_nop();
 200   // A 5 byte nop that is safe for patching (see patch_verified_entry)
 201   void fat_nop();
 202 
 203   // Stack frame creation/removal
 204   void enter();
 205   void leave();
 206 
 207   // Support for getting the JavaThread pointer (i.e.; a reference to thread-local information)
 208   // The pointer will be loaded into the thread register.
 209   void get_thread(Register thread);
 210 
 211 
 212   // Support for VM calls
 213   //
 214   // It is imperative that all calls into the VM are handled via the call_VM macros.
 215   // They make sure that the stack linkage is setup correctly. call_VM's correspond
 216   // to ENTRY/ENTRY_X entry points while call_VM_leaf's correspond to LEAF entry points.
 217 
 218 
 219   void call_VM(Register oop_result,


 282   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2);
 283   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3);
 284   void super_call_VM_leaf(address entry_point, Register arg_1, Register arg_2, Register arg_3, Register arg_4);
 285 
 286   // last Java Frame (fills frame anchor)
 287   void set_last_Java_frame(Register thread,
 288                            Register last_java_sp,
 289                            Register last_java_fp,
 290                            address last_java_pc);
 291 
 292   // thread in the default location (r15_thread on 64bit)
 293   void set_last_Java_frame(Register last_java_sp,
 294                            Register last_java_fp,
 295                            address last_java_pc);
 296 
 297   void reset_last_Java_frame(Register thread, bool clear_fp);
 298 
 299   // thread in the default location (r15_thread on 64bit)
 300   void reset_last_Java_frame(bool clear_fp);
 301 
 302   void oopmap_metadata(int index);
 303 
 304   // jobjects
 305   void clear_jweak_tag(Register possibly_jweak);
 306   void resolve_jobject(Register value, Register thread, Register tmp);
 307 
 308   // C 'boolean' to Java boolean: x == 0 ? 0 : 1
 309   void c2bool(Register x);
 310 
 311   // C++ bool manipulation
 312 
 313   void movbool(Register dst, Address src);
 314   void movbool(Address dst, bool boolconst);
 315   void movbool(Address dst, Register src);
 316   void testbool(Register dst);
 317 
 318   void resolve_oop_handle(Register result, Register tmp = rscratch2);
 319   void resolve_weak_handle(Register result, Register tmp);
 320   void load_mirror(Register mirror, Register method, Register tmp = rscratch2);
 321   void load_method_holder_cld(Register rresult, Register rmethod);
 322 
 323   void load_method_holder(Register holder, Register method);


 494   // from register xmm0. Otherwise, the value is stored from the FPU stack.
 495   void store_double(Address dst);
 496 
 497   // pushes double TOS element of FPU stack on CPU stack; pops from FPU stack
 498   void push_fTOS();
 499 
 500   // pops double TOS element from CPU stack and pushes on FPU stack
 501   void pop_fTOS();
 502 
 503   void empty_FPU_stack();
 504 
 505   void push_IU_state();
 506   void pop_IU_state();
 507 
 508   void push_FPU_state();
 509   void pop_FPU_state();
 510 
 511   void push_CPU_state();
 512   void pop_CPU_state();
 513 
 514   void get_cont_fastpath(Register java_thread, Register dst);
 515   void set_cont_fastpath(Register java_thread, int32_t imm);
 516   DEBUG_ONLY(void stop_if_in_cont(Register cont_reg, const char* name);)
 517 
 518   // Round up to a power of two
 519   void round_to(Register reg, int modulus);
 520 
 521   // Callee saved registers handling
 522   void push_callee_saved_registers();
 523   void pop_callee_saved_registers();
 524 
 525   // allocation
 526   void eden_allocate(
 527     Register thread,                   // Current thread
 528     Register obj,                      // result: pointer to object after successful allocation
 529     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 530     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 531     Register t1,                       // temp register
 532     Label&   slow_case                 // continuation point if fast allocation fails
 533   );
 534   void tlab_allocate(
 535     Register thread,                   // Current thread
 536     Register obj,                      // result: pointer to object after successful allocation
 537     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise


 874   // for jumps/calls.
 875   void call(AddressLiteral entry);
 876 
 877   // Emit the CompiledIC call idiom
 878   void ic_call(address entry, jint method_index = 0);
 879 
 880   // Jumps
 881 
 882   // NOTE: these jumps tranfer to the effective address of dst NOT
 883   // the address contained by dst. This is because this is more natural
 884   // for jumps/calls.
 885   void jump(AddressLiteral dst);
 886   void jump_cc(Condition cc, AddressLiteral dst);
 887 
 888   // 32bit can do a case table jump in one instruction but we no longer allow the base
 889   // to be installed in the Address class. This jump will tranfers to the address
 890   // contained in the location described by entry (not the address of entry)
 891   void jump(ArrayAddress entry);
 892 
 893   // Floating
 894 
 895   void push_f(XMMRegister r);
 896   void pop_f(XMMRegister r);
 897   void push_d(XMMRegister r);
 898   void pop_d(XMMRegister r);
 899 
 900   void andpd(XMMRegister dst, Address src) { Assembler::andpd(dst, src); }
 901   void andpd(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 902   void andpd(XMMRegister dst, XMMRegister src) { Assembler::andpd(dst, src); }
 903 
 904   void andps(XMMRegister dst, XMMRegister src) { Assembler::andps(dst, src); }
 905   void andps(XMMRegister dst, Address src) { Assembler::andps(dst, src); }
 906   void andps(XMMRegister dst, AddressLiteral src, Register scratch_reg = rscratch1);
 907 
 908   void comiss(XMMRegister dst, XMMRegister src) { Assembler::comiss(dst, src); }
 909   void comiss(XMMRegister dst, Address src) { Assembler::comiss(dst, src); }
 910   void comiss(XMMRegister dst, AddressLiteral src);
 911 
 912   void comisd(XMMRegister dst, XMMRegister src) { Assembler::comisd(dst, src); }
 913   void comisd(XMMRegister dst, Address src) { Assembler::comisd(dst, src); }
 914   void comisd(XMMRegister dst, AddressLiteral src);
 915 
 916   void fadd_s(Address src)        { Assembler::fadd_s(src); }
 917   void fadd_s(AddressLiteral src) { Assembler::fadd_s(as_Address(src)); }
 918 


< prev index next >