¿Cómo se implementan los argumentos variables en gcc?

Question

int max(int n, ...) 

Estoy usando la convención de llamada cdecl donde la persona que llama limpia la variable después de que regrese el destinatario.

Estoy interesado en saber cómo funcionan las macros va_end, va_start y va_arg?

¿La persona que llama pasa la dirección de la matriz de argumentos como el segundo argumento al máximo?

Answer 1

Si nos fijamos en la forma en que el lenguaje C almacena los parámetros en la pila, la forma en la macros de trabajo debe convertirse en claro: -

Higher memory address Last parameter 
         Penultimate parameter 
         .... 
         Second parameter 
Lower memory address  First parameter 
     StackPointer -> Return address 

(nota, dependiendo del hardware del puntero de pila tal vez uno abajo de línea y el más alto y más bajo se pueden intercambiar)

los argumentos se almacenan siempre como esto , incluso sin el tipo ... parámetro.

El va_start macro simplemente establece un puntero a la primera parámetro de función, e.g.:-

void func (int a, ...) 
{ 
    // va_start 
    char *p = (char *) &a + sizeof a; 
} 

que hace p punto para el segundo parámetro.La macro va_arg hace esto: -

void func (int a, ...) 
{ 
    // va_start 
    char *p = (char *) &a + sizeof a; 

    // va_arg 
    int i1 = *((int *)p); 
    p += sizeof (int); 

    // va_arg 
    int i2 = *((int *)p); 
    p += sizeof (int); 

    // va_arg 
    long i2 = *((long *)p); 
    p += sizeof (long); 
} 

la va_end macro simplemente establece el valor p-NULL.

NOTAS:

1. compiladores de optimización y algunas almacenar parámetros CPU RISC de registros en lugar de utilizar la pila. La presencia del parámetro ... desactivaría esta capacidad y el compilador utilizaría la pila.

Answer 2

Como los argumentos se pasan en la pila, va_ "funciones" (la mayoría de las veces se implementan como macros) simplemente manipulan un puntero de pila privada. Este puntero de pila privada se almacena desde el argumento pasado a va_start, y luego va_arg "muestra" los argumentos de la "pila" mientras itera los parámetros.

digamos que se llama a la función max con tres parámetros, así:

max(a, b, c); 

Dentro de la función max, la pila básicamente tiene el siguiente aspecto:

 
     +-----+ 
     | c | 
     | b | 
     | a | 
     | ret | 
SP -> +-----+ 

SP es el puntero de pila real, , y no es realmente a, b y c que en la pila pero sus valores. ret es la dirección de retorno, a donde ir cuando se realiza la función.

Lo va_start(ap, n) hace es tomar la dirección del argumento (n en su prototipo de función) y desde que calcula la posición del siguiente argumento, por lo que obtener un nuevo puntero de pila privada:

 
     +-----+ 
     | c | 
ap -> | b | 
     | a | 
     | ret | 
SP -> +-----+ 

Cuando use va_arg(ap, int) devuelve aquello a lo que apunta el puntero de la pila privada, y luego lo "salta" cambiando el puntero de la pila privada para apuntar ahora al siguiente argumento. La pila ahora se ve así:

 
     +-----+ 
ap -> | c | 
     | b | 
     | a | 
     | ret | 
SP -> +-----+ 

Esta descripción es, por supuesto, simplificada, pero muestra el principio.

Answer 3

int max(int n, const char *msg,...) 
{ 
va_list args; 
char buffer[1024]; 
va_start(args, msg); 
nb_char_written = vsnprintf(buffer, 1024, msg, args); 
va_end(args); 
printf("(%d):%s\n",n,buffer); 
}