Compiler generated code: introduction

Suppose one has the following.

n programming languages
m target machines

To have each of n programming language compile and run on each of m target machines takes n*m compilers.

For 4 programming languages and 4 target machines, this is 16 compilers with target machine code generation.
For 10 programming languages and 10 target machines, this is 100 compilers with target machine code generation.

A compromise is as follows.

Create an intermediate representation code.
Create a compiler for each language to that intermediate code.
Create a intermediate code interpreter or code generation for each target machine.

The improvement is as follows.

For 4 programming languages and 4 target machines, this is 4 compilers and 4 target machine interpreters
For 10 programming languages and 10 target machines, this is 10 compilers and 10 target machine interpreters.

Some of these intermediate code machines include the following.

UCSD Pascal (1970's which influenced others used what was called P-Code)
Java byte-code machine, the JVM (Java Virtual Machine)
DotNet byte-code machine, the CLR (Common Language Runtime)
Python byte-code
Lua byte-code
... and so on ...

A compiler translates a programmer-friendly source program into a machine-friendly object program that can be executed on a computer.

Traditional compilers generate code for a processor (e.g., microprocessor).

C++ to Pentium
C++ to PowerPC
C++ to ...

JIT (Just In Time) compilers generate an abstract intermediate byte code that is compiled on-the-fly as it is needed for the architecture that the code is running on.

Java -> int. code -> Pentium
.NET -> int. code -> Pentium

The Java JIT compiler compiles the Java byte-codes as they are received into binary machine code that executes faster than the interpreted Java byte-codes. What is the Java JIT compiler and why is it important?

JIT compilers have allowed the compiled code of programming languages such as Java to be both portable and fast when compared to traditional compiled code which will run only on one particular platform (i.e., processor and operating system).

We use the javac compiler to transform java source text (legible) code in a java file to java object (illegible) code in a class file.

We can use the javap disassembler to see a text representation of the java class file.

In the .NET architecture, source code is compiled to an intermediate code called MSIL (Microsoft Intermediate Language), also called meta-data. The meta-data approach avoids the need for information stored in the registry.

In the .NET architecture the CLR manages the code for the system. When requested, the CLR compiles the intermediate code to binary code for the processor on which the code will run. This concept is called managed code. Code run outside of the CLR is called unmanaged code. The CLR is similar in principle to the JVM which uses a JIT compiler.

In the original C language, and many languages that have C-like syntax, there are (at least) three ways to increment a variable (by 1). Assume the variable is an integer called count1. Here are three ways.

count1++; count1 += 1; count1 = count1 + 1;

One sometimes wants to look at the generated code to see how statements might be written to run faster (i.e, by taking fewer statements)

Here is the Java code [#1]

public class goto12_01 {
	public goto12_01() {
		int count1 = 0;
		count1++;
		count1 += 1;
		count1 = count1 + 1;
		System.out.print(String.format("count=%d\n",count1));
		}
	public static void main(String [] args) {
		new goto12_01();
		}
	}

Here is the output of the Java code.

count=3

From the relevant generated code, we see the following. Here is the Java source code fragment.

count1++; count1 += 1; count1 = count1 + 1;

Here is the generated byte-code separated into groups for each source code statement.

// count1++ 6: iinc 1, 1 // count1 += 1; 9: iinc 1, 1 // count1 = count1 + 1; 12: iload_1 13: iconst_1 14: iadd 15: istore_1

The first two source code statements generate the same code. The last one generates more code - involving a load and a store. (Some compilers would improve the generated code).

Python does not have the "++" increment operator.

Here is the Python code [#1]

import dis
def countTest1():
	count1 = 0
	count1 += 1
	count1 = count1 + 1
	print("count={0:d}".format(count1))
dis.dis(countTest1)

Here is the output of the Python code.

  4           0 LOAD_CONST               1 (0)
              2 STORE_FAST               0 (count1)
  5           4 LOAD_FAST                0 (count1)
              6 LOAD_CONST               2 (1)
              8 INPLACE_ADD
             10 STORE_FAST               0 (count1)
  6          12 LOAD_FAST                0 (count1)
             14 LOAD_CONST               2 (1)
             16 BINARY_ADD
             18 STORE_FAST               0 (count1)
  7          20 LOAD_GLOBAL              0 (print)
             22 LOAD_CONST               3 ('count={0:d}')
             24 LOAD_METHOD              1 (format)
             26 LOAD_FAST                0 (count1)
             28 CALL_METHOD              1
             30 CALL_FUNCTION            1
             32 POP_TOP
             34 LOAD_CONST               0 (None)
             36 RETURN_VALUE

The code appears to be the same size but has two different instructions.

Let us see how Python compiles an arithmetic expression.

Here is the Python code [#2]

import dis
def exprTest1(u1, v1, w1, x1, y1, z1):
	result1 = (u1 + v1) * ((w1 + x1) * (y1 + z1))
	return result
dis.dis(exprTest1)

The code compiles to and is evaluated by a postfix stack machine.

Here is the output of the Python code.

  4           0 LOAD_FAST                0 (u1)
              2 LOAD_FAST                1 (v1)
              4 BINARY_ADD
              6 LOAD_FAST                2 (w1)
              8 LOAD_FAST                3 (x1)
             10 BINARY_ADD
             12 LOAD_FAST                4 (y1)
             14 LOAD_FAST                5 (z1)
             16 BINARY_ADD
             18 BINARY_MULTIPLY
             20 BINARY_MULTIPLY
             22 STORE_FAST               6 (result1)
  5          24 LOAD_GLOBAL              0 (result)
             26 RETURN_VALUE

Below is a counting loop example in Python using a while loop inside a routine called countFromTo1.

The dis module allows disassembly and output of Python byte code from within Python.

Such disassembly is useful for a number of reasons.

One can see the code being generated.
One can improve the generated target code by changing the source code.
One can identify parts of code that are taking a lot of time to run (details omitted).

Here is the Python code [#3]

import dis
def countFromTo1(start1, stop1):
	print("start")
	pos1 = start1
	while pos1 < stop1:
		print("{0:d}".format(pos1))
		pos1 += 1
	print("stop")
dis.dis(countFromTo1)

Here is the output of the Python code.

  4           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 ('start')
              4 CALL_FUNCTION            1
              6 POP_TOP
  5           8 LOAD_FAST                0 (start1)
             10 STORE_FAST               2 (pos1)
  6     >>   12 LOAD_FAST                2 (pos1)
             14 LOAD_FAST                1 (stop1)
             16 COMPARE_OP               0 (<)
             18 POP_JUMP_IF_FALSE       44
  7          20 LOAD_GLOBAL              0 (print)
             22 LOAD_CONST               2 ('{0:d}')
             24 LOAD_METHOD              1 (format)
             26 LOAD_FAST                2 (pos1)
             28 CALL_METHOD              1
             30 CALL_FUNCTION            1
             32 POP_TOP
  8          34 LOAD_FAST                2 (pos1)
             36 LOAD_CONST               3 (1)
             38 INPLACE_ADD
             40 STORE_FAST               2 (pos1)
             42 JUMP_ABSOLUTE           12
  9     >>   44 LOAD_GLOBAL              0 (print)
             46 LOAD_CONST               4 ('stop')
             48 CALL_FUNCTION            1
             50 POP_TOP
             52 LOAD_CONST               0 (None)
             54 RETURN_VALUE

The programming language term "reflection" is used when a program uses code to look at itself, as in the above Python example.

Here is the Java code [#2]

public class goto12_02 {
	public void countFromTo1(int start1, int stop1) {
		System.out.print("start\n");
		int pos1 = start1;
		while (pos1 < stop1) {
			System.out.print(String.format("%d\n",pos1));
			pos1++;
			}
		System.out.print("stop\n");
		}
	public goto12_02() {
		countFromTo1(1,10);
		}
	public static void main(String [] args) {
		new goto12_02();
		}
	}

Here is the output of the Java code.

start
1
2
3
4
5
6
7
8
9
stop

Below is the disassembled Java byte code.

The Java source file is goto13_01.java
The target class file is goto13_01.class (input for javap)
The disassembled text file goto13_01.txt (output of javap)

The command is as follows (assuming proper paths) and using pipes at the command line.

javap < goto13_01.class >! goto13_01.txt

Compiled from "goto13_01.java"
public class goto13_01 {
  public void countFromTo1(int, int);
    Code:
       0: getstatic     #1                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #2                  // String start\n
       5: invokevirtual #3                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V
       8: iload_1
       9: istore_3
      10: iload_3
      11: iload_2
      12: if_icmpge     43
      15: getstatic     #1                  // Field java/lang/System.out:Ljava/io/PrintStream;
      18: ldc           #4                  // String %d\n
      20: iconst_1
      21: anewarray     #5                  // class java/lang/Object
      24: dup
      25: iconst_0
      26: iload_3
      27: invokestatic  #6                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      30: aastore
      31: invokestatic  #7                  // Method java/lang/String.format:(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;
      34: invokevirtual #3                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      37: iinc          3, 1
      40: goto          10
      43: getstatic     #1                  // Field java/lang/System.out:Ljava/io/PrintStream;
      46: ldc           #8                  // String stop\n
      48: invokevirtual #3                  // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      51: return
  public goto13_01();
    Code:
       0: aload_0
       1: invokespecial #9                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_1
       6: bipush        10
       8: invokevirtual #10                 // Method countFromTo1:(II)V
      11: return
  public static void main(java.lang.String[]);
    Code:
       0: new           #11                 // class goto13_01
       3: dup
       4: invokespecial #12                 // Method "<init>":()V
       7: pop
       8: return
}