## Section: New Results

### Formal verification of compilers and static analyzers

#### The CompCert formally-verified compiler

Participants : Xavier Leroy, Jacques-Henri Jourdan, Robbert Krebbers.

In the context of our work on compiler verification (see section 3.3.1 ), since 2005 we have been developing and formally verifying a moderately-optimizing compiler for a large subset of the C programming language, generating assembly code for the PowerPC, ARM, and x86 architectures [6] . This compiler comprises a back-end part, translating the Cminor intermediate language to PowerPC assembly and reusable for source languages other than C [5] , and a front-end translating the CompCert C subset of C to Cminor. The compiler is mostly written within the specification language of the Coq proof assistant, from which Coq's extraction facility generates executable Caml code. The compiler comes with a 50000-line, machine-checked Coq proof of semantic preservation establishing that the generated assembly code executes exactly as prescribed by the semantics of the source C program.

This year we released three versions of CompCert. Version 1.13, released in March, improves conformance with the ISO C standard by defining the semantics of comparisons involving pointers “one past” the end of an array. Such comparisons used to be undefined behaviors in earlier versions of CompCert. Robbert Krebbers formalized a reasonable interpretation of the ISO C rules concerning pointers “one past” and adapted CompCert's proofs accordingly. CompCert 1.13 also features minor performance improvements for the ARM and PowerPC back-ends, notably for parameter passing via stack locations.

Version 2.0 of CompCert, released in June, re-architects the compiler
back-end around the new register allocator described in
section
6.1.2 . Besides improving the performance of generated
code, this new allocator made it possible to add support for 64-bit
integers, that is, the `long long` and `unsigned long
long` data types of ISO C99. Most arithmetic operations over 64-bit
integers are expanded in-line and proved correct, but a few complex
operations (division, modulus, and conversions to and from
floating-point numbers) are implemented as calls into library
functions.

Moreover, conformance with Application Binary Interfaces
was improved, especially concerning the passing of function parameters
and results of type `float` (single-precision FP numbers).

Finally, CompCert 2.0 features preliminary support for debugging
information. The `-g` compiler flag causes DWARF debugging
information to be generated for line numbers and call stack
structure. However, no information is generated yet for C type
definitions and variable declarations.

Version 2.1, released in October, addresses several shortcomings of
CompCert for embedded system codes, as identified by Airbus during
their experimental evaluation of CompCert. In particular, CompCert
2.1 features the `_Alignas` modifier introduced in ISO C2011, to
support precise control of alignment of global variables and structure
fields, and uses this modifier to implement packed structures in a
more robust fashion than in earlier releases. Xavier Leroy also
implemented and proved correct the optimization of integer divisions
by constants introduced by Granlund and Montgomery
[40] .

#### Register allocation with validation a posteriori

Participant : Xavier Leroy.

Register allocation (the placement of program variables in processor
registers) has a tremendous impact on the performance of compiled
code. However, advanced register allocation techniques are difficult
to prove correct, as they involve complex algorithms and data
structures. Since the beginning of the CompCert project, we chose to
avoid some of these difficult proofs by performing validation
*a posteriori* for part of register allocation: the IRC graph
coloring algorithm invoked during register allocation is not proved
correct; instead, its results are verified at every compiler run to be
a correct coloring of the given interference graph, using a simple
validator proved sound in Coq.

In CompCert 2.0, we push this validation-based approach further. The whole register allocator is now subject to validation a posteriori and no longer needs to be proved correct. The validator follows the algorithm invented by Rideau and Leroy [50] and further developed by Tassarotti and Leroy. It proceeds by backward dataflow analysis of symbolic equations between program variables, registers, and stack locations.

Consequently, the new register allocator for CompCert 2.0 is much more aggressive than that of CompCert 1: it features a number of optimizations that could not be proved correct in CompCert, including live-range splitting, better handling of two-address operations and other irregularities of the x86 instruction set, an improved spilling strategy, and iterating register allocation to place temporaries introduced by spilling. Moreover, the new register allocator can handle program variables of 64-bit integer types, allocating them to pairs of 32-bit registers or stack locations. The new register allocator improves the performance of generated x86 code by up to 10% on our benchmarks.

