Load from a 64-bit address into other register than rax

by

From the MOV instruction document you can see that you can move a 64-bit immediate to any registers, but loads/stores involving a 64-bit immediate absolute address can only work with Areg

Opcode Instruction Description
A0 MOV AL,moffs8* Move byte at (seg:offset) to AL.
REX.W + A0 MOV AL,moffs8* Move byte at (offset) to AL.
A1 MOV AX,moffs16* Move word at (seg:offset) to AX.
A1 MOV EAX,moffs32* Move doubleword at (seg:offset) to EAX.
REX.W + A1 MOV RAX,moffs64* Move quadword at (offset) to RAX.
A2 MOV moffs8,AL Move AL to (seg:offset).
REX.W + A2 MOV moffs8***,AL Move AL to (offset).
A3 MOV moffs16*,AX Move AX to (seg:offset).
A3 MOV moffs32*,EAX Move EAX to (seg:offset).
REX.W + A3 MOV moffs64*,RAX Move RAX to (offset).

As you can see there’s no ModR/M byte to encode the register number. Since this is less commonly used than moving a 64-bit immediate to a register it won’t be a problem. If really needed it can be done in 2 instructions

MOVABS is the GAS opcode name for the MOV opcode forms MOV Areg, [Offs64] and MOV [Offs64], Areg. In Yasm’s NASM syntax mode, you can get this form by saying MOV AX, [qword xxx]. Yasm’s GAS syntax mode accepts MOVABS (for GAS compatibility). Note this form is only valid with Areg (AL/AX/EAX/RAX) as the source/destination register.

http://cvs.tortall.net/pipermail/yasm-devel/2006-March/000579.html

More Related Contents:

  1. Why do x86-64 instructions on 32-bit registers zero the upper part of the full 64-bit register?
  2. What’s the purpose of the LEA instruction?
  3. What considerations go into predicting latency for operations on modern superscalar processors and how can I calculate them by hand?
  4. Why does the x86-64 / AMD64 System V ABI mandate a 16 byte stack alignment?
  5. Why in x86-64 the virtual address are 4 bits shorter than physical (48 bits vs. 52 long)?
  6. Is a sign or zero extension required when adding a 32bit offset to a pointer for the x86-64 ABI?
  7. Printing floating point numbers from x86-64 seems to require %rbp to be saved
  8. MOVZX missing 32 bit register to 64 bit register
  9. CS:APP example uses idivq with two operands?
  10. Why are signed and unsigned multiplication different instructions on x86(-64)?
  11. What do the E and R prefixes stand for in the names of Intel 32-bit and 64-bit registers?
  12. Why is the address of static variables relative to the Instruction Pointer?
  13. Why is (or isn’t?) SFENCE + LFENCE equivalent to MFENCE?
  14. Distinguishing memory from constant in GNU as .intel_syntax
  15. Why does this MOVSS instruction use RIP-relative addressing? [duplicate]
  16. How to push a 64bit int in NASM?
  17. x64 instruction encoding and the ModRM byte
  18. Assembly registers in 64-bit architecture
  19. Why does the x86-64 GCC function prologue allocate less stack than the local variables?
  20. Bomb lab phase_4
  21. Does each PUSH instruction push a multiple of 8 bytes on x64?
  22. Can I add 64bit constants to 64bit registers?
  23. How to multiply a register by 37 using only 2 consecutive leal instructions in x86?
  24. What does “rep; nop;” mean in x86 assembly? Is it the same as the “pause” instruction?
  25. x86-64 canonical address?
  26. Why does this code execute more slowly after strength-reducing multiplications to loop-carried additions?
  27. What is callq instruction?
  28. Can rip be used with another register with RIP-relative addressing?
  29. Create an arg array for execve on the stack
  30. x86 Assembly pushl/popl don’t work with “Error: suffix or operands invalid”

Leave a Comment