Compiler generated code: Investigations

Got it! This site uses cookies. You consent to this by clicking on "Got it!" or by continuing to use this website.nbsp; Note: This appears on each machine/browser from which this site is accessed.

c go java js lua py vbs rkt scm pro

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.

public class goto15_01 {

	public goto15_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 goto15_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.

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.

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