TL;DR:

“A complete compiler pipeline (Lexing to IR) featuring a custom memory management strategy to ensure zero-leak stability under high-stakes testing constraints.”

The Project

The Tiger Compiler is one of the most rigorous projects at EPITA. Developed over two months in a team of four, the goal was to build a robust pipeline capable of translating Tiger source code into executable logic.

Because of the project’s complexity, we were limited to only four official submissions to pass a suite of 100+ hidden test cases. A single segmentation fault or memory leak would result in an immediate failure for that submission, requiring a level of precision far beyond standard academic exercises.

Technical Implementation

I focused on the core architecture and the transition between semantic analysis and code generation:

• Lexing & Parsing: Utilized Flex and Bison to generate a concrete syntax tree.
• AST Generation: Designed a clean Abstract Syntax Tree to represent Tiger’s unique features like nested scopes and record types.
• Semantic Analysis: Implemented a visitor pattern for type checking and scope resolution.
• Intermediate Representation: Leveraged LLVM to translate the AST into optimized code.

The “Baballoc” Strategy

One of the primary challenges was ensuring zero memory leaks across thousands of lines of complex C++ logic. With limited submissions and no error logs from the grading server if any memory leaks occurred, we couldn’t rely on simple trial and error.

I developed a custom internal memory manager dubbed “Baballoc”. Instead of standard raw pointers, I implemented a wrapper around malloc and free that tracked every active allocation in a specialized linked list.

• The Benefit: It allowed us to perform a “Global Sweep” upon program termination, ensuring every byte was accounted for and freed.
• The Result: During our final jury, we were able to demonstrate a 100% leak-free execution. While unconventional for long-running services, this was a highly effective architectural decision for a CLI compiler, ensuring total stability under the grading server’s strict constraints.

Key Takeaways

This project was my first deep dive into LLVM and industrial-grade C++. It taught me how to manage high-pressure deadlines where “close enough” isn’t an option. More importantly, it taught me that sometimes the best engineering solution is to build your own tooling (like Baballoc) to guarantee the reliability of the main system.

The grade & the source code ?

We achieved a score of 16/20, passing all test cases without a single memory leak or segmentation fault. Unfortunately, due to academic policies, the source code cannot be publicly shared to prevent plagiarism since it is a pivot project of the EPITA curriculum. But some people shared it nonetheless for example here, this can help you get a grasp of the complexity of the project: tiger-compiler