Cross Reference: /openjdk7/hotspot/src/cpu/x86/vm/nativeInst

Lines Matching refs:address
72   address addr_at(int offset) const    { return address(this) + offset; }
98   inline friend NativeInstruction* nativeInstruction_at(address address);
101 inline NativeInstruction* nativeInstruction_at(address address) {
102   NativeInstruction* inst = (NativeInstruction*)address;
109 inline NativeCall* nativeCall_at(address address);
125   address instruction_address() const       { return addr_at(instruction_offset); }
126   address next_instruction_address() const  { return addr_at(return_address_offset); }
128   address displacement_address() const      { return addr_at(displacement_offset); }
129   address return_address() const            { return addr_at(return_address_offset); }
130   address destination() const;
131   void  set_destination(address dest)       {
139   void  set_destination_mt_safe(address dest);
146   inline friend NativeCall* nativeCall_at(address address);
147   inline friend NativeCall* nativeCall_before(address return_address);
149   static bool is_call_at(address instr) {
153   static bool is_call_before(address return_address) {
157   static bool is_call_to(address instr, address target) {
163   static void insert(address code_pos, address entry);
165   static void replace_mt_safe(address instr_addr, address code_buffer);
168 inline NativeCall* nativeCall_at(address address) {
169   NativeCall* call = (NativeCall*)(address - NativeCall::instruction_offset);
176 inline NativeCall* nativeCall_before(address return_address) {
204   address instruction_address() const       { return addr_at(instruction_offset); }
205   address next_instruction_address() const  { return addr_at(next_instruction_offset); }
216   inline friend NativeMovConstReg* nativeMovConstReg_at(address address);
217   inline friend NativeMovConstReg* nativeMovConstReg_before(address address);
220 inline NativeMovConstReg* nativeMovConstReg_at(address address) {
221   NativeMovConstReg* test = (NativeMovConstReg*)(address - NativeMovConstReg::instruction_offset);
228 inline NativeMovConstReg* nativeMovConstReg_before(address address) {
229   NativeMovConstReg* test = (NativeMovConstReg*)(address - NativeMovConstReg::instruction_size - NativeMovConstReg::instruction_offset);
238     friend NativeMovConstRegPatching* nativeMovConstRegPatching_at(address address) {
239     NativeMovConstRegPatching* test = (NativeMovConstRegPatching*)(address - instruction_offset);
302   address instruction_address() const;
304   address next_instruction_address() const;
319   inline friend NativeMovRegMem* nativeMovRegMem_at (address address);
322 inline NativeMovRegMem* nativeMovRegMem_at (address address) {
323   NativeMovRegMem* test = (NativeMovRegMem*)(address - NativeMovRegMem::instruction_offset);
332   friend NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address) {
333     NativeMovRegMemPatching* test = (NativeMovRegMemPatching*)(address - instruction_offset);
369   friend NativeLoadAddress* nativeLoadAddress_at (address address) {
370     NativeLoadAddress* test = (NativeLoadAddress*)(address - instruction_offset);
390   address instruction_address() const       { return addr_at(instruction_offset); }
391   address next_instruction_address() const  { return addr_at(next_instruction_offset); }
392   address jump_destination() const          {
393      address dest = (int_at(data_offset)+next_instruction_address());
396      // Now 32bit and 64bit use jump to self as the unresolved address
400     dest = (dest == (address) this) ? (address) -1 : dest;
404   void  set_jump_destination(address dest)  {
406     if (dest == (address) -1) {
410     assert((labs(val)  & 0xFFFFFFFF00000000) == 0 || dest == (address)-1, "must be 32bit offset or -1");
416   inline friend NativeJump* nativeJump_at(address address);
424   static void insert(address code_pos, address entry);
426   static void check_verified_entry_alignment(address entry, address verified_entry);
427   static void patch_verified_entry(address entry, address verified_entry, address dest);
430 inline NativeJump* nativeJump_at(address address) {
431   NativeJump* jump = (NativeJump*)(address - NativeJump::instruction_offset);
452   address instruction_address() const       { return addr_at(0); }
453   address jump_destination()    const;
456   inline friend NativeGeneralJump* nativeGeneralJump_at(address address);
459   static void insert_unconditional(address code_pos, address entry);
460   static void replace_mt_safe(address instr_addr, address code_buffer);
465 inline NativeGeneralJump* nativeGeneralJump_at(address address) {
466   NativeGeneralJump* jump = (NativeGeneralJump*)(address);
482   static void insert(address code_pos, Register reg);
495   // Insert illegal opcode as specific address
496   static void insert(address code_pos);
544     // two cases, depending on the choice of the base register in the address.
557       address fault = addr_at(6) + int_at(2);
567            (os::is_poll_address((address)int_at(2)));