Final Project

Due: 5 pm., Friday, December 11, 1998

Assignment

Your assignment is to develop a compiler from Tiger (as specified in one of Appel's Tiger books) to a ``straight-line intermediate-representation code'' (hereafter referred to as IRT) which is described in the next section. IRT is a simplified assembly code, which is quite similar to the intermediate representation trees given in the Appel book.

In order to complete the translation, your program should:

• Tokenize the input characters;
• Parse the input, creating an abstract syntax tree;
• Type-check the abstract syntax tree;
• Construct appropriate frames (I'll provide IRTframe.{c,java});
• Translate the abstract syntax tree to an intermediate representation tree;
• Put the intermediate representation tree in canonical form (Appel provides a program for doing this);
• Flatten any deep expressions in the intermediate representation tree; and
• Turn the converted intermediate representation tree into a textual version of the instructions (I'll provide a program to do this).

You will then interpret the textual instructions using an IRT interpreter that I will write (in Perl, for portability).

It is not clear when all of the helpers will be ready, so you should be prepared to go ahead using only ``stubs'' for the various parts. I will definitely have the various things ready Monday after Thanksgiving.

You need not implement the built-in functions.

Architecture

Code Format

A few forms of memory locations are accepted:

• R(num): register number num
• M(num): memory location num
• M(R(num): the memory location given by the contents of register number num
• L(label): the address associated with a particular label

The valid commands are:

• CALL label mem1 mem2 ... memn
  • Call a function given by a particular label, passing the given arguments (which are copied to the appropriate registers).
  • The result is stored in the ``result register'' (RV).
  • Arguments are separated by spaces.
• RETURN
  • Return from a called function.
  • Does little more than a branch to the address stored in RA.
• BUILTIN name mem1 mem2 ... memn
  • Call a built-in function.
  • The result (if any) is stored in the ``result register'' (RV).
• MOVE memdest memsource
  • Move one word from the source to the destination. The source can be a memory location (as above) or an integer constant (which is just written as the number).
• JUMP mem label-list
  • Jump to one element of label-list based on the value stored in the given memory location.
• CJUMP op mem mem label
  • Jump to the label only if the operator applied to the contents of the two memory locations results in a true value.
  • Valid operations are LT, LE, GT, LE, EQ, and NE.
  • The arguments can either be memory locations or integer constants.
• BINOP op mem mem
  • Compute a binary operation, storing the results in the accumulator (a designated register).
  • The arguments can either be memory locations (described above) or integer constants.
  • Valid operations are as given in Appel and include PLUS, MINUS, MUL, DIV, AND, and OR.
• LABEL label
  • Label a piece of code.
• STRING string
  • A string stored in memory. Used along with LABEL and L(label).
• NOOP
  • Do nothing. May be useful as a placeholder.
• END
  • End the program.

Registers

• R(0): the value 0.
• R(1): the program counter. You can also (and should) use PC.
• R(2): the stack pointer. You can also (and should) use SP.
• R(3): the frame pointer. You can also (and should) use FP.
• R(4): the heap pointer. You can also (and should) use HP.
• R(5): the accumulator. You can also (and should) use ACC.
• R(6): the return value from function calls. You can also (and should) use RV.
• R(7): the return address for function calls. You can also (and should) use RA.
• R(8) and R(9): reserved for future use
• R(10) through R(19): the arguments for a function call. Function calls with more than ten arguments are not allowed. You can also (and should) use A0 through A9.
• R(20) through R(maxint): for program use.

Calling Conventions

The CALL instruction copies all of the values to the appropriate registers and then branches to the appropriate label. It is the callee's responsibility to move values from those registers to other registers or to locations in memory. (The code given by IRTFrame will handle the parameters, but not the return address.)

If your functions call other functions, you will need to handle the code for storing values in possibly-changed registers within the current frame. The IRTFrame module will provide an inRegisters method that lists all registers used within the module.

Built-in Functions

You can call any of the built-in functions given as part of the Tiger standard library by using the name given in the Tiger language description. In addition to the given functions, there is also a printInt function for printing integers.

Sample IRT Programs

Here is a program that multiplies two and three and prints the result.

BINOP MUL 2 3
BUILTIN printInt ACC
END

Here is a program that that prints the string "Hello".

BUILTIN print L(L123)
END
LABEL L123
STRING Hello

Here is a program that reads two characters and prints the one with the larger ordinal value.

BUILTIN getchar
MOVE R(21) RV
BUILTIN ord R(21)
MOVE R(22) RV
BUILTIN getchar
MOVE R(23) RV
BUILTIN ord R(23)
MOVE R(24) RV
CJUMP GT R(22) R(24) L101
LABEL L100
BUILTIN print R23
JUMP 1 L102
LABEL L101
BUILTIN print R21
LABEL L102
END

Here is a program fragment that multiplies the contents of register 22 by 3

BINOP MUL R(22) 3
BUILTIN printInt ACC
END

Here is a program the prints numbers from 1 to ???

# Loop forever, printing numbers from 1 to maxint
BINOP PLUS 0 1
LABEL loop
BUILTIN printInt ACC
BUILTIN print L(cr)
BINOP PLUS 1 ACC
JUMP L(loop)
END
LABEL cr
STRING \n

More programs forthcoming.

Sample Tiger Programs

Forthcoming. Please send me some of your own suggestions.

Extra Credit

You can obtain extra credit by doing any or all of the following:

• Translate to real assembly code, rather than IRT (this is a signficiantly harder assignment, and will garner you large amounts of extra credit);
• Correctly determine which parameters and local variables escape;
• Do improved register allocation;
• Feel free to suggest other extra-credit components.

History

• November 18, 1998: First version.
• November 20, 1998: Updated the description of memory referents to permit use of registers and constants
• November 23, 1998: Added NOOP.
• November 25, 1998: Added BUILTIN and RETURN. Clarified separation of arguments to functions. Added register 0.