JIT 编译器中的代码生成是否会生成更好的本机代码？

Question

I'm researching about JVM and JIT compiler, and want to figure out what difference between traditional compiler like gcc and JIT compiler.

I know JIT compiler will investigate the hotspot of a code, and compile the instructions to machine code to improve the performance.

But in the situation below:

Q = a / b;
R = a % b;

In traditional compiler, this code will be translated to a single division if the hardware has the operator.

But does the JIT compiler do the same thing as traditional compiler?

the interpreter like JVM executes the bytecode one by one line. If the division and modulo above are the hotspot, does JIT compiler compile it to one single machine code to get the value? or just compile them to two divisions?

In my point, maybe the javac will do some optimizations first and then do the JIT jobs. But I do the experiment below:

javac test.java
javap -c test.class

and it prints out the bytecode. I can see there are irem and idiv in the bytecode. Then I know there is not such a pre-optimization or any else.

Answer 1

There is no fundamental difference between an offline compiler and a JIT compiler as both transforms code from a more abstract representation (eg source code or byte code) into a more concrete representation (most commonly native code).

The main difference is in the trade offs when deciding on what optimizations to perform and the information present when performing the optimizations. In an offline compiler you can, typically, spend more time on optimizing the code as this is done once and for all and a long compile time will not impact on the performance of your program. On the other hand an offline compiler often know very little about how a program is used and must guess which paths are hot and which loops are tight.

A JIT compiler on the other hand is run on demand by the runtime system of the language while the program is running, this implies that the compile time is amortized over runtime of the program and a slow compiler will impact its performance. On the other hand it a JIT compiler can know more about the runtime behavior of the program and direct its effort to hot paths and tight loops.