1

I am trying to learn x64 assembler. I wrote "hello world" and tried to call printf using the following code:

EXTERN printf: PROC

PUBLIC hello_world_asm

.data
hello_msg db "Hello world", 0


.code
hello_world_asm PROC
push rbp ; save frame pointer
mov rbp, rsp ; fix stack pointer
sub rsp, 8 * (4 + 2) ; shadow space (32bytes)

lea rax, offset hello_msg
mov rcx, rax ; <---- QUESTION ABOUT THIS LINE
call printf

; epilog. restore stack pointer
mov rsp, rbp
pop rbp
ret
hello_world_asm ENDP


END

At the beginning I called printf without "mov rcx, rax", which ended up with access violation. Getting all frustrated I just wrote in C++ a call to printf and looked in the disassembler. There I saw the line "mov rcx, rax" which fixed everything, but WHY do I need to move RAX to RCX ??? Clearly I am missing something fundamental.

Thanks for your help!

p.s. a reference to good x64 assembler tutorial is more than welcome :-) couldn't find one.

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
TCS
  • 5,790
  • 5
  • 54
  • 86
  • `rax` is volatile. `printf` uses `rcx` to load the string so in my understanding, it's just the calling convention you got wrong. Pretty good explanation [here](http://masm32.com/board/index.php?topic=3101.0) – Lieven Keersmaekers Aug 29 '17 at 06:58
  • 1
    Because the first parameter to x64 printf goes in rcx, not rax. – David Wohlferd Aug 29 '17 at 07:01
  • See the [x86 tag wiki](https://stackoverflow.com/tags/x86/info) for links to docs and tutorials. Since you're using Windows, https://software.intel.com/en-us/articles/introduction-to-x64-assembly is probably a good one. – Peter Cordes Aug 29 '17 at 07:45
  • Not related to the question, but seems to me you could have loaded `offset hello_msg` into _RCX_ with `lea` rather than using _RAX_ as an intermediate step. – Michael Petch Aug 29 '17 at 13:51

2 Answers2

4

It isn't required, this code just wastes an instruction by doing an lea into RAX and then copying to RCX, when it could do

lea   rcx, hello_msg
call  printf              ; printf(rcx, rdx, r8, r9, stack...)

printf on 64-bit Windows ignores RAX as an input; RAX is the return-value register in the Windows x64 calling convention (and can also be clobbered by void functions). The first 4 args go in RCX, RDX, R8, and R9 (if they're integer/pointer like here).

Also note that FP args in xmm0..3 have to be mirrored to the corresponding integer register for variadic functions like printf (MS's docs), but for integer args it's not required to movq xmm0, rcx.

In the x86-64 System V calling convention, variadic functions want al = the number of FP args passed in registers. (So you'd xor eax,eax to zero it). But the x64 Windows convention doesn't need that; it's optimized to make variadic functions easy to implement (instead of for higher performance / more register args for normal functions).

A few 32-bit calling conventions pass an arg in EAX, for example Irvine32, or gcc -m32 -mregparm=1. But no standard x86-64 calling conventions do. You can do whatever you like with private asm functions you write, but you have to follow the standard calling conventions when calling library functions.

Also note that lea rax, offset hello_msg was weird; LEA uses memory-operand syntax and machine encoding (and gives you the address instead of the data). offset hello_msg is an immediate, not a memory operand. But MASM accepts it as a memory operand anyway in this context.

You could use mov ecx, offset hello_msg in position-dependent code, otherwise you want a RIP-relative LEA. I'm not sure of the MASM syntax for that.

Peter Cordes
  • 328,167
  • 45
  • 605
  • 847
  • 1
    `lea rax, offset hello_msg` would have assembled on every version of MASM and TASM I've ever used and that goes back to the 80s (of course with 16-bit addresses). MASM's use of brackets is optional so it would be the same as `lea rax, [offset hello_msg]` and the offset is effectively discarded, so is equivalent to `lea rax, [hello_msg]` – Michael Petch Apr 18 '18 at 05:02
2

The Windows 64-bit (x64/AMD64) calling convention passes the first four integer arguments in RCX, RDX, R8 and R9.

The return value is stored in RAX and it is volatile so a C/C++ compiler is allowed to use it as generic storage in a function.

Anders
  • 97,548
  • 12
  • 110
  • 164