#### Formal verification of static analyzers based on abstract interpretation

Participants : Sandrine Blazy [EPI Celtique] , Vincent Laporte [EPI Celtique] , Jacques-Henri Jourdan, Xavier Leroy, David Pichardie [EPI Celtique] .

In the context of the ANR Verasco project, we are investigating the formal specification and verification in Coq of a realistic static analyzer based on abstract interpretation. This static analyzer should be able to handle the same large subset of the C language as the CompCert compiler; support a combination of abstract domains, including relational domains; and produce usable alarms. The long-term goal is to obtain a static analyzer that can be used to prove safety properties of real-world embedded C codes.

This year, Jacques-Henri Jourdan worked on numerical abstract domains for the static analyzer. First, he designed, programmed and proved correct an abstraction layer that transforms any relational abstract domain for mathematical, arbitrary-precision integers into a relational abstract domain for finite-precision machine integers, taking overflow and “wrap-around” behaviors into account. This domain transformer makes it possible to design numerical domains without taking into account the finiteness of machine integers. Then, he implemented and proved sound non-relational abstract domains for intervals of integers and of floating-point numbers, supporting almost all CompCert arithmetic operations.

In collaboration with team Celtique, we studied which intermediate languages of the CompCert C compiler are suitable as source language for the static analyzer. Early work by Blazy, Laporte, Maroneze and Pichardie [36] performs abstract interpretation over the RTL intermediate language, a simple language with unstructured control (control-flow graph). However, this language is too low-level to support reporting alarms at the level of the source C program.

Later this year, we decided to use the C#minor intermediate language
of CompCert as source language for analysis. This language has mostly
structured control (if/then/else, C loops, and `goto` ), and is
much closer to the source C program. Then, Jacques-Henri Jourdan,
Xavier Leroy and David Pichardie designed a generic abstract
interpreter for the C#minor language, parameterized by an abstract
domain of execution states, using structured fixpoint iteration for
loops and a function-global iteration for `goto` .
Jacques-Henri Jourdan is in the process of proving the
soundness of this abstract interpreter in Coq.

#### Formalization of floating-point arithmetic

Participants : Sylvie Boldo [EPI Toccata] , Jacques-Henri Jourdan, Xavier Leroy, Guillaume Melquiond [EPI Toccata] .

Last year, we replaced the axiomatization of floating-point numbers and arithmetic operations used in early versions of CompCert by a fully-formal Coq development, building on the Coq formalization of IEEE-754 arithmetic provided by the Flocq library of Sylvie Boldo and Guillaume Melquiond. A paper describing this work was presented at the ARITH 2013 conference [15] .

This year, we extended this formalization of floating-point arithmetic with a more precise modeling of “Not a Number” special numbers, reflecting the signs and payloads of these numbers into their bit-level, in-memory representation. We also proved correct more algebraic identities over FP computations, such as $x/{2}^{n}=x\times {2}^{-n}$ if $\left|n\right|<1023$, as well as nontrivial implementation schemes for conversions between integer and FP numbers, whose correctness rely on subtle properties of the “round to odd” rounding mode. These extensions are described in a draft journal paper under submission [29] , and integrated in version 2.1 of CompCert.

#### Formal verification of hardware synthesis

Participants : Thomas Braibant, Adam Chlipala [MIT] .

Verification of hardware designs has been thoroughly investigated. Yet, obtaining provably correct hardware of significant complexity is usually considered challenging and time-consuming. Hardware synthesis aims to raise the level of description of circuits, reducing the effort necessary to produce them. This yields two opportunities for formal verification: a first option is to verify (part of) the hardware compiler; a second option is to study to what extent these higher-level design are amenable to formal proof.

Continuing work started during a visit at MIT under the supervision of Adam Chlipala, Thomas Braibant worked on the implementation and proof of correctness of a prototype hardware compiler. This compiler produces descriptions of circuits in RTL style from a high-level description language inspired by BlueSpec. Formal verification of hardware designs of mild complexity was conducted at the source level, making it possible to obtain fully certified RTL designs. A paper describing this compiler and two examples of certified designs was presented at the CAV 2013 conference [16] .