CPSC 388 Compiler Design and Construction

Code Generation

Code Generation
Global Variables Functions (entry and exit) Statements Expressions

Assume only scalar variables, no arrays (you figure out arrays) Generate MIPS assembly code for Spim http://pages.cs.wisc.edu/~larus/spim.html

Spim Interpreter
spim file <name>
<name> is the name file containing MIPS assembly code Program will run, giving output and errors to screen Also has graphical interface

Some Spim Registers

Register
$sp $fp $ra $v0, $a0 $t0-$t7

Purpose
Stack pointer Frame pointer Return address Used for output and return value temporaries

Helps for Generating Assembly Code

Constants Used
SP, FP, RA, V0, A0, T0, T1, TRUE, FALSE

Methods Used
generate(opcode, arg1, arg2, arg3) generateIndexed(opcode,R1,R2,offset) genPush(R1) genPop(R1) String nextLabel() genLabel(label)

Global Variables
For each global variable, v:
.data .align 2 # align on word boundary .space N

_v:

N is the size of the variable in bytes

int: 4 bytes arrays: 4*(size of array)

Global Variable Example

Give source code
int x; int y[10];

Generate code
.data .align .space .data .align .space
2 4 2 40

_x:

_y:

Code Generation for Functions

For each Function
Function Function Function Function caller) preamble entry (setup AR) body (functions statements) exit (restore stack, return to

Function Preamble
For the main function generate:
.text .globl main main:

All other functions:

.text _<fName>: Where <fname> is the function name

Function Entry
<- SP New AR

<- SP parameters Callers AR

Space for Local vars Control link return add

parameters <- FP

<- FP

Callers AR

Function Entry Steps

Push RA
sw subu $ra, 0($sp) $sp, $sp, 4

Push CL
sw subu $fp, 0($sp) $sp, $sp, 4
$fp, $sp, <size of params +8> $sp, $sp, <size of locals in bytes>

Set FP
addu subu

Push space for local vars

Function Body
FnBodyNode DeclListNode StmtListNode

No need for code from DeclListNode Call codeGen() for statement nodes in StmtListNode

Function Exit
Pop AR Jump to RA field
lw move lw move jr $ra, $t0, $fp, $sp, $ra -<paramsize>($fp) New $fp AR -<paramsize+4>($fp) $t0

<- SP Space for Local vars Control link return add parameters <- FP

Callers AR

Function Returns
Return statement End of function
Two ways to handle this
Generate return code once and have return statements jump to this code (op code is b for branch) Generate return code for each return statement and end of function

Return Statements value

Return statements can return a a value from an ExpNode ExpNodes will push values onto the stack Return statement should pop the top of stack and place return value in register V0 before the rest of return code

Statements
Write a different codeGen() method for each kind of statement in AST Hard to debug assembly code Alternate method:
Write codeGen() for the WriteIntStmtNode and WriteStrStmtNode classes first (maybe one method) Test codeGen() for other kinds of statements and expressions by writing a c- program that computes and prints a value.

Write Statement
Call codeGen for expression being printed
Leaves value on top of stack (if int) Leaves address on top of stack (if String)

Pop top of stack into A0 (register used for output) Set register V0 to
1 of int 4 if String

Generate: syscall

Write Statement Example

myExp.codeGen(); genPop(A0); if ( type is int) generate(li,V0,1); else if (type is String) generate(li,V0,4); generate(syscall);

If Statement
IfStmtNode ExpNode DeclListNode StmtListNode

Two Methods for Generating code

Numeric Method Control-Flow Method

Numeric Method for If Statements

Evaluate the condition, leave value on stack Pop top of stack into register T0 Jump to FalseLabel if T0==FALSE Code for statement list FalseLabel:
Note: Every Label in assembly code must be unique! Im Using FalseLabel but the actual label is generated using genLabel()

You Try It
Write the actual code needed for IfStmtNode What is the form for IfElseStmtNode?
What is the form for WhileStmtNode?

Return Stmt
ReturnStmtNode ReturnStmtNode ExpNode

Call codeGen() for expNode child (leaves result value on stack) Pop value off stack into V0 Generate code for actual return
Pop AR Jump to address in RA

Read Statement
ReadStmtNode ExpNode
Code:
li syscall $v0, 5

Loads special value 5 into register V0, then does syscall. 5 tells syscall to read in an integer and store it back in V0 Need to write code to copy value from V0 back into address represented by ExpNode

ReadStmtNode Examples
int x; int *p; int **q; *q=p=&x; scanf(%d,&x); scanf(%d,p); scanf(%d,*q); All three calls to scanf read in a value into variable x. The value of the expression is the address of x. To store value into address do:
Generate code to compute value of expression (value is pushed onto stack) Pop the value into T0 Store from V0 to address in T0

ReadStmtNode Example
generate(li,V0,5); generate(syscall); myExp.codeGen(); genPop(T0); generateIndexed(sw,V0,T0,0);

Identifiers in Code Generation

Function call (id is name of function)
Need to jump-and-link to instruction using the name of function

Expressions (can be just a name (id) or an id can be one of the operands) Assignment statements (id of lefthand side)

Generate code to fetch current value and push onto stack

Generate code to fetch the address of variable and push address onto stack

IdNode
Needs several methods genJumpAndLink() generate jump and link code for given IdNode codeGen() pushes value of IdNode expression onto stack genAddr() pushes address of IdNode onto stack

genJumpAndLink() for IdNode

simply generate a jump-and-link instruction (with opcode jal) using label as target of the jump. If the called function is "main", the label is just "main". For all other functions, the label is of the form: _<functionName>

codeGen() for IdNode

copy the value of the global / local variable into a register (e.g., T0), then push the value onto the stack Different for local or global variables Examples:
lw $t0 _g // load global g into T0 lw $t0 -4($fp) // load local into T0

How do you tell if variable is local or global? Using Symbol Table

genAddr() for IdNode

load the address of the identifier into a register then push onto the stack Uses opcode for loading address la rather than loading values lw
Different for locals or globals Examples:
la $t0, _g // global la $t0, -8($fp) // local

AssignStmtNode
AssignStmtNode

ExpNode

ExpNode

Push the address of the left-hand-side expression onto the stack. Evaluate the right-hand-side expression, leaving the value on the stack. Store the top-of-stack value into the second-from-the top address.

Expression Node codeGen

Always generate code to leave value of expression on top of stack Literals
IntLitNode, StrLitNode

Function Call Non short-circuited operators Short-circuited operators

IntLitNode
generate code to push the literal value onto the stack Generated code should look like:
li $t0, <value> # load value into T0 sw $t0, ($sp) # push onto stack subu $sp, $sp, 4

StrLitNode
Store string literal in data area Push address of string onto stack Two string lits should be equal if they contain the same characters This means store only a single instance of a string literal no matter how often it appears in user code

Storing String Literals

Code to store a string literal in data area
.data <label>: .asciiz <string value>

<label> needs to be a new label; e.g., returned by a call to nextLabel. <string value> needs to be a string in quotes. You should be storing string literals that way, so just write out the value of the string literal, quotes and all.

Storing Strings Once

To avoid storing the same string literal value more than once, keep a hashtable in which the keys are the string literals, and the associated information is the staticdata-area label. When you process a string literal, look it up in the hashtable: if it is there, use its associated label; otherwise, generate code to store it in the static data area, and add it to the hashtable.

Pushing StrLitNodes onto stack

Generated Code:
.text la $t0, <label> #load addr into $t0 sw $t0, ($sp) #push onto stack subu $sp, $sp, 4

CallExpNode
Since the codeGen method for an expression generates code to evaluate the CallExpNode expression, leaving the value on the stack, all we need to do for step 1 is call the codeGen method of the ExpListNode (which will in turn call the codeGen methods of each ExpNode in the list). For step IdNode ExpListNode 2, we just call the genJumpAndLink method of the IdNode. For step 3, we just call genPush(V0).

Code Should: Evaluate each actual parameter, pushing the values onto the stack; Jump and link (jump to the called function, leaving the return address in the RA register). Push the returned value (which will be in register V0) onto the stack.

Also CallStmtNode
CallStmtNode CallExpNode

IdNode

ExpListNode

CallExpNode pushes value onto stack (may be void, i.e. garbage from V0) CallStmtNode MUST pop value off stack

Non-Short Circuited ExpNodes

Plus, Minus, , Not, Less, Equals, All do Same basic sequence of tasks
Call each child's codeGen method to generate code that will evaluate the operand(s), leaving the value(s) on the stack. Generate code to pop the operand value(s) off the stack into register(s) (e.g., T0 and T1). Remember that if there are two operands, the right one will be on the top of the stack. Generate code to perform the operation (see Spim documentation for a list of opcodes). Generate code to push the result onto the stack.

Note on SPIM op-codes

The NOT opcode is a bit-wise note (flips bits), this wont work for the Not boolean operations Suggest using seq opcode
Seq Rdest, Rsrc1, Src2

Example AddExpNode
AddExpNode

ExpNode
public void codeGen() { // step 1: evaluate both operands myExp1.codeGen(); myExp2.codeGen(); // step 2: pop values in T0 and T1 genPop(T1); genPop(T0); // step 3: do the addition (T0 = T0 + T1) generate("add", T0, T0, T1); // step 4: push result genPush(T0) }

ExpNode

Short-Circuited Operators
AndNode and OrNode Short-Circuit means the right operand is evaluated ONLY if it is needed to be evaluated Example:
(J != 0) && (I/J > Epsilon)

AndNode Procedure
Evaluate left operand If left operand is true then Evaluate right operand Expression value is value of right operand Else Expression value is false

OrNode Procedure
Evaluate left operand If left operand is false evaluate right operand expression is value of right operand Else expression is true

Short-Circuit Nodes
Need to do jump depending on values of sub-expressions Look at if-node code for example of this

You Try It
Write code for AndExpNode

If Statement
IfStmtNode ExpNode DeclListNode StmtListNode

Two Methods for Generating code Numeric Method

Control-Flow Method

Evaluate condition, pop off stack, jump on particular value

Evaluate condition and jump to TrueLabel on true or FalseLabel on false (i.e. ALWAYS do a jump) Requires a new method for Expression Nodes (i.e. dont put value on the stack, instead do jump) Call New method genJumpCode(LabelTrue,LabelFalse)

codeGen for IfStmtNode (controlflow method)

public void codeGen() { String trueLab = nextLabel(); String doneLab = nextLab(); myExp.genJumpCode(trueLab, doneLab); genLabel(trueLab); myStmtList.codeGen(); genLabel(doneLab); }

genJumpCode() for IdNode

Old way
lw push $t0, <vars addr> $t0

New way
lw beq b $t0, <vars addr> $t0, FALSE, falseLab trueLab

genJumpCode() for LessNode

Old Way
-- code to eval operands -- pop values into T1, T0 slt $t2, $t0, $t1 push $t2

New Way
-- code to eval operands -- pop values into T1, T0 blt $t0, $t1, trueLab B falseLab

genJumpCode() for Short-Circuited Operators (AndExpNode)

AndExpNode

ExpNode

ExpNode

Call genJumpCode() of left child. If child is false then jump to false label If child is true jump to right child Generate label for right child Call genJumpCode() of right child. If child is false jump to false label If child is true jump to true label

genJumpCode() for AndExpNode

Public void genJumpCode(String trueLab, String falseLab) { String newLab=nextLabel(); myExp1.genJumpCode(newLab,falseLab); genLabel(newLab); myExp2.genJumpCode(trueLab,falseLab); }

Example with genJumpCode

If (a && b>0) {
IfStmtNode

AndExpNode

DeclListNode

StmtListNode

IdNode

LessExpNode

genJumpCode() Example
IfStmtNode
creates two labels, trueLab, doneLab calls AndNodes genJumpCode(trueLabel,doneLabel) Generate trueLab --code for StmtListNode Generate doneLabel

AndNode
creates a label newLabel, calls IdNodes genJumpCode(newLabel,doneLabel) Generate newLabel Call LessNodes genJumpCode(trueLab,doneLab)

You Try It
What is the form of the code for genJumpCode()
For an OrNode For a NotNode

Comparing Numeric and ControlFlow methods

Numeric Method
-- code to evaluate left operand, leaving value on stack
Pop into T0 Goto trueLab if t0==FALSE Push FALSE Goto doneLab

Control-Flow Method
--code to evaluate left operand, including jumps to newLab and falseLab newLab: --code to evaluate right operand, including jumps to trueLab and falseLab

trueLab: -- code to evalute right operand, leaving value on stack doneLab:

You Try It
Compare two approaches for OrNode and NotNode