Entonces, recientemente me interesé en qué tan bien el compilador ( gcc (GCC) 4.8.3 es el que está en cuestión) está optimizando punteros y punteros.

Inicialmente, creé un entero simple y un puntero de entero y realicé operaciones en él para poder imprimirlo. Como era de esperar, todas las operaciones que estaban codificadas de forma rígida se optimizaron, a través de un puntero desreferenciado o no.

 call __main leaq .LC0(%rip), %rcx movl $1, %edx call printf

E incluso después de crear una función que toma un puntero int, lo desreferencia y lo cambia, aún estaba perfectamente optimizado.

 call __main leaq .LC0(%rip), %rcx movl $-1, %edx call printf

Ahora, cuando traté mi puntero como un vacío e hice cambios convirtiéndolo en char y desreferenciandolo, en realidad todavía se optimizó perfectamente (una llamada mov 'extra' ya que inicialmente lo traté como un valor de 8 bytes, y luego como un 1 valor de byte para la desreferenciación del puntero)

 call __main movl $4, 44(%rsp) movb $2, 44(%rsp) leaq .LC0(%rip), %rcx movl 44(%rsp), %eax leal 1(%rax), %edx call printf

Así que a mi (s) pregunta (s):

1. ¿Qué tan consistente es la optimización del compilador con respecto a la desreferenciación de punteros? ¿Cuáles serían algunos casos en los que optaría por ser conservador?

2. Si todos mis punteros en un proyecto se declararan con la palabra clave restrict, ¿puedo confiar en que estaría tan bien optimizado como si 'no se usaran punteros en absoluto'?

(suponiendo que no haya casos volatile )

Ps¹.: Soy consciente de que el compilador generalmente hace un trabajo bastante bueno, y que un programador que se preocupa por ayudar al compilador en optimizaciones menores es, en general, improductivo (como muchos señalan en las respuestas de stackoverflow a preguntas relacionadas con la optimización). Sin embargo, todavía tengo curiosidad con respecto al asunto.

Ps².: gcc -O3 -S -c main.c fue el comando utilizado para generar el código ensamblador

Código C: (según lo solicitado)

1:

 #include <stdio.h> int main (void) { int a = 4; int *ap = &a; *ap = 0; a += 1; printf("%d\n", a); return 0; }

2:

 #include <stdio.h> void change(int *p) { *p -= 2; } int main (void) { int a = 4; int *ap = &a; *ap = 0; change(ap); a += 1; printf("%d\n", a); return 0; }

3:

 #include <stdio.h> void change(void *p) { *((char*)p) += 2; } int main (void) { int a = 4; void *ap = (void*) &a; *((char*)(ap)) = 0; change(ap); a += 1; printf("%d\n", a); return 0; }