gcc (x64) 如何处理可变函数中的类型/大小？

Question

A variadic function and main()

#include <stdio.h>
#include <stdarg.h>
int f(long x,...)
{ va_list ap;
  int i=0;
  va_start(ap,x);
  while(x)
  { i++;
    printf("%ld ", x);
    x=va_arg(ap,long);
  }
  va_end(ap);
  printf("\n");
  return i;
}

int main()
{ return f(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,1L<<63,0);
}

On gcc, linux and x64: even though f()'s arguments are not cast to a 64bit long, gcc seems to get it right.

$ gcc t.c && ./a.out
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 -9223372036854775808 

How?

Answer 1

在Linux x64上，可变参数的参数被“提升”为64位值，因此无需在此平台上显式转换为64位值。

Answer 2

Three things are happening here:

1. Default argument promotion

The C standard defines something called “ default argument promotion ” for variadic arguments. That means :

• If the actual argument is of type float , it is promoted to type double prior to the function call.
• Any signed char or unsigned char , signed short or unsigned short , enumerated type, or bit field is converted to either a signed int or an unsigned int using integral promotion.

But beware: This is int , which is 32bit on x64 linux. There is more happening:

2. The System V x64 calling convention

The SysV AMD64 ABI defines how the arguments are then passed to the function in section 3.2.3. What matters here is: The first 6 integers are passed in registers, the remaining ones are pushed to the stack. Also: “The size of each argument gets rounded up to eightbytes. [...] Therefore the stack will always be eightbyte aligned”. Note that floats are passed in the floating point registers, not the normal ones.

3. The va_... macros

Functions that contain va_start get a special prologue that also pushes all the argument registers to the stack. How this is done is not part of the calling convention. Since the compiler doesn't know the actual argument sizes at this point, you can expect it to push the whole registers making these values also 64bit aligned. va_arg then first iterates through these, then the rest of the arguments which were passed on the stack.

What this means for your code example

All of this means that all the arguments are 64bit aligned. But they are not actually 64bit wide. All integers are at least 32bit wide ( _Bool / bool is 8bit wide), but nothing more. The value of the unused bits is unspecified. The caller is free to leave these bits uninitialized. Thus:

• The code is broken for negative values ( godbold )
• The spec doesn't guarantee that garbage data won't just pop up in the higher bits at some point in the future. But this seems rather unlikely since a lot of code probably depends on this behavior (see comments).

Answer 3

The essential bit of code which makes it work is

x = va_arg(ap, long);

You could shoot yourself in the foot quite well by changing it to any other type.

char ch = va_arg(ap, char);

Depending on the rules of the target architecture, this might increment ap by one, two, four, or eight after each access.