I’ve written recently about clean-ups I’ve been making in Nanojit — simplifying code, refactoring, adding more internal sanity checking. I’m a firm believer that these kinds of changes are worth doing, that “if it ain’t broke, don’t fix it” is not always true. But there’s always a voice in the back of my head wondering “am I just polishing this code for little gain? Should I be working on something else instead?” Yesterday I received confirmation that this work has been worthwhile. But before I can explain why, I need to give some background.
Nanojit serves as the back-end of TraceMonkey. It converts LIR (a low-level intermediate representation) generated by TraceMonkey’s front-end into native code. So Nanojit is a critical part of TraceMonkey. And TraceMonkey is a critical part of Firefox.
However, code generators (and register allocators) are tricky beasts — easy to get wrong and hard to debug. (A long time ago I heard someone, I can’t remember who, say “code generators and garbage collectors should crash as early and noisily as possible”.) So with a piece of code this important and inherently difficult, it’s a good idea to arm yourself with some weapons that give you confidence that it is correct.
Weapon 1: clean IR semantics
One way to do this is to give your IR clean semantics. LIR’s semantics are mostly clean, but there are a few nasty cases. One of the worst is the ‘ov’ instruction. It performs an overflow check on an arithmetic (add, mul, sub, neg) operation.
Here’s some example LIR that uses ‘ov':
ld6 = ld sp[-8]
add1 = add ld6, 1
ov1 = ov add1
xt4: xt ov1 -> pc=0x883ed8 imacpc=0x0 sp+0 rp+0 (GuardID=218)
The first instructions loads a value from the stack. The second instruction adds 1 to that value. The third instruction performs an overflow check and puts the result in ‘ov1′. The fourth instruction is a guard; if ‘ov1′ is true it exits the code block.
So why is ‘ov’ semantically nasty? First consider ‘add’, which is a semantically cleaner instruction. Its result (in this case ‘add1′) is a function of its inputs (‘ld6′ and 1). In comparison, ‘ov’ does not have this property. The ‘ov’ doesn’t really take ‘add1′ as an input — you can’t tell by looking at ‘add1′ whether the addition overflowed. In fact you can’t really understand what is happening here at the LIR level; you have to know what happens in the native code that is generated from this LIR. It turns out that the native code for the ‘add’ also sets some condition codes, and the native code generated for the ‘ov’/’xt’ pair inspects those condition codes. For this to work, the ‘add’ has to immediately precede the ‘ov'; if it does not, whatever intermediate native code that is generated could overwrite the condition codes, in which case the behaviour of the guard becomes completely unpredictable. This is obviously bad.
The real problem is that the addition has two outputs: the result, and the overflow status indicator (which maps to condition codes in the hardware). But LIR has no explicit way to represent that second output. So the second output is implicit, and an extra constraint must be imposed on the LIR instead, i.e. ‘ov’ must immediately follow an arithmetic operation. Because this constraint is so arbitrary it’s easy to forget and easy to break.
In May 2009 Julian Seward opened a bug to improve LIR’s semantics, giving five suggestions. It generated a lot of discussion and Julian drafted a patch to replace ‘ov’ with some cleaner opcodes, but there was enough disagreement that it never went anywhere. But I didn’t forget about it, and ‘ov’ has annoyed me enough times recently that I decided to resurrect Julian’s idea, this time in a new bug to escape the baggage of the old one. The idea is simple: if ‘ov’ always has to follow an arithmetic operation, then why not create new opcodes that fuse the two parts together? These new opcodes are ‘addxov’, ‘subxov’ and ‘mulxov’. With my patch the code from above now looks like this:
ld6 = ld sp[-8]
add1 = addxov ld6, 1 -> pc=0x883ed8 imacpc=0x0 sp+0 rp+0 (GuardID=218)
The ‘addxov’ adds ‘ld6′ and 1, puts the result in ‘add1′, and exits if there was an overflow. The generated native code is unchanged, but the implicit output of the addition is now hidden within a single LIR instruction, and it’s impossible for overflow checks in the native code to become separated from the potentially-overflowing arithmetic operation.
Weapon 2: strong IR sanity checking
Compilers are usually built in a pipeline fashion, where you have multiple passes over the code representation, and each pass does a task such as optimisation, register allocation or code generation. It’s also a really good idea to have a pass that does a thorough sanity check of the code representation.
In November 2008 Jim Blandy filed a bug suggesting such a pass for Nanojit, one that performs type-checking of the LIR. The bug sat untouched for over six months until some extra discussion occurred and then (once again) Julian wrote a patch. It found at least one case where TraceMonkey was generating bad LIR code, but again the bug stalled, this time because we spent three months merging Mozilla’s and Adobe’s copies of Nanojit. I resurrected the bug again recently and added some “structure checking” for things like the ‘ov’ constraint, and it landed in the TraceMonkey repository on January 21st. Happily, my version of the checker was simpler than Julian’s; this was possible because LIR had had some other semantic clean-ups (e.g. properly distinguishing 64-bit integers from 64-bit floats). My patch replaced a very basic type-checker (called “SanityFilter”) that had been in TraceMonkey, and immediately found two bugs, one of which involved ‘ov’.
It’s not often that a bug report involving your code makes you smile. Yesterday Gary Kwong hit an assertion failure in Nanojit when fuzz-testing:
LIR structure error (end of writer pipeline):
in instruction with opcode: ov
argument 1 has opcode: add
it should be: located immediately prior, but isn't
One way to debug this: change the failing NanoAssertMsgf(0, ...) call to a
printf(...) call and rerun with verbose output. If you're lucky, this error
message will appear before the block containing the erroneous instruction.
In other words, there’s an ‘ov’ following an ‘add’, but there are one or more other LIR instructions between them. This means that the code generated will be bogus, as I explained above. This bug may have been in TraceMonkey for a long time, but it wasn’t detected until strong internal sanity checking was added. The good news is that the ‘ov’-removal patch (which hasn’t landed as it’s still awaiting review) will fix this patch.
This story tied together a number of related ideas for me. In particular:
- Clean IR semantics are worth the effort. Hacks may save time initially but they will come back to bite you.
- Strong IR sanity checking is worth the effort. (And cleaner semantic allows for stronger checking.)
- Listen to Julian, especially when he talks about correctness. (And read his code! VEX/pub/libvex_ir.h in the Valgrind source code describes Valgrind’s IR, which is a wonderfully clean IR, particularly in the way it separates statements (which have side-effects) from expressions (which don’t).)
- Don’t put too many ideas into one bug report. Too much discussion can kill a bug, or at least put it in a coma.
- Follow-through is important. A patch can’t do much good unless it lands.
- Fuzz testing is awesome (but we already knew that).