¿Dónde se almacenan las constantes de cadena almacenadas por GCC y desde dónde se asignan estos punteros?

Question

Cuando compilar y ejecutar siguiente programa C en mi máquina Linux x86_64, compilado por GCC:

#include <stdio.h> 

int main(void) 
{ 
    char *p1 = "hello";    // Pointers to strings 
    char *p2 = "hello";    // Pointers to strings 
    if (p1 == p2) {     // They are equal 
    printf("equal %p %p\n", p1, p2); // equal 0x40064c 0x40064c 
             // This is always the output on my machine 
    } 
    else { 
    printf("NotEqual %p %p\n", p1, p2); 
    } 
} 

siempre me dan el resultado como:

igual 0x40064c 0x40064c

I comprende que las cadenas se almacenan en una tabla constante, pero la dirección es demasiado baja en comparación con la memoria asignada dinámicamente.

Comparar con siguiente programa:

#include <stdio.h> 

int main(void) 
{ 
    char p1[] = "hello";    // char arrar 
    char p2[] = "hello";    // char array 
    if (p1 == p2) { 
    printf("equal %p %p\n", p1, p2); 
    } 
    else {        // Never equal 
    printf("NotEqual %p %p\n", p1, p2); // NotEqual 0x7fff4b25f720 0x7fff4b25f710 
             // Different pointers every time 
             // Pointer values too large 
    } 
} 

Los dos punteros no son iguales, ya que estos son dos matrices que pueden ser manipulados de forma independiente.

Quiero saber cómo GCC genera el código para estos dos programas y cómo se asignan a la memoria durante la ejecución. Como esto ya estaría documentado, muchas veces los enlaces a la documentación también son bienvenidos.

Answer 1

En ambos casos, el compilador emite los bytes de la cadena "hello" sólo una vez, en la sección .rodata del programa (Rodata siglas de de sólo lectura de datos).

En realidad, se asignan directamente desde el archivo ejecutable a la memoria, algo similar a la sección del código. Es por eso que están muy lejos de los asignados dinámicamente.

continuación:

char *p = "hello"; 

simplemente inicializa p a la dirección de este (sólo lectura) de datos. Y, obviamente, :

char *q = "hello"; 

Obtiene la misma dirección. Esto se llama string pooling y es una optimización popular opcional del compilador.

Pero cuando escribe:

char p[] = "hello"; 

Probablemente generará algo como esto:

char p[6]; 
memcpy(p, "hello", 6); 

Siendo el "hello" realidad la dirección de la cadena de sólo lectura agrupada.

La llamada a memcpy es solo para fines ilustrativos. Puede muy bien copiar en línea, en lugar de hacerlo con una llamada a función.

Si más tarde que hace:

char q[] = "hello"; 

Se definirá otra matriz y otro memcpy(). Entonces los mismos datos, pero diferentes direcciones.

¿Pero dónde residirán estas variables de matriz? Bueno eso depende.

• Si son variables locales, no estáticas, en la pila.
• Si son variables globales: entonces estarán en la sección .data del ejecutable, y se guardarán allí con los caracteres correctos, por lo que no es necesario memcpy en tiempo de ejecución. Lo cual es bueno, porque ese memcpy tendría que ejecutarse antes del main.
• Si son variables estáticas locales: exactamente lo mismo que con las variables globales. Los dos juntos se llaman variables of static duration o algo así.

Acerca de los enlaces de documentación, lo siento, no conozco ninguno.

¿Pero quién necesita documentación si puede hacer los experimentos usted mismo? Para eso, la mejor herramienta disponible es objdump, ¡puede desensamblar el programa, volcar las secciones de datos y mucho más!

Espero que esto responda a sus preguntas ...