Write an IR Pretty-Printer and Round-Trip Parser

Topic Overview

Readable IR Aids Debugging

LLVM's -S flag prints human-readable .ll files; GCC dumps GIMPLE with -fdump-tree-ssa. A pretty-printer turns your internal IR into text you can diff, test, and round-trip. Compiler engineers spend hours reading printed IR when optimizations go wrong.

Print and Parse Round-Trip

Walk instructions and emit syntax: t1 = add t2, t3. Labels on their own lines. Functions as named regions. A parser that reads the same format validates your printer and enables file-based test cases.

cCopy
Loading…

• Consistent formatting makes diffs meaningful
• Operand kinds: temp, variable, constant, label
• Round-trip: print then parse equals original
• Pretty output is the primary debug interface for IR bugs

Connecting to real compilers

Production compilers embed this step inside a longer pipeline. GCC flows through cpp, cc1, assembly, and ld; Clang uses the driver, Sema, LLVM IR passes, and a target backend. LLVM bitcode, JVM bytecode, and WASM are other familiar IRs at the same layer. The exercise isolates one pass so you can test it alone before chaining it to the next stage.

Why for this exercise

You will write an IR pretty-printer and optional round-trip parser. This exercise asks you to serialize your instruction list to text and verify that parsed output reconstructs the same structure.

Your Task

Write a pretty-printer and a parser for three-address code that round-trip: parsing the printer's output and printing it again must give byte-identical text. Hand-written input is messy; the printer's output is canonical.

Input

TAC with any spacing: tokens may be separated by spaces, tabs, or nothing at all (x=a+b). Instructions:

cCopy
Loading…

Operands are names ([A-Za-z_][A-Za-z0-9_]*) or integer literals, which may be negative (-3) where an operand is expected. # starts a comment that runs to the end of the line; comments and blank lines are discarded.

Canonical format

• Split the code into basic blocks (leaders: the first instruction, every label, every instruction after goto/if/ifFalse/return).
• Before each block print # BK (blocks numbered from 0); put one blank line between blocks.
• Labels are printed flush left as NAME:; every other instruction is indented 4 spaces with single spaces between tokens ( x = a + b).

Output

1. The canonical text.
2. A blank line, then instructions=N blocks=B.
3. round-trip: ok if parsing the canonical text (your own parser must skip the # BK comments) and printing it again reproduces it exactly; otherwise round-trip: FAILED.

If any input line cannot be parsed, print only error: line L: cannot parse 'TEXT' (TEXT = the line with leading/trailing whitespace and any comment removed) and stop.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. A tokenizer that doesn't depend on whitespace, a parser into an instruction array, and a printer that writes into a buffer (so you can compare the two printings).
2. The parser must accept its own output, including the block comments and blank lines.

Hidden tests cover negative literals, every operator, labels immediately after jumps, comments everywhere, and an unparseable line.