tutorial 3: code generation

Tutorial Code Generation

Compiler Construction1

S C I E N C E ■ P A S S I O N ■ T E C H N O L O G Y

u www.tugraz.at

Tutorial 3: Code Generation

Univ.-Prof. Dr. Franz Wotawa, DI Roxane Koitz,

Stephan Frühwirt, Christopher Liebmann, Martin

Zimmermann

Institute for Software Technology

Jova Input Program

Java Byte Code

Compiler Phases

Jova Input Program

Java Byte Code

Compiler Phases

Source Code

(*.jova file)Syntax tree

Grammar

(Jova.g4)

Lexer and Parser

Lexical and

syntactical errors

Symbol

visitor / listener

Type checking

errors

Debugging

output

Debugging

output

Workflow (1/2)

Syntax tree

Symbol

Workflow (2/2)

Jasmin code

(.j file)

Byte code

(.class file)

Jasmin

What is Jasmin?

• Assembler for Java bytecode

• Input: <filename>.j file

• contains assembly of the original code

• written in Jasmin assembler language

• Output: executable Java .class file

Pipeline

Create

Assembly

• Produce jasmin assembly

• Result: <filename>.j

Convert

• Invoke “java –jar jasmin.jar <filename>.j“

• Result: <filename>.class

Execute

• Invoke “java <filename>“

• Result: executes main method of class

• One class per .j file

• One statement per line

• Assembly setup:

• Required options

• Methods

• Statements (JVM instructions)

Jasmin syntax

File structure: Class options

▪ .source: Source of assembly▪ e.g.: .source MyClass.jova

▪ .class: Resulting java class description▪e.g.: .class public MyClass

▪ .super: Superclass of resulting java class▪always: .super java/lang/Object

▪ .field: Specify fields of class▪e.g.: .field public my_field I

.method <method signature>

e.g. .method public myMethod(I)V

.limit stack n

n: choose realistic number

.limit locals n

n = #parameters + #local_vars + #temp_var

return

requires matching type on top-of-stack for non-void returns

(e.g. ireturn)

.end method

File structure: Methods

Default Constructor

▪ needs to be defined for every class

▪ since Jova does not have Constructors you can

use the same definition for every class:

.method public <init>()V

.limit stack 1

.limit locals 1

aload_0

invokespecial java/lang/Object/<init>()V

return

.end method

Example: DoNix

File: DoNix.j

.source noSource

.class public DoNix

.super java/lang/Object

