Undefined behavior

El estándar del lenguaje C especifica con precisión el comportamiento observable de los programas en lenguaje C, excepto para aquellos en las siguientes categorías:

• comportamiento indefinido - no existen restricciones sobre el comportamiento del programa. Ejemplos de comportamiento indefinido son accesos a memoria fuera de los límites de un array, desbordamiento de enteros con signo, desreferenciación de puntero nulo, modificación del mismo escalar más de una vez en una expresión sin puntos de secuencia, acceso a un objeto a través de un puntero de tipo diferente, etc. Los compiladores no están obligados a diagnosticar comportamiento indefinido (aunque muchas situaciones simples son diagnosticadas), y el programa compilado no está obligado a hacer nada significativo.

• comportamiento no especificado - se permiten dos o más comportamientos y la implementación no está obligada a documentar los efectos de cada comportamiento. Por ejemplo, orden de evaluación , si los literales de cadena idénticos son distintos, etc. Cada comportamiento no especificado resulta en uno de un conjunto de resultados válidos y puede producir un resultado diferente cuando se repite en el mismo programa.

• comportamiento definido por la implementación - comportamiento no especificado donde cada implementación documenta cómo se realiza la elección. Por ejemplo, número de bits en un byte, o si el desplazamiento a la derecha de enteros con signo es aritmético o lógico.

• comportamiento específico de la configuración regional - comportamiento definido por la implementación que depende de la configuración regional actualmente seleccionada . Por ejemplo, si islower retorna verdadero para cualquier carácter diferente de las 26 letras latinas minúsculas.

(Nota: Los programas estrictamente conformes no dependen de ningún comportamiento no especificado, indefinido o definido por la implementación)

Los compiladores deben emitir mensajes de diagnóstico (ya sean errores o advertencias) para cualquier programa que viole cualquier regla de sintaxis de C o restricción semántica, incluso si su comportamiento se especifica como undefined o implementation-defined o si el compilador proporciona una extensión de lenguaje que le permite aceptar dicho programa. No se requieren diagnósticos adicionales para undefined behavior.

UB y optimización

Debido a que los programas C correctos están libres de comportamiento indefinido, los compiladores pueden producir resultados inesperados cuando un programa que realmente tiene UB se compila con optimizaciones habilitadas:

Por ejemplo,

Desbordamiento con signo

int foo(int x)
{
    return x + 1 > x; // verdadero o comportamiento indefinido por desbordamiento con signo
}

puede compilarse como ( demo )

foo:
        mov     eax, 1
        ret

Acceso fuera de límites

int table[4] = {0};
int exists_in_table(int v)
{
    // devuelve 1 en una de las primeras 4 iteraciones o UB debido a acceso fuera de límites
    for (int i = 0; i <= 4; i++)
        if (table[i] == v)
            return 1;
    return 0;
}

Puede compilarse como ( demo )

exists_in_table:
        mov     eax, 1
        ret

Escalar no inicializado

_Bool p; // variable local no inicializada
if (p) // acceso UB a escalar no inicializado
    puts("p is true");
if (!p) // acceso UB a escalar no inicializado
    puts("p is false");

Puede producir la siguiente salida (observado con una versión anterior de gcc):

p es true
p es false

size_t f(int x)
{
    size_t a;
    if (x) // ya sea x distinto de cero o comportamiento indefinido
        a = 42;
    return a;
}

Puede compilarse como ( demo )

f:
        mov     eax, 42
        ret

Escalar no válido

int f(void)
{
    _Bool b = 0;
    unsigned char* p = (unsigned char*)&b;
    *p = 10;
    // leer desde b ahora es UB
    return b == 0;
}

Puede compilarse como ( demo )

f:
        mov     eax, 11
        ret

Desreferencia de puntero nulo

int foo(int* p)
{
    int x = *p;
    if (!p)
        return x; // O bien hay UB arriba o esta rama nunca se ejecuta
    else
        return 0;
}
int bar()
{
    int* p = NULL;
    return *p;    // UB incondicional
}

puede compilarse como ( demo )

foo:
        xor     eax, eax
        ret
bar:
        ret

Acceso al puntero pasado a realloc

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int *p = (int*)malloc(sizeof(int));
    int *q = (int*)realloc(p, sizeof(int));
    *p = 1; // UB access to a pointer that was passed to realloc
    *q = 2;
    if (p == q) // UB access to a pointer that was passed to realloc
        printf("%d%d\n", *p, *q);
}

12

Bucle infinito sin efectos secundarios

#include <stdio.h>
int fermat()
{
    const int MAX = 1000;
    // Endless loop with no side effects is UB
    for (int a = 1, b = 1, c = 1; 1;)
    {
        if (((a * a * a) == ((b * b * b) + (c * c * c))))
            return 1;
        ++a;
        if (a > MAX)
        {
            a = 1;
            ++b;
        }
        if (b > MAX)
        {
            b = 1;
            ++c;
        }
        if (c > MAX)
            c = 1;
    }
    return 0;
}
int main(void)
{
    if (fermat())
        puts("Fermat's Last Theorem has been disproved.");
    else
        puts("Fermat's Last Theorem has not been disproved.");
}

Fermat's Last Theorem has been disproved.

Referencias

Véase también

Enlaces externos