Comportamiento indefinido en C: -O0 vs -O2 y UBSan
Curso de C 5: overflow con signo, un bucle de 22 vueltas que -O2 borra, strict aliasing, variables sin inicializar y un chequeo de NULL eliminado.
Serie: curso de C 5/6 (avanzado). Esta clase es para ti si ya escribes y depuras C, y alguna vez viste un programa comportarse distinto entre el build de debug y el de release: en la librería nativa de una startup, en el firmware de un cliente como freelancer o en la práctica de sistemas operativos de la universidad. Al terminar vas a reconocer las formas comunes de comportamiento indefinido, explicar qué hizo el optimizador con ellas, encontrarlas con UBSan y elegir una solución que sea C bien definido, no un flag que esconde el síntoma.
"En mi computadora pasa todos los tests, pero el build de release da otro número" es uno de los reportes de bug más caros en C. La causa muchas veces no es un bug del compilador sino comportamiento indefinido (undefined behavior, UB): código sobre el que el estándar de C no impone ningún requisito. Esta clase ejecuta cinco ejemplos pequeños de UB con -O0 y -O2, muestra el código máquina que produjo el optimizador y lo que reporta el sanitizer.
Entorno: Apple clang 21.0.0 (clang -std=c17 -Wall -Wextra), Mac con Apple Silicon (M1 Pro), macOS, arm64. Cada salida se copió de una ejecución real. El desensamblado se obtuvo con objdump -d --no-show-raw-insn. Volver a la hoja de ruta para aprender a programar.
Qué significa "indefinido" y por qué le importa al optimizador
El estándar de C clasifica el comportamiento no portable en tres categorías:
- Definido por la implementación: el compilador tiene que elegir un comportamiento y documentarlo. Ejemplo:
sizeof(long), o qué hace un desplazamiento a la derecha de un número negativo. - No especificado: ocurre uno entre varios comportamientos, y el compilador no tiene que decirte cuál. Ejemplo: el orden en que
f() + g()llama a las dos funciones. - Indefinido: el estándar no impone ningún requisito sobre toda la ejecución del programa. Ejemplos: overflow de enteros con signo, leer una variable local sin inicializar, acceder a un arreglo fuera de rango, desreferenciar un puntero NULL, acceder a un objeto a través de un puntero de un tipo incompatible.
La última categoría es la que muerde, y no porque el hardware haga algo raro. En arm64, sumar 1 a 2147483647 en un registro da -2147483648, siempre. La sorpresa viene del optimizador: tiene permitido suponer que el UB nunca ocurre y razonar hacia adelante a partir de esa suposición. "Esta suma no puede desbordarse" se convierte en "entonces x + 1 > x siempre es verdadero", que se convierte en "entonces retorna 1". Cada paso es legal; el resultado parece que el compilador ignoró tu código.
Tres funciones, dos respuestas
Un archivo, tres funciones diminutas. noinline mantiene cada una como una llamada real para que podamos leer su código máquina.
/* ub.c: three kinds of undefined behavior that change with -O level.
clang -std=c17 -Wall -Wextra -O0 ub.c -o ub0 && clang -std=c17 -Wall -Wextra -O2 ub.c -o ub2 */
#include <stdio.h>
#include <limits.h>
/* 1. signed overflow: "is x+1 bigger than x?" */
__attribute__((noinline)) int plus_one_is_bigger(int x) { return x + 1 > x; }
/* 2. strict aliasing: writes through an int* and a float* */
__attribute__((noinline)) int alias(int *i, float *f) {
*i = 1;
*f = 0.0f; /* if f points at the same bytes, *i is now 0 */
return *i;
}
/* 3. a loop whose counter overflows */
__attribute__((noinline)) int count_steps(int start) {
int steps = 0;
for (int i = start; i > 0; i += 100000000) steps++; /* "until it wraps negative" */
return steps;
}
int main(void) {
printf("plus_one_is_bigger(INT_MAX) = %d\n", plus_one_is_bigger(INT_MAX));
int x = 0;
printf("alias(&x, (float*)&x) = %d\n", alias(&x, (float *)&x));
printf("count_steps(1) = %d\n", count_steps(1));
return 0;
}
Compila sin ningún warning en ambos niveles. La salida:
-- O0
plus_one_is_bigger(INT_MAX) = 0
alias(&x, (float*)&x) = 0
count_steps(1) = 22
-- O2
plus_one_is_bigger(INT_MAX) = 1
alias(&x, (float*)&x) = 1
count_steps(1) = 0
Cambiaron todas las líneas. Esto es lo que contiene el binario de -O2 (los comentarios son nuestros):
<_plus_one_is_bigger>:
mov w0, #0x1 ; return 1
ret
<_alias>:
mov w8, #0x1
str w8, [x0] ; *i = 1
str wzr, [x1] ; *f = 0
mov w0, #0x1 ; return 1, without reading *i again
ret
<_count_steps>:
mov w0, #0x0 ; return 0: the loop is gone
ret
1. Overflow con signo. En -O0 la CPU sumó y dio la vuelta; -2147483648 > 2147483647 fue falso, resultado 0. En -O2 clang razonó que x + 1 no puede desbordarse, así que siempre es mayor que x, y reemplazó la función por return 1. Con -fwrapv (que define el overflow con signo como vuelta) el build de -O2 volvió a imprimir 0.
2. Strict aliasing. C dice que a un objeto int no se le puede acceder a través de un lvalue float (C17 6.5p7). Por eso clang supone que *f = 0.0f no puede cambiar *i y devuelve el 1 que acaba de guardar. Con -fno-strict-aliasing, el build de -O2 imprimió 0. El kernel de Linux y algunas bases de código grandes en C compilan con ese flag justamente por esta razón.
3. El bucle que desapareció. La única salida de for (int i = 1; i > 0; i += 100000000) es el overflow. En -O0 dio la vuelta después de 22 pasos. En -O2, sin overflow el bucle nunca podría terminar; pero un bucle sin efectos secundarios como este se puede suponer que termina (C11 6.8.5p6); las dos suposiciones juntas no dejan nada que ejecutar, y clang emitió return 0. Ni 22 ni un bucle infinito: 0. -fwrapv trajo de vuelta el 22.
Variables sin inicializar: el número cambia en cada ejecución
#include <stdio.h>
__attribute__((noinline)) int grade(int score) {
int bonus; /* forgot "= 0" */
if (score >= 90) bonus = 10;
return score + bonus;
}
__attribute__((noinline)) void scribble(void) { /* leaves junk on the stack */
volatile int junk[16];
for (int i = 0; i < 16; i++) junk[i] = 7777;
}
int main(void) {
printf("grade(95) = %d\n", grade(95));
scribble();
printf("grade(50) = %d\n", grade(50));
return 0;
}
Esta vez clang sí avisa, y la nota incluso muestra la solución:
uninit.c:5:9: warning: variable 'bonus' is used uninitialized whenever 'if' condition is false [-Wsometimes-uninitialized]
5 | if (score >= 90) bonus = 10;
| ^~~~~~~~~~~
uninit.c:6:20: note: uninitialized use occurs here
uninit.c:4:14: note: initialize the variable 'bonus' to silence this warning
4 | int bonus; /* forgot "= 0" */
| ^
| = 0
Lo que realmente pasa si lo ignoras:
-- O0, three runs
grade(50) = 76989834
grade(50) = 47941002
grade(50) = 43156874
-- O2
grade(95) = 105
grade(50) = 60
En -O0, bonus vale lo que haya quedado en esa posición del stack, y con la aleatorización del espacio de direcciones (ASLR) fue un número distinto en cada ejecución. En -O2 la respuesta es estable, y equivocada de una forma nueva: el código máquina es add w0, w0, #0xa. Como leer bonus sin inicializar sería UB, el compilador supuso que la rama del if siempre se ejecuta y suma 10 sin condición. Un estudiante con 50 puntos recibe 60, siempre, y eso parece un bug de lógica y no un bug de memoria.
-ftrivial-auto-var-init=zero (aceptado por clang 21) llena de ceros esas variables locales e imprimió grade(50) = 50. Es un flag de endurecimiento útil para builds de release, pero convierte un bug visible en una suposición silenciosa; la solución real es int bonus = 0;. Haz que el compilador insista con -Werror=sometimes-uninitialized (o -Werror para todo):
uninit.c:5:9: error: variable 'bonus' is used uninitialized whenever 'if' condition is false [-Werror,-Wsometimes-uninitialized]
El chequeo de NULL que el compilador borró
Error típico: primero desreferenciar, después revisar.
struct cfg { int retries; };
__attribute__((noinline)) int get_retries(struct cfg *c) {
int r = c->retries; /* dereference first ... */
if (c == NULL) return -1; /* ... check later: the compiler may delete this */
return r;
}
Lo que realmente pasa con -O2:
<_get_retries>:
ldr w0, [x0]
ret
La revisión desapareció. Como c->retries ya desreferenció c, el compilador concluye que c no puede ser NULL, así que c == NULL es falso y la rama es código muerto. En -O0 la comparación sigue ahí. Si esta función llega a recibir NULL, el build de -O2 truena en la lectura, y la revisión "defensiva" que ves en el código fuente nunca se ejecutó. Solución: revisa antes del primer uso. Este patrón exacto causó una conocida vulnerabilidad del kernel de Linux en 2009 (hoy el kernel compila con -fno-delete-null-pointer-checks; no lo ejecutamos aquí).
UBSan: hacer que el UB haga ruido
-fsanitize=undefined (UndefinedBehaviorSanitizer) inserta una revisión antes de cada operación que puede ser UB e imprime una línea cuando una salta. Con ub.c en -O0:
ub.c:7:68: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior ub.c:7:68
ub.c:19:34: runtime error: signed integer overflow: 2100000001 + 100000000 cannot be represented in type 'int'
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior ub.c:19:34
plus_one_is_bigger(INT_MAX) = 0
alias(&x, (float*)&x) = 0
count_steps(1) = 22
exit=0
Dos cosas para notar. Encontró ambos overflows, con los valores exactos, pero no la violación de aliasing: UBSan no tiene un chequeo para eso. Y reportó y siguió (salida 0). En CI quieres que el build falle, así que agrega -fno-sanitize-recover=undefined; con eso el mismo archivo se detuvo en el primer reporte con código de salida 134.
Tres chequeos más de un segundo archivo, ejecutado sin argumentos:
int n = argc > 1 ? atoi(argv[1]) : 32;
int table[4] = {10, 20, 30, 40};
int idx = argc > 2 ? atoi(argv[2]) : 4;
printf("1 << %d = %d\n", n, 1 << n); /* shift >= width */
printf("table[%d] = %d\n", idx, table[idx]); /* off by one */
int d = argc - 1; /* 0 when run with no args */
printf("100 / %d = %d\n", d, 100 / d);
more_ub.c:8:35: runtime error: shift exponent 32 is too large for 32-bit type 'int'
more_ub.c:9:37: runtime error: index 4 out of bounds for type 'int[4]'
more_ub.c:11:38: runtime error: division by zero
1 << 32 = 1
table[4] = -16
100 / 0 = 0
Mira la última línea. Sin el sanitizer, tanto en -O0 como en -O2, esta Mac también imprimió 100 / 0 = 0 y terminó normalmente: la instrucción de división de arm64 devuelve 0 cuando el divisor es cero en vez de lanzar una excepción. En x86-64 la misma lógica lanza SIGFPE ("Floating point exception", aunque sea una división entera; no lo ejecutamos aquí). Un programa "probado" solo en una Mac con Apple Silicon puede, por lo tanto, tronar en el primer servidor Linux que encuentre. table[4] imprimió -16, -178814720 y 1010573361 en tres builds distintos.
Medido: lo que cuestan los niveles -O y los sanitizers
El mismo bucle de 20 millones de elementos (un histograma más una suma ponderada, datos de un generador xorshift con semilla fija) con distintos flags. El mejor de 7 repeticiones, Mac con Apple Silicon (M1 Pro); una segunda ronda completa dio los mismos números con menos de 5% de diferencia. El checksum fue idéntico en todos los builds, así que ninguno se saltó trabajo.
| Build | Tiempo (ms) | vs -O2 |
|---|---|---|
-O0 |
30.22 | 3.1x |
-O1 |
9.77 | 1.0x |
-O2 |
9.63 | 1.0x |
-O3 |
6.97 | 0.72x |
-O2 -fwrapv |
10.03 | 1.04x |
-O2 -fsanitize=undefined |
25.22 | 2.6x |
-O2 -fsanitize=address |
17.25 | 1.8x |
-O0 -fsanitize=address,undefined |
241.33 | 25x |
Tres lecturas. -fwrapv casi no costó nada en este bucle, así que la frase "no podemos definir el overflow porque es lento" merece una medición en tu propio código crítico antes de creerla (puede importar en algunos bucles, por ejemplo por el ensanchamiento de índices; no se muestra aquí). Los sanitizers en -O2 son lo bastante baratos para correr con ellos toda la suite de tests. Y el build de debug con sanitizers que la gente usa a diario es 25 veces más lento que el de release, lo cual está bien para tests y es una razón para no hacer benchmarks con él.
/* bench5.c: the same code under different -O levels and sanitizers.
clang -std=c17 -O2 bench5.c -o b && ./b */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
enum { N = 20000000, REPS = 7 };
static double now_ms(void) {
struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t);
return t.tv_sec * 1e3 + t.tv_nsec / 1e6;
}
static int64_t work(const int *a, int n, int *hist) {
int64_t s = 0;
for (int i = 0; i < n; i++) { hist[a[i] & 255]++; s += (int64_t)a[i] * (i & 7); }
return s;
}
int main(void) {
int *a = malloc(N * sizeof *a);
uint32_t x = 42; /* fixed seed, xorshift32 */
for (int i = 0; i < N; i++) { x ^= x << 13; x ^= x >> 17; x ^= x << 5; a[i] = (int)(x % 1000); }
double best = 1e30; int64_t r = 0;
for (int k = 0; k < REPS; k++) {
int hist[256] = {0};
double t0 = now_ms();
r = work(a, N, hist);
double dt = now_ms() - t0;
if (dt < best) best = dt;
r += hist[7];
}
printf("best of %d: %.2f ms (checksum %lld)\n", REPS, best, (long long)r);
free(a);
return 0;
}
Tabla de decisión: síntoma, herramienta, solución bien definida
| Síntoma | Primera herramienta | Solución bien definida |
|---|---|---|
| Resultado distinto con -O0 y -O2 | -fsanitize=undefined, y luego -fno-sanitize-recover en CI |
elimina el UB; flags como -fwrapv solo como parche temporal |
| Aritmética que puede desbordarse | UBSan signed integer overflow |
revisa antes, o ckd_add/ckd_mul de C23 en <stdckdint.h> |
| Leer los bits de un float, parsear paquetes | (ningún sanitizer lo detecta) | memcpy al otro tipo, o acceso con unsigned char |
| Basura que cambia en cada ejecución | -Wall (-Wsometimes-uninitialized) |
inicializa al declarar; -Werror para ese warning |
| Un chequeo de NULL o de límites "no funciona" | lee el desensamblado de -O2 |
revisa antes de la primera desreferencia |
| Crash solo en otro sistema operativo o CPU | UBSan en tu máquina | no confíes en el resultado afortunado de una plataforma (en arm64 x / 0 dio 0) |
Los dos reemplazos bien definidos, ejecutados en -O0 y -O2 con salida idéntica:
#include <stdckdint.h> /* C23 */
static uint32_t float_bits(float f) { /* the defined way to look at bytes */
uint32_t u;
memcpy(&u, &f, sizeof u);
return u;
}
/* ... */
int sum;
if (ckd_add(&sum, INT_MAX, 1)) puts("ckd_add: overflow detected");
if (!ckd_add(&sum, 40, 2)) printf("ckd_add: 40 + 2 = %d\n", sum);
printf("bits of 1.0f = 0x%08X\n", float_bits(1.0f));
ckd_add: overflow detected
ckd_add: 40 + 2 = 42
bits of 1.0f = 0x3F800000
El memcpy se compila a un solo movimiento de registro en -O2; no cuesta nada.
Límites honestos y notas de versión
- Todos los resultados son de Apple clang 21.0.0 en arm64. Otros compiladores (GCC) y otras versiones pueden optimizar el mismo UB de otra forma, o no optimizarlo; esa es la naturaleza del UB. Las salidas de
-O0/-O2de arriba son lo que hizo este compilador, no lo que garantiza C. - C23 exige representación en complemento a dos para los enteros con signo, pero el overflow con signo sigue siendo indefinido en C23. No leas "complemento a dos" como "da la vuelta".
<stdckdint.h>yckd_addson C23. clang 21 también los aceptó con-std=c17 -Wpedanticsin warning; otros compiladores puede que no, así que compila con-std=c23cuando los uses.- UBSan no reportó la violación de strict aliasing.
-fsanitize=type(TypeSanitizer, nuevo en LLVM) fue aceptado por el driver, pero el enlazado falló porquelibclang_rt.tysan_osx_dynamic.dylibno viene con Apple clang 21. UBSan tampoco encuentra lecturas sin inicializar; MemorySanitizer sí, pero no está disponible en macOS (no lo ejecutamos aquí). - C11 6.8.5p6 (se puede suponer que los bucles terminan) está en C11 y C17. El bug de 2009 del chequeo de NULL en el kernel y el SIGFPE de x86 se describen a partir de la documentación, no se ejecutaron aquí.
- Tiempos: mejor de 7, una sola máquina, dos rondas. Las proporciones importan más que los números absolutos.
Ejercicios
- Predice qué imprimen
same_after_double(21)ysame_after_double(INT_MAX)con-O0y con-O2, dondeint same_after_double(int x) { return (x * 2) / 2 == x; }. Luego di qué reporta UBSan. - La función
gradede arriba: haz que el build falle en vez de solo avisar, sin cambiar el código.
Respuestas
-O0imprimió1 0:INT_MAX * 2dio la vuelta a -2, y -2 / 2 es -1.-O2imprimió1 1: el compilador simplificó(x * 2) / 2axporque la multiplicación "no puede desbordarse". UBSan:ex5.c:3:68: runtime error: signed integer overflow: 2147483647 * 2 cannot be represented in type 'int'.- Agrega
-Werror=sometimes-uninitialized(o-Werror). clang entonces imprimióerror: variable 'bonus' is used uninitialized whenever 'if' condition is false [-Werror,-Wsometimes-uninitialized]y no generó ningún binario.
Para el UB que aparece como errores de memoria (escrituras fuera de rango, use-after-free), mira los reportes de ASan en las clases 3 y 4.
Lo que sigue
La clase 6 cierra la serie con rendimiento: código amigable con la caché, builds con make y depuración con lldb.
Anterior: Clase 4: strings, structs y buffer overflows · Siguiente: Clase 6: código amigable con la caché, make y lldb
Preguntas frecuentes
¿Por qué mi programa en C funciona en debug pero da resultados distintos con -O2?
Normalmente porque tiene comportamiento indefinido que el build -O0 toleró por casualidad. El optimizador tiene permitido suponer que el UB nunca ocurre y simplificar el código con esa base. En nuestras pruebas, x + 1 > x devolvió 0 para INT_MAX con -O0 y 1 con -O2, y un bucle que dependía del overflow dio 22 vueltas con -O0 y desapareció con -O2. Compila con -fsanitize=undefined para encontrar la línea.
¿-fsanitize=undefined detecta todo el comportamiento indefinido?
No. En nuestras pruebas atrapó overflow con signo, shifts demasiado grandes, un índice fuera de rango en un arreglo local y una división entre cero, pero no la violación de strict aliasing, y no detecta lecturas de variables sin inicializar. -fsanitize=type existe, pero su librería de runtime no viene con Apple clang 21, así que el enlazado falló.
¿Cuánto más lento es un build con sanitizers?
En nuestro bucle de 20 millones de elementos, -O2 tardó 9.63 ms, -O2 con UBSan 25.22 ms (2.6x) y -O2 con ASan 17.25 ms (1.8x). -O0 con ambos sanitizers tardó 241 ms, 25 veces lo de -O2. Usa los sanitizers en tests y CI, no en los builds de release.