.method public static main([Ljava/lang/String;)V

.limit stack 0

.limit locals 1

;nothing to do here

return

.end method

• Two data structures per method (invocation/frame)

• Stack

• Local array

• Operations to manipulate both

• Build-in datatypes

• Primitive Types (int, float, byte, char,…)

• Reference Types (class types, array types,

interface types)

• Very limited support for boolean

Data Management

• Each method has its own operand stack

• Size is definable per method

(just assume a realistic number)

• LIFO

• Stack operations

• Push values onto stack

• Pop/Fetch values from stack

• Instructions which require one or multiple values

on stack (order does matter!)

Data Management: Stack

• Each method has its own local variable array

• Definable size for each method (0-based indices)

• Typing

• Can store arbitrary types

• Items need to be initialized before read access

• Contains

• Method parameters (stored in lowest indices)

• At index 0 the ‘this’ reference

Data Management: Local Variable Array

Data Managment: Types

▪ … a few primitives▪Integer indicated by letter I▪Void indicated by letter V▪Boolean indicated by letter Z

▪ Objects following the format “Lpackage/Classname;“▪e.g. Ljava/lang/String; String object

▪ Array indicated by a leading [▪e.g. [Ljava/lang/String; array of Strings

Instructions

▪ Can involve stack and local array

▪ Most instructions operate on expected types

▪ Instruction template: <T><instr>

where <T> = type letter

<instr> = operation▪ E.g.: iadd, fadd

▪ Instructions which do not operate on specific type▪ E.g.: swap, dup

Instructions: Stack - Locals interaction

▪ iload n pushes integer, stored in index n of

local array, onto stack▪ istore n pops integer from stack and stores it

into index n of local array▪ aload n pushes object, stored in index n of

local array, onto stack▪ astore n pops object from stack and stores it

into index n of local array

Instructions: Constants

▪ sipush n / bipush n

▪Pushes integer constant onto stack▪E.g. sipush 10

▪For m1 - 5 you can also use iconst_<n>

▪ ldc “<string>”

▪Pushes string constant <string> onto stack▪E.g. ldc “Hello World”

▪Note: Strings are Objects (variable access with

astore/aload)

Instructions: Arithmetic Operators

▪ iadd add two integers

▪ isub subtract two integers

▪ imul multiply two integers

▪ idiv divide two integers

▪ irem modulo division of two integers

▪ ineg toggles sign of int on top of stack

Example: BasicInstructions

File: BasicInstructions.j.source noSource

.class public BasicInstructions

.limit stack 3

.limit locals 2

sipush 5 ;push integer 5 onto stack

istore 0 ;pop integer 5 and store in index 0

ldc "Hello i11" ;push string i11 onto stack

astore 1 ;store string in index 1

iload 0 ;load 5

dup ;duplicate stack entry 5

sipush 2 ;push integer 2 onto stack

isub ;pop 5 and 2 and store result 3 onto stack

iadd ;pop 5 and 3 and store result 8 onto stack

istore 0 ;store result 8 in index 0

return

.end method

File: BasicInstructions.j

sipush 5 local array

istore 0

local array

ldc "Hello i11"

local array

astore 1

local array

Hello i11

iload 0

local array

5 Hello i11

local array

5 Hello i11

sipush 2

local array

5 Hello i11

local array

5 Hello i11

local array

5 Hello i11

istore 0

local array

5 Hello i11

return

local array

8 Hello i11

Instructions: Logical Operators

▪ iand bitwise and of two integers

▪ ior bitwise or of two integers

▪ inot does not exist!

▪Note: Needs to be assembled using custom labels and

conditional jump operations

Instructions: Relational Operators

▪ Do not exist!

▪ Need to be assembled using custom labels and

conditional jump operations

Instructions: Labels and Jumps

▪ <labelname>:

▪sets a label in the assembly

▪ goto <labelname>

▪continues execution of current method at position of the

label <labelname>

▪ if_icmpXX <labelname>

▪pops two elements of the stack, relates them and jumps

to <labelname> if comparison computes to true

Instructions: if_icmp variations

▪ if_icmplt relation using <

▪ if_icmple relation using <=

▪ if_icmpge relation using >=

▪ if_icmpgt relation using >

▪ if_icmpeq relation using ==

▪ if_icmpne relation using !=

Example: LabelsAndJumpsFile: LabelsAndJumps.j

.source noSource

.class public LabelsAndJumps

.limit stack 2

.limit locals 2

sipush 10

istore 0 ;store 10 in index 0

goto L_skip_redef

sipush 20

istore 0 ;store 20 to index 0 - skipped

L_skip_redef:

iload 0 ;push value of index 0: 10

sipush 15 ;push 15

if_icmplt L_is_lesser

ldc "greater" ;push string to stack - skipped

goto L_end

L_is_lesser:

ldc "lesser" ;push string to stack

L_end:

; result: string "lesser" on top of stack

return

.end method

sipush 10

local array

istore 0 local array

goto L_skip_redef

sipush 20

istore 0

L_skip_redef:

local array

sipush 20

istore 0

L_skip_redef:

local array

iload 0

local array

sipush 15

local array

if_icmplt L_is_lesser

ldc "greater"

goto L_end

L_is_lesser:

ldc "lesser"

L_end:

local array

ldc "greater"

goto L_end

L_is_lesser:

local array

ldc "lesser"

local array

L_end:

local array

lesser

return

local array

lesser

Instructions: field access

▪ Call put-/getfield of object on stack

▪ Call usingputfield <class ID>/<field ID> <type>

getfield <class ID>/<field ID> <type>

▪ Requires value and object on stack

▪ Example▪Jova-field: public int my_field

▪Jasmin-signature: MyClass/my_field I

▪assembly: putfield MyClass/my_field I

Instructions: non-static method calls

▪ Call method of object on stack

▪ Call usinginvokevirtual <class ID>/<method signature>

▪ Requires parameters and object on stack (in correct

order!)

▪ Example▪method: public int myMethod(int a)

▪Jasmin- sig.: MyClass/myMethod(I)I

▪invokation: invokevirtual MyClass/myMethod(I)I

Instructions: print

▪ Based on virtual invokation

▪ How to:

1. Push PrintStream object onto stackgetstatic java/lang/System/out Ljava/io/PrintStream;

2. Push value onto stack (iload, aload, etc.)

3. Invoke matching PrintStream methodinvokevirtual java/io/PrintStream/print(I)V

invokevirtual java/io/PrintStream/print(Ljava/lang/String;)V

invokevirtual java/io/PrintStream/print(Z)V

▪ Try and write some simple Jasmin code yourselves▪ Use aload_0 to get ‘this’ reference

▪ Number your labels

▪ Map Jova/internal variables to locals array indices▪ Instruction swap/dup may be useful in some cases

▪ Use the online documentation to find additional

instructions/explanations

▪ When in doubt: model a problem in Java - compile it -and use javap -c <Class> to decompile the .class

References:

▪ Jasmin User Guide:

http://jasmin.sourceforge.net/guide.html

▪ The Structure of the Java Virtual Machine:

https://docs.oracle.com/javase/specs/jvms/se8

/html/jvms-2.html

Questions?

tutorial 3: code generation

Documents

rs3 code generation tutorial with isabelle/hol - the

tutorial auto code generation for f2833x … code generation...

tutorial n°5 simulation and control code generation...

production code generation (pcg) time machine€¦ ·...

tutorial g code

mathematica tutorial: random number generation

code saturne tutorial

code generation

tutorial for generating c code from simulink models using...

tutorial for generating c code from simulink models using...

code generation algorithm #2 code generation algorithms #2...

g code tutorial

code generation - secure systems...

building model (lod) generation tutorial

code jsp tutorial

cfd wave generation tutorial

code generation solutions for embedded systems · 12...

digital generation tutorial v1.0

rtl design and ip generation tutorial - xilinxrtl design and...

intermediate code generation intermediate code generation