Lab 10: More Code Generation
Overview
In this lab, you extend your code generator to handle expressions, statements, methods without local parameters, and classes without fields.
Overview
Objectives
- Write MiniJava programs and corresponding Jasmin programs which cover the following constructs:
- all kinds of unary and binary expressions,
- object and array creation,
this
expressions,- method calls without arguments,
- block statements,
if
statements,while
statements,- methods without parameters and local variables,
- classes without fields.
- Extend your code generator to handle these constructs.
Submission
You need to submit your MiniJava project with a merge request against branch assignment-10-submission
on GitLab.
The Git documentation explains how to file such a request.
The deadline for submissions is December 21, 2019, 23:59. The extended deadline is January 11, 2020, 23:59, for a penalty of 1 point.
Grading
You can earn up to 65 points for your code generator:
- transformation (55 points)
- classes (8 points)
- methods (7 points)
- statements (13 points)
- block statements (2 points)
if
statements (5 points)while
loops (6 points)
- expressions (22 points)
- logic constants (1 point)
- unary expressions (5 points)
- binary expressions (14 points)
- object and array creation (1 point)
this
expressions (1 point)- method calls (5 points)
- inheritance (5 points)
- challenge (10 points)
- stack limits (10 points)
Early Feedback
We provide early feedback for the transformation part and the stack limits challenge. You have 3 early feedback attempts.
Detailed Instructions
Git Repository
You continue with your work from the previous assignment.
See the Git documentation on how to create the assignment-10-develop
branch from your previous work.
Write More Jasmin Code
Before you extend your code generator, you should come up with small example MiniJava programs, which cover the following constructs:
- all kinds of unary and binary expressions,
- object creation,
this
expressions,- method calls without arguments,
- block statements,
if
statements,while
statements,- methods without parameters and local variables,
- classes without fields.
Write corresponding Jasmin programs, which you expect to be the result of a MiniJava-to-Jasmin compiler. Generate Java class files from them and run them. Improve your programs until they run without errors.
Do not write all the MiniJava programs and the corresponding Jasmin code in one go. Instead, you should extend your code generator once you figured out the Jasmin code for a certain construct. This way, you can go back and forth between manually writing Jasmin code and extending the code generator.
Generate Code for Expressions and Statements
You now need to extend stmt-to-jbc
and exp-to-jbc
to cover all statements except assignments.
-
Provide a rule for
stmt-to-jbc
, which translates a block statement from MiniJava into a sequence of Java bytecode instructions. This rule should callstmt-to-jbc
recursively to translate the inner statements to Java bytecode sequences. -
Provide rules for
exp-to-jbc
, which translate logic constantstrue
andfalse
from MiniJava into sequences of Java bytecode instructions. -
Provide rules for
stmt-to-jbc
, which translateif
andwhile
statements from MiniJava into sequences of Java bytecode instructions. These rules should callstmt-to-jbc
recursively to translate inner statements to Java bytecode sequences. The JVM documentation discusses an efficient translation pattern forwhile
loops.These statements require labels. You can apply
newname
from Stratego’s standard library (docs) to a string, to obtain a fresh name starting with the given string. -
Provide rules for
exp-to-jbc
, which translate unary and binary expressions from MiniJava into sequences of Java bytecode instructions. These rules should callexp-to-jbc
recursively to translate subexpressions to Java bytecode sequences. Furthermore, they should call a strategyop-to-jbc
to translate unary and binary operators to Java bytecode instructions. The only exception is the&&
operator, which needs to be treated differently, due to its lazy evaluation semantics.
Interaction with Name and Type Information
To ease code generation, we have made the following name and type information available to your compiler:
- The occurrence of a method declaration has a property
cname
with the name of its surrounding class (same for the occurrence of a field declaration). - The occurrence of a method declaration has the type
MethodType(return-type, parameter-types)
.
The following strategies are useful to query the analysis result:
nabl2-mk-occurrence(|Ns)
applied to a namen
yields an occurrenceNs{n}
.nabl2-get-ast-analysis
applied to any AST term yields the analysis result, which can be used with the following strategies to extract information:nabl2-get-resolved-name(|a)
applied to a reference occurrence yields a tuple(occurrence, path)
. The term parametera
is the analysis result.nabl2-get-property(|a, prop)
applied to an occurrence yields the value of propertyprop
. The term parametera
is the analysis result.nabl2-get-type(|a)
applied to an occurrence yields the type of the occurrence. The term parametera
is the analysis result.
nabl2-get-occurrence-name
applied to an occurrence yields the name of the occurrence.
For more information about these strategies, Ctrl/Cmd-click the nabl2/api
import in your Stratego file.
The following example shows how to use these strategies.
The first rule matches method declarations, gets the analysis result, creates an occurrence from the method declaration name, and retrieves the cname
property of the method.
The second rule matches method calls, gets the analysis result, creates an occurrence from the method reference name, and resolves this to an occurrence of the method declaration which can be used in other query strategies.
method-to-jbc:
Method(t, m, _, _, stms, e) -> ...
with
a := <nabl2-get-ast-analysis>
; dec-occ := <nabl2-mk-occurrence(|"Method")> m
; cname := <nabl2-get-property(|a, "cname")> dec-occ
...
exp-to-jbc:
Call(e, m, _) -> ...
with
a := <nabl2-get-ast-analysis>
; ref-occ := <nabl2-mk-occurrence(|"Method")> m
; (dec-occ, _) := <nabl2-get-resolved-name(|a)> ref-occ
...
Code Generation for Methods
Now you need to define a strategy method-to-jbc
to handle methods without local variables.
-
Provide a rule for
method-to-jbc
, which translates a method without parameters and local variables from MiniJava into a Jasmin method. This rule should callstmt-to-jbc
to translate the statements of the method to a Java bytecode sequence. -
Provide a rule for
exp-to-jbc
, which translatesthis
expressions from MiniJava into sequences of Java bytecode instructions. -
Provide a rule for
exp-to-jbc
, which translates method calls without arguments from MiniJava into sequences of Java bytecode instructions. This rule should callexp-to-jbc
recursively to translate subexpressions to Java bytecode sequences.For this rule, you need to know the name of the class containing the method and the type of the method. Read the instructions above on how to use name and type information.
-
Extend the rule for
class-to-jbc
, which handles classes, in order to include code generation for methods. -
Provide a rule for
exp-to-jbc
, which translates object creation expressions into sequences of Java bytecode instructions.
For grading, if you decide not to participate in the challenge, use a fixed stack size of 99 for both static and non-static methods.
Testing and Debugging
Testing and debugging your compiler is the same as the previous lab. Refer to the section on Testing and Debugging from assignment 9.
Challenges
Challenges are meant to distinguish excellent solutions from good solutions. Typically, they are less guided and require more investigation and programming skills.
Precise Stack Limit Directives
A stack limit directive tells the Java Virtual Machine the maximum number of elements at the operand stack.
To give a precise limit, you need to write a strategy stack-limit
that maps MiniJava expressions and statements to a stack limit.
Do not do this analysis on the Java bytecode level.
For expressions, you need to consider the number of elements already on the stack before the expression is evaluated. You can either pass this number as a term parameter or adapt intermediate results accordingly. For statements, you do not need this information since statements should not leave any elements on the stack.
The following strategies might be useful:
inc
rewrites an integer number to its successor.max
rewrites a pair of integer numbers to the maximum of both numbers.addi
rewrites a pair of integer numbers to the sum of both numbers.foldr(s1, s2, f)
right-folds a list.s1
yields the starting point of the folding,s2
is the folding strategy, andf
is applied to each element just before each folding step.
You should test your stack limit implementation by writing SPT tests as follows:
test stack limit [[
class Main {
public static void main(String[] args) {
System.out.println([[1]]);
}
}
]] run stack-limit on #1 to ??
For grading it is important that your strategy stack-limit
does not take any parameters. You are free to use parameters in strategies that you call yourself.
For grading it is important that your strategy stack-limit
operates on expressions, statements, and lists of statements.