# RustCompCert: A Verified and Verifying Compiler for a Sequential Subset of Rust
**Authors**: Jinhua Wu, Yuting Wang, Liukun Yu, Linglong Meng
> Shanghai Jiao Tong University, China â University of Minnesota, USA §
## 1. Introduction
We aim to develop an end-to-end verified Rust compiler. It should provide two guarantees: one is semantics preservation, i.e., the behaviors of source code includes the behaviors of target code, with which the properties verified at the source can be preserved down to the target; the other is memory safety ensured by the verifying compilation (tony-verifying) âthe borrow checking pass (borrow-check-doc), which can simplify the verification of Rust programs, e.g., by allowing the verification tools focus on the functional correctness (Creusot; RustHorn; prusti; Aeneas; Verus; sound-borrow).
However, there are significant challenges in verifying the Rust compiler. Some Rust compilation and checking passes, such as Drop Elaboration (elabdrop) and Borrow Checking (borrow-check-doc), involve complicated program analysis algorithms. It is non-trivial to formalize and verify these analyses within existing frameworks for verified compilers. Existing formalizations of Rust (weiss2019oxide; rustbelt) primarily focus on verifying its type soundness, rather than verifying the analysis algorithms themselves. Aeneas (Aeneas; sound-borrow) proposes a promising borrow checking algorithm based on a borrow-centric semantics, but we focus on another directionâverifying the algorithms used in the standard Rust compiler, namely NLL (rust-nll) or Polonius (Polonius-update). Rust Rustlight Clight Asm Parser RustCompCert frontend CompCert backend
Figure 1. Structure of RustCompCert ( green: verified)
We present our ongoing work on verifying a Rust compiler frontend in Rocq and connecting it with CompCert (leroy09; Leroy-backend) to build an end-to-end verified Rust compiler, which we call RustCompCert. Its overall structure is illustrated in Fig. 1, which consists of three components: (1) an unverified parser that translates source Rust code into Rustlight, a sequential subset of Rust formalized in Rocq; (2) a verified frontend that compiles Rustlight to Clight, including Rust-specific passes such as Drop Elaboration and Borrow Checking; and (3) a verified backend based on CompCert, an optimizing compiler that compiles Clight to assembly We use the framework of CompCertO (direct-refinement; compcerto), an extension of CompCert, to support verified compositional compilation..
Verifying all features of Rust is not realistic. We therefore focus on a core subset of the language, which we formalize as Rustlight. Rustlight supports algebraic data types (i.e., struct and enum), automatic memory management for Box via RAII and ownership semantics, (im)mutable references with region (or lifetime) annotations, as well as the composition of safe and unsafe modules (e.g., safe Rust and C). The main unsupported features include concurrency, polymorphism, traits, and higher-order functions (e.g., closures).
### How we present it
We plan to present our work in 20â25 minutes, with an additional 5â10 minutes reserved for Q&A. The presentation will broadly follow the structure of this paper. We will begin by introducing the compilation passes of RustCompCert and its main correctness theorems in § 2. We will then focus on how we formalize and verify the borrow checking algorithm as described in § 3. Due to time and space limits, we may not cover our approach to supporting unsafe code; interested readers can refer to this paper (open-safety). Our ongoing formalization is publicly available at https://github.com/SJTU-PLV/CompCert/tree/rust-verified-compiler.
## 2. Overview of RustCompCert
The internal structure of the RustCompCert frontend is shown in Fig. 2. We follow the design of the standard Rust compiler (i.e., rustc) to structure our compilation pipeline. The syntax of Rustlight is close to that of surface Rust. We design an intermediate representation called RustIR, whose syntax is similar to MIR. The first pass lowers Rustlight to RustIR in preparation for subsequent analyses, corresponding to the MIR construction in rustc (mir-construct). We then perform Drop Elaboration (elabdrop), which is a key pass in rustc that realizes the mechanism of automatic resource management. This pass determines which drop operations (i.e., destructors) should be executed by analyzing the initialization status of variables. Consequently, the correctness of this pass crucially relies on the soundness of this program analysis.
Rustlight RustIR RustIR Clight Lower Drop Elaboration Clight Generation Borrow Checking
Figure 2. Structure of RustCompCert Frontend
We then perform borrow checking on RustIR. The borrow checker consists of two components: a move checking pass (movecheck), which ensures that each variable is not used after being moved, and a borrow checking pass based on Polonius (Polonius-update). Compare to NLL (rust-nll), the stable borrow checker in rustc which interprets regions as âsets of program points that a loan may liveâ, Polonius can be seen as an alias analysis, which is more suitable to implement in the program analysis framework provided by CompCert. Its interpretation of regions as âsets of places that a reference may point toâ aligns naturally with the values that may be stored in references in the program semantics. The Clight Generation pass serves as the code generation phase. For example, it translates enum types into tagged unions and generates drop glue functions for types that require destructors.
### Compiler Correctness
Like CompCert providing end-to-end semantics preservation for Clight programs, RustCompCert also provides this guarantee for Rustlight programs:
| | $â (M_s:\textnormal{Rustlight}) (M_t:\textnormal{Asm}),$ | |
| --- | --- | --- |
Here $\llbracket M_t\rrbracketâ€slant\llbracket M_s\rrbracket$ is defined as a standard backward simulation, meaning that the behaviors of source program is included in the behaviors of target program.
### Soundness of Borrow Checking
The memory safety ensured by the borrow checking has been utilized by many Rust verification tools (Creusot; RustHorn; prusti; Aeneas; Verus; sound-borrow) to simplify the verification at the source level, e.g., by focusing on its functional correctness. To provide such guarantee, we extract a functional specification called RustIRspec which abstracts the low-level CompCert memory of the RustIR semantics into a structured memory model. The soundness of borrow checking is then formalized as a refinement between RustIRspec and RustIR:
| | $â (M:\textnormal{RustIR}), BorrowCheck(M) \checkmarkâ$ | |
| --- | --- | --- |
For programs passing the borrow checking, we can conclude that its specification is safe, i.e., it has no undefined behaviors. In fact, we cannot show that the borrow checker rules out all undefined behaviors. For example, division-by-zero is a typical UB that borrow checking cannot prevent. Therefore, the safety ensured by the borrow checker is partial safety: some UBs may still occur in the semantics. To obtain total safety (absence of all UBs), it remains the proverâs responsibility to rule out these UBs. The predicate safe can be seen as a definition of partial correctness (open-safety). When the programs are open, it would specify pre- and post-conditions to support composition.
### End-to-end Verification
By combining the soundness of borrow checking and the compiler correctness, the properties verified in RustIRspec can be preserved to the assembly:
| | $â (M_s:\textnormal{RustIR}) (M_t:\textnormal{Asm}),$ | |
| --- | --- | --- |
## 3. Formalization and Verification of the Borrow Checking Algorithm
### Formalization of Polonius
One possible strategy is to re-implement the current Polonius in Rocq, for instance by porting its code from rustc. However, because it relies on complex graph construction and solving algorithms (rustc-polonius), this approach would be difficult to verify in Rocq in practice. We instead implement it within the Kildall framework (kildall) in CompCert by defining its abstract domain and transfer functions. The result of Polonius is then obtained as a fixpoint computed by the Kildall solver.
Abstract Domain. The naive definition is a loans map from regions to set of loans (the terminology representing borrowed places). However, borrow checking relies on variance rules (rust-subtyping) to maintain equality relationships between regions. The analysis must therefore not only propagate loans across regions and program points, but also propagate the equality relation between regions. If two regions are recorded as equal, they must contain the same set of loans. We achieve this by maintaining region equality in the abstract domain using a unionâfind structure. To access the loans associated with a region, we use its representative in the unionâfind to index the loans map instead of using the region itself. As a result, the abstract domain is a pair of type $(MĂ U)$ consisting of a mapping from regions to loans and a unionâfind structure. To integrate this domain into the Kildall framework, we further prove that it forms a semi-lattice.
Transfer Function. A transfer function $F:ââ(MĂ U)â(MĂ U)$ describes how the abstract state of type $(MĂ U)$ evolves for an instruction at node $nââ$ . It mainly specifies how loans flow from one region (e.g., the assigner) to another (e.g., the assignee). Moreover, new equality relations between regions may be established (e.g., by variance rules (rust-subtyping)). Conversely, some relations may need to be removed when one of the regions in the relation becomes dead (i.e., will no longer be used). We design the transfer function following the subtyping and reborrow rules in the NLL RFC (rust-nll) and their implementation in rustc.
### Verification of Polonius
Recall that we define the soundness of borrow checking as a refinement between RustIRspec and RustIR. To prove this refinement for any program that passes borrow checking, the key steps are: (1) to establish an approximation relation between the abstract state produced by the borrow-checking analysis and the concrete state (i.e., the memory model) in the semantics, and (2) to show that under this relation every operation in the structured memory model of RustIRspec can correspond to a non-stuck operation in the CompCert memory model of RustIR. In particular, this implies the absence of memory errors. The first step is the more challenging one. With Polonius viewed as a form of alias analysis, we can relate each region to the set of memory locations that may alias with the places containing this region, a property that is much easier to formalize (verified-alias). This abstraction relation also guides potential improvements to the Polonius algorithm in terms of precision and performance. For instance, we can relax the alias sets to reduce precision in exchange for better performance (e.g., by making Polonius field-insensitive), while still being able to prove soundness using the same proof technique.
## References