CS 374 Compilers Homework #7

Note: This work is to be done in assigned groups.  Each group will submit one assignment.  Although you may divide the work, both team members should be able to present/describe their partner's work upon request. 

Code Generation - Part II

At this point, we can generate code that prints compound arithmetic and logical expressions.  However, the main method of MiniJava doesn't allow us to declare variables (rats!).  In order to do so, we need to be able to (1) allocate new objects, (2) generate code for a method call, and (3) generate stack frame push/pop code for methods.  Our first goal is to create a trivial object with a single method that returns 123, call this method, and print the returned value.

1. Symbol Table Additions: You'll want to add to your symbol table such that it will be easy to:

• Return a unique integer for each class.
• Compute the size of an object (i.e. find out how many fields it has).  Don't forget inheritance!
• Given a class and field name, return the offset (in words) of that word in the object.  If you put superclass fields before subclass fields, such that a field is always in the same position, you'll simplify polymorphic behaviors.
• Given a class name and method name, return the class in which the method is defined.  For example, suppose class B extends A which defines method f.  If B does not override A's method f, then A will be the class returned given B and f.

2. Memory Allocation: Create a helper method alloc(int) in your translator that generates code to dynamically allocate the given number of words.  Syscall 9, given a number of bytes will do this for you conveniently.  Finally, clear the memory.  That is, set each allocated position to 0.

3. NewObject:  Each object will consist of an integer identifier and a certain number of fields.  Use the previous additions to generate code that allocates the needed memory and places the address of the allocated memory in $v0.

4. Simplified Call:  Add a field to syntaxtree.Call to keep track of the type of the object in the call.  Set this field at the appropriate point in your type-checking code.  Call this the call class.  (Note that the calling object may actually be of a different subclass.)  Use your symbol table to look up which method defining class actually defines the method for the call class.  Assume the method occurs at a label "<method defining class>.<method name>".  Now you can implement code generation for this simplified Call:

• Generate code to compute the address of the call object.
• Grow the stack (i.e. subtract from $sp) to hold n arguments, where n is the greater of 4 and (number of method arguments + 1).
• At $sp offset 0, put the address of the calling object.
• Compute each argument left-to-right, placing them at successive positions allocated in the stack.
• After completing this, put the first arguments from the stack to registers $a0-$a3 to respect calling conventions.  (We'll use the stack copies in practice.)
• Add 16 bytes (4 words) from the $sp to respect calling conventions.
• Make the jump to the appropriate method address label.
• Add the necessary amount to return $sp to its original position before the call.

5. Tracking Scope, ClassDeclSimple, ClassDeclExtends, MethodDecl:  As in type-checking, it is important to track your scope in code generation.  Add fields to your class to track the current class and method.  Set these fields in the appropriate visitor methods.

6. Method Generation:  In MethodDecl,

• Emit a label of the form <current class name>.<method name>.
• Compute the number of local variables in the method, and move the stack pointer to make space for these, the old frame pointer  $fp, and the return address $ra.
• Store the old frame pointer and return address to the stack frame.
• To respect calling conventions, store the contents of $a0-$a3 to the stack frame (redundant for our purposes).
• Set the new frame pointer.
• Generate the code for all statements.
• Generate the code to compute the return value (which is placed in $v0).
• Load the old frame pointer $fp and return address $ra from the stack frame.
• Pop the stack frame (i.e. add the appropriate amount to $sp).
• Jump to the return address.

You can now test your generated object creation and method call code with NewObject.java.

7. This: This, the address of the current object, will always be at the same position of the stack frame.  Emit code to load the address of "this" from the stack from into $v0.

8. Identifier: Load the address of the given identifier into $v0.  This is handled in three cases:

• Local variable: Compute the address of the local in the stack frame ($fp plus an offset) and put that address in $v0.
• Parameter variable: Compute the address of the parameter in the stack frame ($fp plus an offset) and put that address in $v0.
• Field case: Load the address of "this" into $v0 as you did for syntaxtree.This.  Then add the appropriate offset to that address such that $v0 holds the address of the given field.

9. IdentifierExp:  This is similar to Identifier, except that instead of loading the address of the identifier, load the value stored in the identifier.  Instead of simply leaving the address of the identifier in $v0, you'll want to load the value at that address into $v0.

10. Assign: In Assign,

• Emit the code for the assignment's expression.
• Push $v0 to the stack
• Emit the code for the assignment's identifier.
• Pop from the stack to $v1
• Store $v1 to the address of $v0 (offset 0).

You can now test your generated code with Factorial.java.