PhD: construye lo imposible

Has recorrido todo el mapa: del primer printf al Undefined Behavior. Este último nivel no enseña un tema nuevo — te reta a demostrar que lo entiendes construyendo lo que antes usabas sin pensar. Si puedes escribir tu propia libc y tu propio allocator, y entender cómo un compilador convierte tu C en máquina, eres, de verdad, nivel dios.

Reto 1: tu propia libc mínima

En el nivel 23 corriste código freestanding. Ahora conviértelo en una mini-libc: implementa, desde syscalls crudas, las funciones que dabas por sentadas.

// escribir a la salida estándar, sin la libc: solo la syscall write
long sys_write(int fd, const void *buf, unsigned long n) {
    long r;
    __asm__ volatile ("syscall" : "=a"(r)
        : "a"(1), "D"(fd), "S"(buf), "d"(n) : "rcx", "r11", "memory");
    return r;
}

size_t mi_strlen(const char *s) {          // tu strlen
    const char *p = s;
    while (*p) p++;
    return (size_t)(p - s);
}

int mi_puts(const char *s) {                // tu puts, sobre tu strlen y sys_write
    sys_write(1, s, mi_strlen(s));
    sys_write(1, "\n", 1);
    return 0;
}

Reto 2: tu propio allocator

Implementa malloc y free desde cero, pidiendo memoria al sistema con mmap o sbrk y gestionándola tú. Empieza simple —una lista libre de bloques— y evoluciona:

// esqueleto: pide memoria al kernel y gestiona una lista de bloques libres.
// cada bloque lleva una cabecera con su tamaño y si está libre.
// malloc: busca un hueco suficiente (o pide más al kernel);
// free: marca el bloque libre y fusiona con vecinos libres (coalescing).
void *mi_malloc(size_t n);
void  mi_free(void *p);

Al hacerlo entenderás en carne propia la fragmentación, la alineación (nivel 14), las cabeceras de bloque, y por qué las arenas y pools existen. Habrás cerrado el círculo del nivel 13.

Cómo funciona un compilador por dentro

Has usado gcc y clang cientos de veces. ¿Qué hacen realmente? Un compilador convierte tu C en máquina por fases:

flowchart LR
S[código C] --> L[lexer: tokens]
L --> P[parser: AST]
P --> I[IR intermedio]
I --> O[optimización: pasadas]
O --> C[codegen: ensamblador]
style S fill:#89b4fa,color:#11111b
style I fill:#cba6f7,color:#11111b
style O fill:#fab387,color:#11111b
style C fill:#a6e3a1,color:#11111b

• El lexer parte el texto en tokens (int, x, =, 5).
• El parser los organiza en un árbol de sintaxis (AST) según la gramática.
• Se traduce a una representación intermedia (IR) — en LLVM, el famoso “LLVM IR”.
• Las pasadas de optimización transforman el IR (es aquí donde se explota el UB del nivel 29, se hace inlining, LTO, vectorización).
• El codegen emite ensamblador para tu arquitectura, respetando la ABI (nivel 21).

El camino no termina