There is a tension in dynamic language runtime design between speed
and correctness. State-of-the-art JIT compilation, the result of
enormous industrial investment and significant research, achieves
heroic speedups at the cost of complexity. This complexity leads to
subtle and sometimes catastrophic correctness bugs. Much of this
complexity comes from the existence of multiple tiers and the need to
maintain correspondence between these separate definitions of the
language's semantics; it also comes from the indirect nature of the semantics
implicitly encoded in a compiler backend. One way to address this
complexity is to automatically derive, as much as possible, the
compiled code from a single source-of-truth, such as the interpreter
tier. In this work, we introduce a partial evaluator that can compile
a whole guest-language function ahead-of-time, without tracing or
profiling, ``for free.'' This transform unrolls an interpreter
function expressed in a standard compiler intermediate representation
(static single assignment or SSA) and uses partial evaluation of the
interpreter function and its regular control flow to drive the
guest-language compilation. The effect of this is that the transform
is applicable to almost unmodified existing interpreters in systems
languages such as C or C++, producing ahead-of-time guest-language
compilers. We show the effectiveness of this new tool by applying it
to the interpreter tier of an existing industrial JavaScript engine,
SpiderMonkey, yielding $2.17\times$ speedups, and the PUC-Rio Lua
interpreter, yielding $1.84\times$ speedups. Finally, we outline an
approach to carry this work further, deriving more of the capabilities
of a JIT backend from first principles while retaining correctness.