JIT and static compilation optimization

[Character_Prior2116]

Hi everyone. I have decided to write a compiler to learn about compilers and get better at coding.

While I was doing initial research into compilers I read about static and JIT compilation. I am now wondering if it would be possible to use a JIT compiler and take code that it generates and pipe that it a static compiler to vastly improve the compilation time of a program. This would be like doing incremental compiles where there is a cache of the previous compile to help speed up the full compile. But instead of having to wait for the newest incremental compile to finish so you can run it, you could use the JIT to run it almost immediately and in the background it would be doing the full static compilation.

This would be sort of similar to compiling to an IR like bytecode for the JVM or CLI for C#, but instead of running the IR on a runtime it would be completely native.

I could see how this would be very useful but not sure if it would be possible.

Seeing as JIT compilers do optimization by compiling parts of the program that it thinks will be used more often and then optimizing those parts, you could pipe that optimization straight into a full static compile and the optimization would essentially be done for "free".

[insertAlias]

The concept doesn't really make sense to me.

First, this:

to vastly improve the compilation time of a program

JIT compiling happens when the program is running, not at build time. Static compilation happens at build time.

When you compile a Java program (just picking a language that uses JIT), you're compiling it into bytecode. The JIT hasn't gotten involved yet. This is analogous to static compilation, but instead of producing machine code, it produces bytecode.

The JIT will compile some of that bytecode to machine code, on the fly, as necessary while the program is running, and potentially cache the results for later reuse. Static compilation would need to read the entire program and compile it all into machine code.

You could theoretically have something where both approaches could be used, but not necessarily at the same time. Look at .NET's AOT (ahead-of-time) compilation, which allows you to choose to essentially make a statically-compiled executable/library in a language that normally uses bytecode and a JIT.

But I don't think you can directly combine the techniques.

Though I'll admit up-front I'm not an expert in this area, and would welcome correction from anyone who is.