Nivel 5 · Investigación· Lección 3 de 9 · 50 min
Modelos de aliasing: Stacked Borrows, Tree Borrows y procedencia
Qué tiene realmente permitido hacer el código unsafe — semánticas operacionales para las referencias, la procedencia de los punteros, y las optimizaciones que estos modelos existen para justificar.
Las reglas del Rust seguro las impone un comprobador de tipos. Las reglas del Rust unsafe son una especificación del comportamiento indefinido, y en lo que respecta al aliasing esa especificación todavía se está decidiendo. Esta lección cubre las dos propuestas principales y el concepto que hay debajo de ambas.
Por qué hace falta un modelo
Considera lo que el compilador quiere hacer con las referencias:
fn example(x: &mut i32, y: &i32) -> i32 {
*x = 10;
unknown(); // alguna función dentro de la cual el compilador no puede ver
let a = *y;
*x = 20;
a + *x // al compilador le gustaría devolver `a + 20` sin volver a leer *x,
// y suponer que `*y` no cambió por `*x = 10` ni por `unknown()`
}
fn unknown() {}
Esas optimizaciones solo son válidas si x e y no tienen aliasing, y si unknown no puede escribir en *x ni en *y a través de algún puntero crudo guardado. El sistema de tipos lo garantiza para el código seguro. Para el código unsafe, nada en el sistema de tipos te impide fabricar un &mut con aliasing. Así que el lenguaje debe declarar que esos programas tienen comportamiento indefinido, y debe decir con precisión cuáles; de lo contrario, ni quienes escriben compiladores ni quienes escriben código unsafe saben dónde está la línea.
Un modelo de aliasing es por tanto un contrato con dos lados: enumera lo que el código unsafe no debe hacer y, con ello, lo que el optimizador puede dar por supuesto.
Los modelos se definen de forma operacional: la máquina abstracta lleva un estado «fantasma» adicional, y cada acceso a memoria lo comprueba y lo actualiza. Si una comprobación falla, el programa tiene UB. Miri implementa exactamente esa máquina, y por eso puede detectar las violaciones.
Procedencia
Antes del aliasing, una pregunta más básica: ¿qué es un puntero?
fn main() {
let a = [1u8, 2];
let b = [3u8, 4];
let end_of_a = a.as_ptr().wrapping_add(2);
let start_of_b = b.as_ptr();
// Las dos direcciones bien pueden ser iguales: los arrays pueden ser contiguos en la pila.
println!("same address: {}", end_of_a as usize == start_of_b as usize);
// Aun así, leer a través de `end_of_a` es comportamiento indefinido aunque sean iguales:
// se derivó de `a`, y su procedencia no cubre `b`.
println!("{}", unsafe { *start_of_b });
}
Un puntero en la máquina abstracta es una dirección más una procedencia (provenance): la reserva de la que se derivó y los permisos que lleva. La procedencia no se guarda en los bits; existe para que el compilador pueda razonar que los punteros derivados de reservas distintas nunca tienen aliasing. Todos los compiladores principales razonan ya así: LLVM y GCC compilan mal los programas que suponen que los punteros son «solo enteros».
Consecuencias:
- Un puntero solo puede acceder a memoria dentro de la reserva de la que se derivó, aunque la aritmética lo lleve a una dirección válida en otro sitio.
- Las conversiones de puntero a entero pierden la procedencia; las de entero a puntero tienen que invocarla de la nada. Esta es la parte difícil. Rust ofrece dos regímenes:
- Procedencia estricta (estable desde la 1.84):
ptr.addr()devuelve la dirección sin exponer la procedencia;ptr.with_addr(a)yptr.map_addr(f)producen un puntero nuevo con una dirección distinta y la misma procedencia. El etiquetado de punteros y trucos parecidos pueden escribirse sin ninguna conversión de entero a puntero, y Miri puede comprobarlos con precisión. - Procedencia expuesta:
ptr.expose_provenance()yptr::with_exposed_provenance(addr)(y las conversiones conas) permiten viajes reales de ida y vuelta. El modelo marca la procedencia como expuesta, y una conversión posterior puede recoger cualquier procedencia expuesta: correcto para quien programa, pero bloquea optimizaciones y es difuso de comprobar por naturaleza.
- Procedencia estricta (estable desde la 1.84):
- Los bytes también llevan procedencia: copiar un puntero byte a byte debe conservarla, y por eso la memoria se modela como bytes abstractos (inicializados, con procedencia opcional, o sin inicializar), no como
u8.
Stacked Borrows
Jung, Dang, Kang y Dreyer, POPL 2020.
Cada valor puntero lleva una etiqueta (tag). Cada posición de memoria tiene una pila de préstamos de elementos, cada uno una etiqueta con un permiso:
| Permiso | Lo concede | Permite |
|---|---|---|
Unique |
&mut T |
leer y escribir |
SharedReadOnly |
&T (fuera de UnsafeCell) |
leer |
SharedReadWrite |
los punteros crudos, &T dentro de UnsafeCell |
leer y escribir |
Las reglas, en esencia:
- Reetiquetado (retag). Crear una referencia, o pasar una a una función, apila un elemento nuevo con una etiqueta nueva en lo alto de la pila, encima del elemento del que se derivó.
- Uso. Para acceder a memoria a través de un puntero, su etiqueta debe estar en la pila. Una escritura desapila todo lo que hay por encima del elemento usado. Una lectura desapila (o desactiva) los elementos
Uniqueque tiene encima. - Si la etiqueta ya no está en la pila, el acceso es comportamiento indefinido.
- Protectores. Una referencia pasada como argumento de función está protegida mientras dura la llamada: desapilar su elemento es UB. Esto es lo que permite al compilador suponer que un argumento de tipo referencia sigue siendo válido durante toda la función.
La disciplina de pila refleja el anidamiento de los reborrows que el borrow checker impone estáticamente: un préstamo hijo debe haber terminado antes de que se vuelva a usar su padre.
fn main() {
let mut x = 10;
let a = &mut x as *mut i32; // pila de x: [Unique(x), SharedRW(a)]
let b = &mut x as *mut i32; // un nuevo &mut x es un uso de tipo escritura de la base: desapila `a`
// pila de x: [Unique(x), SharedRW(b)]
unsafe {
*b += 1; // correcto: la etiqueta de b está en la pila
// *a += 1; // sería UB: la etiqueta de a se desapiló
}
println!("{x}");
}
Quita el comentario de la escritura a través de a y ejecútalo con Miri en el Playground: el ejemplo «Comportamiento indefinido» de allí es este programa. Una ejecución normal imprime 12 y no da ninguna pista de que haya un problema.
La forma correcta de obtener dos punteros crudos a los mismos datos es derivar los dos de uno: let a = &raw mut x; let b = a;.
Dónde Stacked Borrows es demasiado estricto
Stacked Borrows validó un conjunto importante de optimizaciones, con demostraciones verificadas por máquina. Pero la experiencia con Miri sobre crates reales sacó a la luz patrones que rechaza, que los programadores consideran razonables y que LLVM en realidad no aprovecha:
- Una referencia se reetiqueta exactamente para los bytes de su tipo. El código que toma
&mut headery después desplaza el puntero para llegar a los datos que van a continuación en la misma reserva (el modismo «container_of» de C) es UB. - Crear un
&mutse trata como una escritura, así que el mero hecho de crear una referencia mutable invalida los punteros hermanos aunque nunca se use. - Las referencias compartidas no permiten ninguna reordenación con ciertas lecturas a través de punteros crudos que parecen inofensivas.
Tree Borrows
Villani, Hostert, Dreyer y Jung, PLDI 2025.
Tree Borrows sustituye la pila por un árbol por reserva: cada nodo es una etiqueta de puntero; un reborrow añade un hijo. Cada nodo guarda, por cada posición de memoria, un estado de una pequeña máquina de estados:
Un acceso es un acceso hijo para un nodo si se hace a través de ese nodo o de uno de sus descendientes, y un acceso ajeno en caso contrario. Cada acceso actualiza todos los nodos del árbol según esta tabla de transiciones (simplificada; los protectores y la mutabilidad interior añaden casos):
| Estado | Lectura hija | Escritura hija | Lectura ajena | Escritura ajena |
|---|---|---|---|---|
Reserved (&mut recién creado) |
se queda | → Active |
se queda | → Disabled |
Active (&mut en el que se ha escrito) |
se queda | se queda | → Frozen |
→ Disabled |
Frozen (&T, o &mut degradado) |
se queda | UB | se queda | → Disabled |
Disabled |
UB | UB | se queda | se queda |
Lo que se gana:
Reservedmodela directamente los préstamos en dos fases. Un&mutrecién creado todavía no estáActive; tolera las lecturas ajenas hasta su primera escritura. Crear una referencia mutable ya no es una escritura.- Violaciones perezosas, guiadas por los accesos. Un puntero en conflicto pasa a
Disabledsolo cuando se produce de verdad un acceso en conflicto, y el UB solo ocurre cuando se usa un puntero desactivado. - Sin extensión fija. Los permisos fuera del rango inicial de la referencia se inicializan de forma perezosa en el primer acceso, así que el patrón
container_ofy los desplazamientos dentro de una misma reserva están permitidos. - Los protectores se mantienen, reforzados: un nodo protegido no debe pasar a
Disabled, y las referencias que son argumentos de función se comportan como activas mientras dura la llamada.
El precio: se pierden algunas optimizaciones que son válidas con Stacked Borrows, en particular algunas que adelantan escrituras, puesto que una referencia Reserved todavía no ha reclamado la exclusividad. La evaluación del artículo encontró que Tree Borrows rechaza muchos menos conjuntos de pruebas de crates reales que Stacked Borrows, conservando las optimizaciones de reordenación de lecturas que importan. Los autores aportan también demostraciones mecanizadas (en Rocq) de que las optimizaciones clave son correctas bajo el modelo.
En Miri, Stacked Borrows es el modelo por defecto; -Zmiri-tree-borrows selecciona Tree Borrows. Ninguno de los dos es normativo todavía. La postura oficial es conservadora: el código que es UB con los dos modelos debe considerarse incorrecto; el código que Tree Borrows acepta pero Stacked Borrows rechaza está en una zona gris que lo más probable es que acabe permitida.
El esfuerzo de especificación más amplio
- La Rust Reference enumera el comportamiento que se considera indefinido, con la advertencia explícita de que la lista no es definitiva.
- El grupo de trabajo de las Unsafe Code Guidelines (ahora el equipo opsem) mantiene un glosario y un registro de cuestiones abiertas: la validez de las referencias a memoria sin inicializar, las reglas exactas de
UnsafeCell, cuándo puede leerse el relleno, y más. - MiniRust (Jung) es una especificación precisa de un lenguaje núcleo parecido a Rust, escrita como un intérprete en un pseudolenguaje parecido a Rust: la definición que se pretende normativa de la máquina abstracta, con Stacked/Tree Borrows como un componente intercambiable.
- Miri (Jung et al., POPL 2026) es la implementación de referencia de todo esto, y es lo que hace falsables los modelos: se evalúan contra los conjuntos de pruebas de miles de crates.
Reglas con las que trabajar hoy
- Nunca tengas un
&mut Tvivo y cualquier otro puntero utilizable a la misma memoria que no se haya derivado de ese&mut. - No escribas a través de un puntero derivado de un
&Tsalvo que los datos estén dentro de unUnsafeCell. - Cuando necesites varios punteros crudos a un objeto, crea un puntero crudo y cópialo; no crees referencias entre medias.
- Prefiere
&raw mut/&raw consta&mut x as *mut _: no crean ninguna referencia intermedia. - Mantén los punteros como punteros. Usa la API de procedencia estricta; evita los viajes de ida y vuelta por enteros.
- Ejecuta tus pruebas con Miri con los dos modelos.
Lista de lecturas
- Jung et al., «Stacked Borrows: An Aliasing Model for Rust» (POPL 2020).
- Villani et al., «Tree Borrows» (PLDI 2025), y la serie anterior de entradas de blog de Villani.
- Jung, «Pointers Are Complicated» I–III (blog): la mejor introducción a la procedencia.
- Memarian et al., «Exploring C Semantics and Pointer Provenance» (POPL 2019): PNVI y el lado de C de la historia.
- Lee et al., «Reconciling High-Level Optimizations and Low-Level Code in LLVM» (OOPSLA 2018).
- La documentación del módulo
std::ptr, secciones sobre la procedencia. - El repositorio de MiniRust y la referencia de las Unsafe Code Guidelines.
Ejercicios
- Para el programa de
a/b, escribe la pila de préstamos después de cada línea con Stacked Borrows. Después dibuja el árbol y los estados de los nodos con Tree Borrows. ¿Acepta Tree Borrows la escritura a través dea? Compruébalo con Miri. - Escribe un programa que Stacked Borrows rechace y Tree Borrows acepte, usando un puntero al primer campo de un struct
repr(C)para llegar al segundo campo. - Implementa un puntero etiquetado (con los dos bits bajos usados como banderas) con
map_addr, sin convertir nunca un entero en un puntero. - Explica, haciendo referencia a los protectores, por qué es UB que una función que recibe
x: &mut i32provoque que*xse libere antes de que retorne, aunquexno se vuelva a usar. - Da una optimización que sea correcta con Stacked Borrows y no con Tree Borrows, y argumenta por qué a partir del estado
Reserved.
Comprueba lo que has entendido
Elige una respuesta para ver la explicación.
1.¿Por qué necesita Rust un modelo de aliasing definido para el código unsafe, si el borrow checker ya impone las reglas de aliasing?
2.¿Qué es la procedencia (provenance) de un puntero?
3.¿En qué se diferencia principalmente Tree Borrows de Stacked Borrows?