Why does the x86-64 System V calling convention pass args in registers instead of just the stack?

by

instead of put the first 6 arguments in registers just to move them onto the stack in the function prologue?

I was looking at some code that gcc generated and that’s what it always did.

Then you forgot to enable optimization. gcc -O0 spills everything to memory so you can modify them with a debugger while single-stepping. That’s obviously horrible for performance, so compilers don’t do that unless you force them to by compiling with -O0.

x86-64 System V allows int add(int x, int y) { return x+y; } to compile to
lea eax, [rdi + rsi] / ret, which is what compilers actually do as you can see on the Godbolt compiler explorer.

Stack-args calling conventions are slow and obsolete. RISC machines have been using register-args calling conventions since before x86-64 existed, and on OSes that still care about 32-bit x86 (i.e. Windows), there are better calling conventions like __vectorcall that pass the first 2 integer args in registers.

i386 System V hasn’t been replaced because people mostly don’t care as much about 32-bit performance on other OSes; we just use 64-bit code with the nicely-designed x86-64 System V calling convention.

For more about the tradeoff between register args and call-preserved vs. call-clobbered registers in calling convention design, see Why not store function parameters in XMM vector registers?, and also Why does Windows64 use a different calling convention from all other OSes on x86-64?.

More Related Contents:

  1. The advantages of using 32bit registers/instructions in x86-64
  2. How to load address of function or label into register
  3. Why is %eax zeroed before a call to printf?
  4. Calling printf in extended inline ASM
  5. Understanding GCC’s floating point constants in assembly listing output
  6. Why did GCC generate mov %eax,%eax and what does it mean?
  7. clang (LLVM) inline assembly – multiple constraints with useless spills / reloads
  8. x86_64: Is it possible to “in-line substitute” PLT/GOT references?
  9. Why doesn’t GCC optimize a*a*a*a*a*a to (a*a*a)*(a*a*a)?
  10. Why does GCC use multiplication by a strange number in implementing integer division?
  11. Why doesn’t GCC use partial registers?
  12. Where is the x86-64 System V ABI documented?
  13. Why does Windows64 use a different calling convention from all other OSes on x86-64?
  14. What registers are preserved through a linux x86-64 function call
  15. Why doesn’t gcc resolve _mm256_loadu_pd as single vmovupd?
  16. Why does GCC allocate more space than necessary on the stack, beyond what’s needed for alignment?
  17. Where exactly is the red zone on x86-64?
  18. Calling printf in x86_64 using GNU assembler
  19. Prefetching Examples?
  20. Why not store function parameters in XMM vector registers?
  21. How can I multiply 64 bit operands and get 128 bit result portably?
  22. Why is RCX not used for passing parameters to system calls, being replaced with R10? [duplicate]
  23. How to set gcc or clang to use Intel syntax permanently for inline asm() statements?
  24. Why does gcc use movl instead of push to pass function args?
  25. How does the GCC implementation of modulo (%) work, and why does it not use the div instruction?
  26. How to use AVX/pclmulqdq on Mac OS X
  27. Is reserving stack space necessary for functions less than four arguments?
  28. How to convert Linux 32-bit gcc inline assembly to 64-bit code? [closed]
  29. Is the hash required for immediate values in ARM assembly?
  30. what is the order of source operands in AT&T syntax compared to Intel syntax?

Leave a Comment