Simpler Compiler: Stack Machines & Code Generation with Dr. Peisert's ECS 142 Lecture 20 -, Study Guides, Projects, Research of Computer Science

Download Simpler Compiler: Stack Machines & Code Generation with Dr. Peisert's ECS 142 Lecture 20 - and more Study Guides, Projects, Research Computer Science in PDF only on Docsity!

Code Generation

Lecture 20 Dr. Sean Peisert – ECS 142 – Spring 2009 1

Status

1.5 weeks to go on project 3

Read Sec. 7.1 through 7.4 by next Monday, May 18

2

Example of a Stack

Machine Program

Consider two instructions

push i — place the int i on top of the stack

add — pop two elements, add them, and put the result back on the stack

A program to compute 7 + 5:

push 7

push 5

add 4

Stack Machine. Example.

Each instruction

takes operands from the top of the stack

removes those operands from the stack

computes the required operation on them

pushes the result on the stack 5 ... ... ... ... 7 7 12 5

Why Use a Stack Machine?

• Location of the operands is implicit (always on the top of the stack)
• No need to specify operands explicitly
• No need to specify the location of the result
• Instruction “add” as opposed to “add r1, r2”

Smaller encoding of instructions

More compact programs

This is one reason why Java Bytecodes use a stack evaluation model 7 

Optimizing the Stack Machine

• The add instruction does 3 memory operations - Two reads and one write to the stack - The top of the stack is frequently accessed
• Idea: keep the top of the stack in a register (called accumulator) - Register accesses are faster

The “add” instruction is now: acc ← acc + top_of_stack - Only one memory operation! 8

Stack Machine w/Accumulator. Example.

Compute 7 + 5 using an accumulator 10 ... ... ... ... 12 7 7

acc (^75) stack acc ← 7 push acc acc ← (^5) acc ← acc + top of stack pop

A Bigger Example: 3 + (7 + 5)

Code acc ← 3 push acc acc ← 7 push acc acc ← 5 acc ← acc + top _ of_stack pop acc ← acc + top _ of_stack pop Acc 3 3 7 7 5 12 12 15 15 Stack 3, 3, 7, 3, 7, 3, 7, 3, 3, 3, 11

From Stack Machines to MIPS

• The compiler generates code for a stack machine with accumulator.
• We want to run the resulting code on the MIPS processor (or simulator).
• We implement stack machine instructions using MIPS instructions and registers. 13

Simulating a Stack Machine

• The accumulator is kept in MIPS register $a
• The stack is kept in memory
• The stack grows toward lower addresses

Standard convention on the MIPS architecture

The address of the next location on the stack is kept in MIPS register $sp 

The top of the stack is at address $sp + 4. 14

MIPS Architecture

Prototypical Reduced Instruction Set Computer (RISC) architecture

Arithmetic operations use registers for operands and results

Must use load and store instructions to use operands and results in memory

32 general purpose registers (32 bits each)

We will use $sp, $a0, and $t1 (a temporary register)

We’ll give you a SPIM document for more details. 16

A Sample of MIPS Instructions

• lw reg1 offset(reg2)

Load 32-bit word from address reg2 + offset into reg

add reg1 reg2 reg 

reg1 ← reg2 + reg

sw reg1 offset(reg2) 

Store 32-bit word in reg1 at address reg2 + offset

addiu reg1 reg2 imm 

reg1 ← reg2 + imm

“u” means overflow is not checked

li reg imm 

reg ← imm 17

A Small Language

A language with integers and integer operations P →D; P | D D →def id(ARGS) = E; ARGS → id, ARGS | id E →int | id | if E 1 = E 2 then E 3 else E 4 | E 1 + E 2 | E 1 –E 2 | id(E 1 ,…,En) 19

A Small Language

The first function definition f is the “main” routine

Running the program on input i means computing f(i)

Program for computing the Fibonacci numbers:

def fib(x) = if x = 1 then 0 else

if x = 2 then 1 else

fib(x -1) + fib(x - 2)

20