cs412/413 introduction to compilers and translators spring ’99 lecture 11: functions and stack...

CS412/413

Introduction to

Compilers and Translators

Spring ’99

Lecture 11: Functions and stack frames

CS 412/413 Introduction to Compilers and Translators -- Spring '99 Andrew Myers

2

Administration

• Homework 2 due now


3

Handling Recursion• Java, Iota: all global identifiers visible

through a module

• Need to create environment (symbol table) containing all of them for checking each function definition

• Global identifiers bound to their types

x: int {x : int}

• Functions bound to function types

gcd(x: int, y:int): int {gcd: int intint}


4

Auxiliary environment info• Entries representing functions are not

normal environment entries

{gcd: int intint}

• int intint not a type in the type system : functions not first-class values in Iota

• Can’t use gcd as a variable name

• In general all kinds of information can be stuck into symbol table


5

Handling Recursion• Need environment containing at least

{f: int int, g: int int}

when checking both f and g

• Two-pass approach:– Scan top level of AST picking up all function

signatures and creating an environment binding all global identifiers

– Type-check each function individually using this global environment


6

Non-local control flow• How to check non-local control transfers?

– return, throw, break, continue

• Fits into existing framework for type checking (mostly)

• Question: what is the type of a return statement?

A |– return E : ?


7

How to check return?A |– E : T

A |– return E : void

• A return statement has no value, so its type is void

• But… how to make sure the return type of the current function is T ?


8

More auxiliary info• Answer: put it in the symbol table

• Add entry {return : int } when we start checking the function, look up this entry when we hit a return statement.

A’ = A { ..., ai : Ti, ... } {return : T} A’ |– E : T

A |– [ id ( ..., ai : Ti, ... ) : T = E ]

A |– E : T{return : T} A

A |– return E : void


9

Summary• Static semantics provides a way to describe

semantic analysis concisely• If properly designed, leads to natural

recursive implementation


10

Where we areSource code(character stream)

Lexical analysis

Syntactic Analysis

Token stream

Semantic Analysis

Intermediate CodeGeneration

Abstract syntax tree+ types

Abstract syntax tree

Intermediate Code

regular expressions

grammars

static semantics

translation functions


11

Intermediate Code• Code for an abstract processor

• Processor-specific details avoided (e.g. # of registers)

• Generality enables optimization

• Tree representation conversion

if

==

int b int 0

=

int a int b

boolean int;

CJUMP ==

MEM

fp 8

+

CONST MOVE

0 MEM MEM

fp 4 fp 8

NOP

+ +

if (b==0) a = b;


12

Variables in IR

if

==

int b int 0

=

int a int b

boolean int;

CJUMP ==

MEM

fp 8

-

CONST MOVE

0 MEM MEM

fp 4 fp 8

NOP

- -

• Variables mapped to memory locationsb Mem[fp - 8]

• How do we map them?


13

IR Architecture• Infinite no. of general purpose registers• Stack pointer register (sp)• Frame pointer register (fp)• Program counter register (pc)• Versus Pentium:

– Very finite number of registers (EAX–EDX, ESI, EDI)– None really “general purpose”– Stack pointer (ESP), frame pointer (EBP), instruction

pointer (EIP)

• Versus MIPS, Alpha:– 32 general purpose registers (r0–r31) + PC


14

Representing variables• Global variables: mapped to particular

locations in memory • Local variables, arguments: can’t map to fixed

locations because of recursion, threads

fact(x: int): int = {

if (x==0) 1; else x*fact(x-1);

}

where to store x?


15

Stack• Local storage allocated on stack

– area of memory for storage specific to function invocations

– each function invocation: a new stack frame– same variable in different invocations stored in

different stack frames: no conflict


16

Stack Frames• Program stack pointed to by

two registers– sp: stack pointer– fp: frame pointer

• New stack allocation at sp• Stack contents accessed relative

to fp• Positive offsets: function

arguments, static link to previous function

• Negative offsets: local storage, e.g. b fp - 8

spunused

fp

arguments

local varstemporaries

static link

increasingmemoryaddress


17

Arguments (std. Pentium)gcd(x:int, y:int): int = { … }• Arguments part of calling stack frame• Pushed onto stack before return address

(positive offset from fp)• End of frame: static link

y

xret pc

call fpfp

+4

+8

+12

+16

callingframe

currentframe


18

Local variablesgcd(x:int, y:int): int = {

if (x == 0) y; else {

if (x < y) { t:int = x; x = y; y = t; } gcd(x%y,y); }}

y

xret pcold fp

fp

+4+8

+12+16

ttemp1

temp1

+0-4

sp

callingframe

currentframe

t always at [fp+0]


19

Making a callgcd(temp1,y)

y

xret pcold fp

fp

+4+8

+12+16

ttemp1

+0-4

sp

callingframe

currentframe

• Caller: push y push temp1 call function

push ret addr pc := gcd

On return:sp := sp + 8

ytemp1

ret addr

sp


20

Entering a function• Callee: need to

establish new frame

• Push fp from calling frame

• Move sp to fp

• Adjust sp to make room for local variables

• On return:– move fp to sp

– pop fp

– return

y

xret pcold fp

fp+4+8

+12+16

ttemp1

+0-4

sp

callingframe

ytemp1

ret addrfp

fp

+8+12+16

tsp

currentframe


21

Modern architectures• Pentium calling conventions (for C): lots of

memory traffic

• Modern processors: use of memory is much slower than register accesses

• Pentium has impoverished register set (4 somewhat general purpose registers)

• More registers better calling conventions?


22

MIPS, Alpha calling conventions

• 32 registers!

• Up to 4 arguments (6 on Alpha) passed in registers

• Return address placed in register (r31)

• No frame pointer unless needed

• Local variables, temporary values placed in registers


23

MIPS stack frame

sp

Caller:Use jal gcd, r31

leaf procedure:Return addr in r31, sp = r30K = max size of locals, tempsOn entry: sp := sp - KOn exit: sp := sp + K; ret r31fp = sp + K

non-leaf procedure:Put return addr on stackSave temporary registers on stack when making callOn entry: sp := sp - K;

[sp + K - 4] := r31On exit: r31 := [sp + K - 4];

sp += K; ret r31;

localsK

locals

ra

K

sp


24

Mapping variables• Variables, temporaries assigned to locations

during intermediate code generation (& optimization)

– assigned to one of infinite no. registers initially– eventually allocated locations relative to fp

• Unoptimized code:– all locations are on stack– arguments pushed onto stack


25

Compiling Functions• Abstract machine for intermediate code

• Stack frames store state for functions

• Calling conventions– x86/Pentium: everything on stack– MIPS, Alpha: everything in registers

• Code transformations for intermediate code generation

cs412/413 introduction to compilers and translators spring ’99 lecture 11: functions and stack...

Documents