This is a great example of going from AOT to JIT specializing function calls by types.
I assume this intended at a class which has already finished writing an AOT compiler and wants to build faster functions than you can derive at a compile time.
> On the first call to a function, the compiler calls compile_me, which reconstructs argument types from their tag bits and builds a temporary type environment. The function body is then optimized using those concrete argument types.
It's been two decades since I have worked on Rhys's brilliant libjit and the work that came before it[1], but the first-call recompilation can mix well with a byte code interpreter as well.
You still need to be able to JIT a whole function with the first-call recompiler here, but you can do even more incremental if you are pairing it with an interpreter which gets to pick up the slack of the JIT.
For example, with an interpreter, I could JIT about ~15% of a function and incrementally implement one opcode at a time without handling the complex ones on day one.
The switch loop with direct threading can jump into a JIT block or the next instruction's compiled location, in identical fashion. So you get to operate register to register for adjacent instructions being JIT'ed together, but write back to heap for the interpreter to take over for an unsupported one.
This is referred to as unrolling in the impl there, because what it really does is partially unroll the for(op in ops) loop and skip the jump to the top when you see a sequence of ops which you can line up together and JIT once.
> I assume this intended at a class which has already finished writing an AOT compiler and wants to build faster functions than you can derive at a compile time.
Quick answer just to this part: So the design challenge I was trying to solve here was doing AOT+JIT in one ugrad compilers class. This eats into some of the later assignments, but actually “worked”, in the sense that many students wrote first-call specialization.
I've linked to course sites in the past (@UW) and they were summarily blocked. Hopefully that doesn't happen.. If you go to Prof. Politz's personal site you might find some course info for CSE131.
This is a great example of going from AOT to JIT specializing function calls by types.
I assume this intended at a class which has already finished writing an AOT compiler and wants to build faster functions than you can derive at a compile time.
> On the first call to a function, the compiler calls compile_me, which reconstructs argument types from their tag bits and builds a temporary type environment. The function body is then optimized using those concrete argument types.
It's been two decades since I have worked on Rhys's brilliant libjit and the work that came before it[1], but the first-call recompilation can mix well with a byte code interpreter as well.
You still need to be able to JIT a whole function with the first-call recompiler here, but you can do even more incremental if you are pairing it with an interpreter which gets to pick up the slack of the JIT.
For example, with an interpreter, I could JIT about ~15% of a function and incrementally implement one opcode at a time without handling the complex ones on day one.
The switch loop with direct threading can jump into a JIT block or the next instruction's compiled location, in identical fashion. So you get to operate register to register for adjacent instructions being JIT'ed together, but write back to heap for the interpreter to take over for an unsupported one.
This is referred to as unrolling in the impl there, because what it really does is partially unroll the for(op in ops) loop and skip the jump to the top when you see a sequence of ops which you can line up together and JIT once.
[1] - https://mirror.linux.org.au/pub/linux.conf.au/2003/papers/Rh...
[2] - https://docs.rs/gnu-libjit/latest/gnu_libjit/struct.Function...
> I assume this intended at a class which has already finished writing an AOT compiler and wants to build faster functions than you can derive at a compile time.
Quick answer just to this part: So the design challenge I was trying to solve here was doing AOT+JIT in one ugrad compilers class. This eats into some of the later assignments, but actually “worked”, in the sense that many students wrote first-call specialization.
I'm very interested in reading this and checking out the associated course site.
Also, I'm taking opportunities to link to relevant sections in SICP, so some suggested reading:
5.5 Compilation
https://sarabander.github.io/sicp/html/5_002e5.xhtml#g_t5_00...
https://ucsd-cse131-fa25.github.io is the version for this course.
My homepage has a number of flavors of that course (Rust, Ocaml, AOT, JIT, etc)
https://jpolitz.github.io
Sorry, can you provide the link to the course? I was not able to find it.
I've linked to course sites in the past (@UW) and they were summarily blocked. Hopefully that doesn't happen.. If you go to Prof. Politz's personal site you might find some course info for CSE131.
https://ucsd-cse131-fa25.github.io/
Really cool. I haven't read it but I'm familiar with some of the authors so I expect this to be good.
Yes. Nice work from Joe Politz et al at UCSD and Nico Lehmann at U Chile.
Do you know if there was video of the talk?
https://icfp26.sigplan.org/home/scheme-2026#program
Yes, the video is here: https://www.youtube.com/watch?v=8qwXgappTWQ