Arreglo constante C invisible sin duplicación de memoria

Question

Quiero declarar un arreglo constante al que se puede acceder desde múltiples archivos C y cuyo contenido puede ser insertado por el compilador, sin duplicar la memoria en varias unidades de compilación. El rendimiento es crítico en mi aplicación.

Anexo 1:

header.h: 
static const int arr[2] = { 1, 2 }; 

file1.c: 
#include "header.h" 
void file1() { printf("%d\n", arr[0]); } 

file2.c: 
#include "header.h" 
int file2() { for (int i = 0; i < 2; i++) printf("%d\n", arr[i]); } 

En ese caso, el compilador puede reemplazar por arr[0]1 en archivo1. Sin embargo, dado que arr está declarado static const, su memoria está duplicada en ambos archivos C. AFAIK el estándar C requiere que las direcciones de matriz sean diferentes en ambos archivos. Lo he verificado en Linux imprimiendo las direcciones. No se produce consolidación de vinculador incluso con -fmerge-all-constants en gcc.

Anexo 2:

header.h: 
extern const int arr[2]; 

file1.c: 
#include "header.h" 
void file1() { printf("%d\n", arr[0]); } 

file2.c: 
#include "header.h" 
const int arr[2] = { 1, 2 }; 
int file2() { for (int i = 0; i < 2; i++) printf("%d\n", arr[i]); } 

En ese caso, no se produce la duplicación de memoria, pero no arr[0] se colocarán en línea.

Considero que el alcance de visibilidad definido por el estándar C es defectuoso. Como tal, una solución de trabajo bajo Linux/gcc que viola el estándar C es aceptable para mí.

Answer 1

Una cosa que usted puede intentar:

const int arr[2] __attribute__((weak)) = { 1, 2 }; 

Ahora la matriz todavía existe en todos los * .o objeto, pero cuando esos objetos están unidos entre sí en un programa, GNU ld los reducirá a un solo trozo común de datos.

Si aún no dispone de una cosa así, es posible que desee en algún archivo cabecera común:

#ifndef __GNUC__ 
#define __attribute__(x) 
#endif 

Answer 2

Desafortunadamente, no hay una forma estándar de lograr eso en C "clásica" (refiriéndose a C89/90). En C89/90, usted está limitado a los dos enfoques que describió, con sus pros y sus contras respectivos, siempre y cuando insista en usar una matriz.

En C99 las cosas son mejores. En el C99 se puede utilizar los llamados literales compuestos, es decir, simplemente definen arr como una macro en el archivo de cabecera

#define arr ((const int []) { 1, 2 }) 

y luego esperar que el compilador "en línea" de la matriz. Los literales compuestos de los tipos const se tratan de la misma manera que los literales de cadena: el compilador puede fusionar distintas apariciones de literal idéntico en el programa en una instancia del objeto real (si el compilador no lo alinea).

AFAIK, el compilador GCC admite literales compuestos como una extensión incluso en modos que no son C99.

Answer 3

Uso del selectanyvariable attribute y dar a sus matrices de vinculación externa (es decir, no los declaran static) . Esto mantendrá el valor de la matriz en el encabezado para que se pueda insertar correctamente, y el atributo selectany le dirá al enlazador que elija arbitrariamente una de las definiciones para que sea la real y descarte las demás (ya que todas son iguales , no importará).

Por ejemplo:

const int arr[] __attribute__((selectany)) = {1, 2}; 

---

EDITAR: Al parecer, esto sólo funciona en objetivos Windows; el atributo weak no funcionó, en cambio, en una prueba rápida que hice con Cygwin's GCC, ya que produjo varias copias de la matriz en el segmento de datos resultante.

Answer 4

Creo que su análisis es algo erróneo. Cuando imprime la dirección de arr, fuerza el compilador para mantener dos copias. GCC eliminará ambas copias si no haces esto.

Una forma mejor de determinar qué tiene el enlazador, y qué no, eliminar es mirar los objetos reales en el archivo de salida. En Linux, el programa nm le dirá esto.

Si puedo compilar el código (Anexo 1) con 'gcc (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1':

gcc -std=c99 -g3 -O6 -fmerge-all-constants file1.c file2.c main.c 

Luego utilizo nm -a a.out | grep '\<arr\>' a buscar en la tabla de símbolos :

$ nm -a a.out|grep '\<arr\>'|wc -l 
0 

de hecho, si se intenta encontrar en gdb, no se encuentra nada:

(gdb) b file1 
Breakpoint 1 at 0x400540: file /usr/include/x86_64-linux-gnu/bits/stdio2.h, line 105. 
(gdb) r 
Starting program: a.out 
Breakpoint 1, file1() at file1.c:5 
5 void file1() { printf("%d\n", arr[0]); } 
(gdb) print arr 
$1 = <optimized out> 

El compilador lo ha optimizado completamente.

Si añado printf("%p\n",arr); al principio de file1() y file2() y compilar la misma manera, a continuación, vuelve nm -a a.out|grep '\<arr\>' dos referencias a arr:

$ nm -a a.out|grep '\<arr\>'|wc -l 
2 
$ nm -a a.out|grep '\<arr\>' 
00000000004006c8 r arr 
00000000004006d0 r arr