Nivel 5 · Investigación· Lección 5 de 9 · 40 min
Arquitectura del compilador
Del texto fuente al código máquina — las representaciones, el sistema de consultas y la compilación incremental, la monomorfización, los backends, y cómo empezar a contribuir.
Para investigar sobre Rust, o simplemente para entender por qué se comporta como lo hace, necesitas un mapa de rustc. Esta lección es ese mapa, con instrucciones para mirar tú mismo cada etapa.
La cadena de compilación
texto fuente
│ análisis léxico y sintáctico
▼
AST ──────────── expansión de macros, resolución de nombres, lints tempranos
│ bajada (elimina el azúcar de `for`, `?`, `async`, `if let`…)
▼
HIR ──────────── recogida de tipos, inferencia y comprobación de tipos, resolución de traits, lints tardíos
│ bajada con los tipos adjuntos
▼
THIR ─────────── comprobación de exhaustividad de patrones, comprobación de unsafe
│ construcción de MIR
▼
MIR ──────────── borrow checking, evaluación constante (el motor de Miri), optimizaciones
│ recogida para la monomorfización
▼
IR del backend (LLVM IR / Cranelift IR / GIMPLE) ── optimización, generación de código
│
▼
archivos objeto ── enlazado ──▶ ejecutable o biblioteca
| IR | Qué es | Por qué existe |
|---|---|---|
| Flujo de tokens | Tokens del análisis léxico, agrupados en árboles de tokens | Entrada y salida de las macros |
| AST | Árbol sintáctico, cercano al código fuente | Expansión de macros, resolución de nombres |
| HIR | Árbol sin azúcar sintáctico, con los nombres resueltos e identificadores estables | Comprobación de tipos; una superficie mucho menor que la del AST |
| THIR | Árbol completamente tipado, con el autoderef, las coerciones y las llamadas a métodos explícitos | Comprobación de exhaustividad; construcción de MIR |
| MIR | Grafo de flujo de control de sentencias simples sobre lugares | Borrow checking, optimización, evaluación constante, monomorfización |
| LLVM IR | Monomórfico, SSA, tipado, de bajo nivel | Optimización independiente de la plataforma y generación de código |
Cada bajada elimina azúcar sintáctico y añade explicitud. Al llegar a MIR, for x in v { … } se ha convertido en un bucle que llama a Iterator::next y hace match sobre el resultado, con liberaciones explícitas.
Mira cada etapa
Toma una función pequeña e imprímela en cada nivel:
fn sum_evens(v: &[u32]) -> u32 {
let mut total = 0;
for &x in v {
if x % 2 == 0 {
total += x;
}
}
total
}
fn main() {
println!("{}", sum_evens(&[1, 2, 3, 4]));
}
| Para ver | Comando |
|---|---|
| El código con las macros expandidas | cargo expand (o rustc -Zunpretty=expanded en nightly) |
| HIR | rustc +nightly -Zunpretty=hir-tree o hir |
| THIR | rustc +nightly -Zunpretty=thir-tree |
| MIR | rustc --emit=mir (estable), o Show MIR en el Rust Playground |
| LLVM IR | rustc --emit=llvm-ir -C opt-level=3 |
| Ensamblador | rustc --emit=asm -C opt-level=3, cargo asm o Compiler Explorer |
| Layouts de los tipos | rustc +nightly -Zprint-type-sizes |
| Tiempo por pasada | cargo +nightly rustc -- -Ztime-passes, -Zself-profile |
Hazlo una vez con una función que tenga una clausura, un match, una async fn y un genérico. Una hora invertida aquí explica más sobre Rust que una semana de lectura.
El front end
El análisis sintáctico produce el AST con un analizador descendente recursivo escrito a mano, con una amplia recuperación de errores: el origen de los buenos errores de sintaxis de Rust.
La expansión de macros y la resolución de nombres están entrelazadas, porque las macros pueden definir nombres y los nombres determinan qué macro se invoca. El bucle se ejecuta hasta un punto fijo. La higiene se implementa con contextos sintácticos asociados a los identificadores.
La bajada a HIR elimina el azúcar sintáctico y asigna a cada elemento un DefId y a cada nodo un HirId, identificadores estables que se usan en todas las etapas posteriores.
Comprobación de tipos
La comprobación de tipos se ejecuta por cada cuerpo de función (typeck) y tiene tres tareas entrelazadas:
- La inferencia de tipos, al estilo de Hindley–Milner con variables de unificación, ampliada con subtipado (para los lifetimes), coerciones, valores por defecto para enteros y flotantes y una propagación bidireccional de la expectativa que hace que las clausuras y los literales se infieran bien.
- La resolución de traits (lección anterior): la búsqueda de métodos prueba receptores candidatos a través del autoderef; las obligaciones que genera cada expresión se registran y se resuelven a medida que se resuelven las variables de inferencia.
- Las restricciones de regiones se recogen pero no se resuelven aquí: los lifetimes se borran de los resultados de typeck y el borrow checker los vuelve a derivar sobre MIR. Esa separación es la razón de que los lifetimes nunca afecten a qué método se llama ni a cómo se genera el código.
No existe una inferencia de tipos de todo el crate: cada función se infiere a partir de su cuerpo contra su firma declarada. Es una decisión de diseño deliberada: las firmas son la unidad de abstracción y de compilación.
MIR y sus usos
MIR es el centro de todo:
- El borrow checking (lección 5.2).
- La evaluación constante:
const,static, las longitudes de los arrays y lasconst fnlas evalúa un intérprete sobre MIR. Miri, la herramienta, es ese mismo motor con comprobaciones adicionales. - Las optimizaciones sobre MIR: inlining, propagación de constantes y de copias, eliminación de código muerto y de escrituras muertas, jump threading, sustitución escalar de agregados. Optimizar antes de la monomorfización se paga una vez por función genérica en lugar de una vez por instancia.
- La transformación de corrutinas: los bloques
asyncy los generadores se convierten aquí en enums que son máquinas de estados. - La elaboración de las liberaciones: las liberaciones condicionales se hacen explícitas con banderas de liberación.
Monomorfización y generación de código
Partiendo de las raíces (main, las funciones exportadas), el recolector recorre el MIR y encuentra todas las instancias concretas necesarias: Vec<u32>::push, Option<String>::map::<usize, {closure}>. Las instancias se reparten en unidades de generación de código (codegen units), que se traducen a la IR del backend y se optimizan en paralelo.
Consecuencias que ya conoces: el código genérico cuesta tiempo de compilación y tamaño de binario por instancia; dyn Trait lo evita; el cuerpo de una función genérica debe estar disponible para los crates que dependen de ella (se guarda como MIR en los metadatos .rmeta), y por eso las funciones genéricas y las marcadas con #[inline] pueden expandirse en línea entre crates y las demás no pueden sin LTO.
Backends:
- LLVM: el backend por defecto; optimización madura y amplio soporte de plataformas.
- Cranelift (
rustc_codegen_cranelift): compilación más rápida, optimización más ligera; pensado para las compilaciones debug. - GCC (
rustc_codegen_gcc): libgccjit como backend, para las plataformas que LLVM no cubre.gccrses un front end aparte e independiente dentro de GCC.
La información específica de Rust que se pasa a LLVM es lo que convierte las garantías del lenguaje en velocidad: noalias en los parámetros &mut y & (sin UnsafeCell), nonnull y dereferenceable, readonly, metadatos de rango en los enums y en bool. Esos atributos son la forma concreta del modelo de aliasing, y unos atributos equivocados son compilaciones incorrectas; por eso importa el modelo.
El sistema de consultas
rustc no es una secuencia de pasadas sobre el crate entero. Está guiado por la demanda: es un conjunto de funciones con memorización llamadas consultas (queries), cuya clave es casi siempre un DefId.
optimized_mir(f)
└─ mir_borrowck(f)
└─ mir_built(f)
└─ thir_body(f)
└─ typeck(f)
├─ fn_sig(g) para cada función llamada g
├─ type_of(S) para cada tipo mencionado
└─ predicates_of(…) …
Pedir un resultado ejecuta el proveedor en el primer uso y guarda la respuesta en el contexto de tipos (TyCtxt, la estructura de datos central a través de la cual se llega a todo). Los tipos, los predicados y otros valores inmutables se internan en arenas, así que la igualdad es una comparación de punteros.
La compilación incremental se desprende de este diseño. El compilador registra el grafo de dependencias entre consultas y un hash de cada resultado. En la siguiente compilación usa el algoritmo rojo-verde: una consulta está en verde si todas sus dependencias están en verde (se reutiliza su resultado en caché); en caso contrario se vuelve a ejecutar, y si el resultado nuevo tiene el mismo hash que antes se marca en verde de todos modos, lo que corta el cambio. Edita el cuerpo de una función y su typeck y su MIR se recalculan, pero fn_sig no cambia, así que quienes la llaman quedan intactos.
Esta arquitectura es también lo que permite a rust-analyzer (que usa su propio motor de consultas, salsa) responder a las peticiones del IDE en milisegundos.
Los diagnósticos como prioridad de diseño
Los mensajes de error de Rust son una inversión de ingeniería deliberada: diagnósticos estructurados con spans, etiquetas, notas y sugerencias aplicables por máquina; una recuperación dedicada en el analizador sintáctico; miles de pruebas de interfaz que fijan la salida exacta. Buena parte de la complejidad del compilador existe para el camino de los errores. Si quieres hacer una primera contribución, mejorar un diagnóstico es el lugar tradicional por donde empezar.
Trabajar en el compilador
git clone https://github.com/rust-lang/rust
cd rust
./x setup # elige el perfil "compiler"
./x check # comprueba los tipos del compilador
./x build library # compila un compilador de etapa 1 y la biblioteca estándar
./x test tests/ui # ejecuta el conjunto de pruebas de interfaz
- El compilador se compila a sí mismo por etapas (bootstrapping): un compilador de etapa 0 descargado compila la etapa 1 a partir del código fuente, que a su vez puede compilar la etapa 2.
- Lee la rustc dev guide junto al código fuente. El código está organizado en crates llamados
rustc_*:rustc_parse,rustc_resolve,rustc_hir_typeck,rustc_trait_selection,rustc_borrowck,rustc_mir_transform,rustc_codegen_ssa,rustc_middle(definiciones compartidas, incluidoTyCtxt). - La coordinación tiene lugar en el Zulip de rust-lang. Los cambios en el lenguaje pasan por las RFC y el equipo del lenguaje; los cambios internos del compilador, por las major change proposals. El equipo de tipos es responsable del sistema de tipos y del resolutor de traits; el equipo opsem, de la semántica operacional y del UB.
- Los cambios que pueden romper código se prueban con crater, que compila y prueba todos los crates de crates.io con el compilador modificado: una herramienta empírica casi exclusiva del proceso de Rust.
- Las incidencias etiquetadas como
E-easyyE-mentorestán pensadas para quienes llegan por primera vez.
Lista de lecturas
- La Rust Compiler Development Guide: la referencia principal.
- Matsakis, «Introducing MIR» (2016) y la RFC 1211.
- La documentación de la API
rustc_middle::ty: el vocabulario del sistema de tipos tal como está implementado. - Appel, Modern Compiler Implementation, o Cooper y Torczon, Engineering a Compiler: como base general.
- Lattner y Adve, «LLVM: A Compilation Framework for Lifelong Program Analysis and Transformation» (2004).
- La documentación de salsa, para ver el modelo de consultas de forma aislada.
Ejercicios
- Emite el MIR de
sum_evens. Encuentra la llamada anextdel iterador, el switch sobre el discriminante delOptiony la comprobación de desbordamiento detotal += x. - Emite el LLVM IR optimizado de la misma función. ¿Se vectorizó el bucle? Encuentra los atributos
noaliasyreadonlydel parámetro. - Usa
-Zself-profilecon un crate de tamaño medio e identifica las tres consultas más caras. - Escribe una función que se monomorfice en 100 instancias (un genérico llamado con 100 longitudes de array mediante una macro). Mide el efecto en el tiempo de compilación y en el tamaño del binario; después refactoriza a un envoltorio genérico fino alrededor de una función interna no genérica.
- Compila rustc a partir del código fuente y cambia la redacción de un mensaje de error. Ejecuta las pruebas de interfaz afectadas y actualiza su salida esperada con
--bless.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿En qué representación intermedia siguen siendo genéricas las funciones genéricas?
2.¿Qué es el sistema de consultas (query system)?
3.¿Por qué el algoritmo rojo-verde de la compilación incremental evita a veces recalcular una consulta cuya entrada cambió?