languages and compilers (sprog og oversættere)

Languages and Compilers(SProg og Oversættere)

Bent Thomsen

Department of Computer Science

Aalborg University

With acknowledgement to Norm Hutchinson whose slides this lecture is based on.

Where are we (going)?

Compiler Driver

Syntactic Analyzer

callscalls

Contextual Analyzer Code Generator

Dependency diagram of a typical Multi Pass Compiler:

A multi pass compiler makes several passes over the program. The output of a preceding phase is stored in a data structure and used by subsequent phases.

Source Text

output

input output

Decorated AST

input output

Object Code

Code Generation

A compiler translates a program from a high-level language into an equivalent program in a low-level language.

TAM Program

Triangle Program

Compile

Result

JVM Program

Java Program

Compile

Result

x86 Program

C Program

Compile

Result

We shall look at this in more detail the next couple of lectures

TAM machine architecture

• TAM is a stack machine– There are no data registers as in register machines.– The temporary data are stored in the stack.

• But, there are special registers (Table C.1 of page 407)

• TAM Instruction Set– Instruction Format (Figure C.5 of page 408)– op: opcode (4 bits)

• r: special register number (4 bits)• n: size of the operand (8 bits)• d: displacement (16 bits)

• Instruction Set– Table C.2 of page 409

TAM Registers

TAM Machine code

• Machine code are 32 bits instructions in the code store– op (4 bits), type of instruction

– r (4 bits), register

– n (8 bits), size

– d (16 bits), displacement

• Example: LOAD (1) 3[LB]:– op = 0 (0000)

– r = 8 (1000)

– n = 1 (00000001)

– d = 3 (0000000000000011)

• 0000 1000 0000 0001 0000 0000 0000 0011

TAM Instruction set

• Two Storage Areas– Code Store (32 bits words)

• Code Segment: to store the code of the program to run– Pointed to by CB and CT

• Primitive Segment: to store the code for primitive operations– Pointed to by PB and PT

– Data Store (16 bits words)• Stack

– global segment at the base of the stack» Pointed to by SB

– stack area for stack frames of procedure and function calls» Pointed to by LB and ST

• Heap– heap area for the dynamic allocation of variables

» Pointed to by HB and HT

Global Variable and Assignment Command

• Triangle source code! simple expression and assignment

var n: Integer

n := 5;

n := n + 1

• TAM assembler code

0: PUSH 1

1: LOADL 5

2: STORE (1) 0[SB]

3: LOAD (1) 0[SB]

4: LOADL 1

5: CALL add

6: STORE (1) 0[SB]

7: POP (0) 1

8: HALT

The “Phases” of a Compiler

Syntax Analysis

Contextual Analysis

Code Generation

Source Program

Abstract Syntax Tree

Decorated Abstract Syntax Tree

Object Code

Error Reports

Next lecture

Storage Allocation

A compiler translates a program from a high-level language into an equivalent program in a low-level language.

The low level program must be equivalent to the high-level program.=> High-level concepts must be modeled in terms of the low-level machine.

This lecture is not about the code generation phase itself, but about the way we represent high-level structures in terms of a typical low-level machine’s memory architecture and machine instructions.

=> We need to know this before we can talk about code generation.

What This Lecture is About

High Level Program

Low-level Language Processor

How to model high-level computational structures and data structures in terms of low-level memory and machine instructions.

Procedures

Expressions

VariablesArrays

Records

Objects

Methods

Registers

Machine Instructions

Bits and BytesMachine Stack

How to model ?

Data Representation

• Data Representation: how to represent values of the source language on the target machine.

Records

ArraysStrings

Integer

00..10

01..00

High level data-structures

0:1:2:3:

Low level memory model

wordword

Note: addressing schema and size of “memory units” may vary

Data Representation

Important properties of a representation schema:• non-confusion: different values of a given type should have

different representations• uniqueness: Each value should always have the same

representation.

These properties are very desirable, but in practice they are not always satisfied:Example: • confusion: approximated floating point numbers.• non-uniqueness: one’s complement representation of integers

+0 and -0

Data Representation

Important issues in data representation:

• constant-size representation: The representation of all values of a given type should occupy the same amount of space.

• direct versus indirect representation

x bit pattern x bit pattern•

handle

Direct representationof a value x

Indirect representationof a value x

Indirect Representation

small x bit pattern

Q: What reasons could there be for choosing indirect representations?

To make the representation “constant size” even if representation requires different amounts of memory for different values.

big x bit pattern

Both are represented by pointers

=>Same size

Indirect versus Direct

The choice between indirect and direct representation is a key decision for a language designer/implementer.

• Direct representations are often preferable for efficiency:• More efficient access (no need to follow pointers)• More efficient “storage class” (e.g stack rather than heap

allocation)• For types with widely varying size of representation it is almost

a must to use indirect representation (see previous slide)

Languages like Pascal, C, C++ try to use direct representation wherever possible.

Languages like Scheme, ML use mostly indirect representation everywhere (because of polymorphic higher order functions)

Java: primitive types direct, “reference types” indirect, e.g. objects and arrays.

Data Representation

We now survey representation of the data types found in the Triangle programming language, assuming direct representations wherever possible.

We will discuss representation of values of:• Primitive Types• Record Types• Static Array Types

We will use the following notations (if T is a type): #[T] The cardinality of the type (i.e. the number of possible values)size[T] The size of the representation (in number of bits/bytes)

Data Representation: Primitive Types

What is a primitive type?The primitive types of a programming language are those types that cannot be decomposed into simpler types. For example integer, boolean, char, etc.

Type: booleanHas two values true and false=> #[boolean] = 2=> size[boolean] ≥ 1 bit

Note: In general if #[T] = n then size[T] ≥ log2n bits

Valuefalsetrue

Possible Representation1bit byte(option 1) byte(option2)0 00000000 000000001 00000001 11111111

Type: integerFixed size representation, usually dependent (i.e. chosen based on) what is efficiently supported by target machine. Typically uses one word (16 bits, 32 bits, or 64 bits) of storage.

size[integer] = word (= 16 bits)=> # [integer] ≤ 216 = 65536

Modern processors use two’s complement representation of integers

1 0 0 0 0 1 0 0 1 0 0 1 0 1 1 1

Multiply with -(215) Multiply with 2n

Value = -1.215 +0.214 +…+0.23+1.22 +1.21 +1.20

n = position from left

Example: Primitive types in TAM (Triangle Abstract Machine)

TypeBooleanCharInteger

Representation00...00 and 00...01 UnicodeTwo’s complement

Size1 word1 word1 word

Example: A (possible) representation of primitive types on a Pentium

TypeBooleanCharInteger

Representation00...00 and 11..11 ASCIITwo’s complement

Size1 byte1 byte1 word

Data Representation: Composite Types

Composite types are types which are not “atomic”, but which are constructed from more primitive types.

• Records (called structs in C)Aggregates of several values of several different types

• ArraysAggregates of several values of the same type

• (Variant Records or Disjoined Unions)• (Pointers or References)• (Objects)• (Functions)

Data Representation: Records

Example: Triangle Records

type Date = recordy : Integer,m : Integer,

d : Integer end;type Details = record

female : Boolean,dob : Date,status : Char

end;var today: Date;var my: Details

type Date = recordy : Integer,m : Integer,

d : Integer end;type Details = record

female : Boolean,dob : Date,status : Char

end;var today: Date;var my: Details

Example: Triangle Record Representation

today.m

today.y

today.d 5

my.dob.m

my.dob.y

my.dob.d 17

‘u’

my.female

my.dob

my.status

…1 word:

Records occur in some form or other in most programming languages:Ada, Pascal, Triangle (here they are actually called records)C, C++ (here they are called structs).

The usual representation of a record type is just the concatenation of individual representations of each of its component types.

value of type T1

value of type T2

value of type Tn

Example:size[Date] = 3*size[integer] = 3 wordsaddress[today.y] = address[today]+0address[today.m] = address[today]+1address[today.d] = address[today]+2

address[my.dob.m] = address[my.dob]+1 = address[my]+2

Q: How much space does a record take? And how to access record elements?

Note: these formulas assume that addresses are indexes of words (not bytes) in memory (otherwise multiply offsets by 2)

Arrays

An array is a composite data type, an array value consists of multiple values of the same type. Arrays are in some sense like records, except that their elements all have the same type.

The elements of arrays are typically indexed using an integer value (In some languages such as for example Pascal, also other “ordinal” types can be used for indexing arrays).

Two kinds of arrays (with different runtime representation schemas):• static arrays: their size (number of elements) is known at

compile time.• dynamic arrays: their size can not be known at compile time

because the number of elements may vary at run-time.

Q: Which are the “cheapest” arrays? Why?

Static Arrays

Example:type Name = array 6 of Char; var me: Name;var names: array 2 of Name

type Name = array 6 of Char; var me: Name;var names: array 2 of Name

‘K’‘r’‘i’‘s’‘ ’‘ ’

me[0]me[1]

‘J’‘o’‘h’‘n’‘ ’‘ ’

names[0][0]names[0][1]

names[0][2]

names[0][3]

names[0][4]

names[0][5]

‘S’‘o’‘p’‘h’‘i’‘a’

names[1][0]names[1][1]

names[1][2]

names[1][3]

names[1][4]

names[1][5]

Static Arrays

Example:

type Coding = record Char c, Integer n

var code: array 3 of Coding

type Coding = record Char c, Integer n

var code: array 3 of Coding

‘K’5

code[0].ccode[0].n Coding

‘i’22

‘d’4

Static Arrays

type T = array n of TE; var a : T;

a[n-1]

size[T] = n * size[TE]

address[a[0]] = address[a]address[a[1]] = address[a]+size[TE]address[a[2]] = address[a]+2*size[TE]…address[a[i] ] = address[a]+i*size[TE]…

Static Storage Allocation

Example: Global variables in Triangle

let type Date = record y: Integer, m:Integer, d:Integer end; //Date var a: array 3 of Integer; var b: Boolean; var c: Char; var t: Date;in ...

Exist as long as program is running

Compiler can:• compute exactly how much memory is needed for globals.• allocate memory at a fixed position for each global variable.

Static Storage Allocation

address[a] = 0address[b] = 3address[c] = 4address[t] = 5

let type Date = record y: Integer, m:Integer, d:Integer end; //Date var a: array 3 of Integer; var b: Boolean; var c: Char; var t: Date;

Example: Global variables in Triangle

Stack Storage Allocation

let var a: array 3 of Integer; var b: Boolean; var c: Char; proc Y() ~ let var d: Integer; var e: ... in ... ; proc Z() ~ let var f: Integer; in begin ...; Y(); ... endin begin ...; Y(); ...; Z(); end

Example: When do the variables in this program “exist”

as long as the program is

running

when procedure Y is active

when procedure Z is active

Now we will look at allocation of local variables

Stack Storage Allocation

Start of program End of program time

call depth

global

1) Procedure activation behaves like a stack (LIFO). 2) The local variables “live” as long as the procedure they are declared in.1+2 => Allocation of locals on the “call stack” is a good model.

A “picture” of our program running:

Stack Storage Allocation: Accessing locals/globals

First time around, we assume that in a procedure only local variables declared in that procedure and global variables are accessible.We will extend on this later to include nested scopes and parameters.

A stack allocation model (under the above assumption):• Globals are allocated at the base of the stack. • Stack contains “frames”.

• Each frame correspond to a currently active procedure. (It is often called an “activation frame”)

• When a procedure is called (activated) a frame is pushed on the stack

• When a procedure returns, its frame is popped from the stack.

Stack Storage Allocation: Accessing locals/globals

callframe

SB = Stack baseLB = Locals baseST = Stack top

callframe Dynamic link

globals

What’s in a Frame?

A frame contains• A dynamic link: to next frame on

the stack (the frame of the caller)• Return address• Local variables for the current

activation

return adress

locals

Link data

Local data

dynamic link

What Happens when Procedure is called?

SB = Stack baseLB = Locals baseST = Stack top

callframe

When procedure f() is called• push new f() call frame

on top of stack.• Make dynamic link in new

frame point to old LB• Update LB (becomes old ST)

new callframe

for f()

What Happens when Procedure returns?

When procedure f() returns• Update LB (from dynamic

link)• Update ST (to old LB)

currentcall

frame for f()

currentcall

frame for f()

callframe

Note, updating the ST implicitly “destroys” or “pops” the frame.

Accessing global/local variables

Q: Is the stack frame for a procedure always on the same position on the stack?

A: No, look at picture of procedure activation below. Imagine what the stack looks like at each point in time.

call depth

global

The global frame is always at the same place in the stack.=> Address global variables relative to SBA typical instruction to access a global variable: LOAD 4[SB]

Frames are not always on the same position in the stack.Depends on the number of frames already on the stack.=> Address local variables relative to LBA typical instruction to access a local variable: LOAD 3[LB]

RECAP: We are still working under the assumption of a “flat” block structure

How do we access global and local variables on the stack?

Example: Compute the addresses of the variables in this program

let var a: array 3 of Integer; var b: Boolean; var c: Char; proc Y() ~ let var d: Integer; var e: ... in ... ; proc Z() ~ let var f: Integer; in begin ...; Y(); ... endin begin ...; Y(); ...; Z(); end

Var Size Address

[0]SB[3]SB[4]SB

[2]LB[3]LB

Accessing non-local variables

RECAP: We have discussed• stack allocation of locals in the call frames of procedures• Some other things stored in frames:

• A dynamic link: pointing to the previous frame on the stack=> corresponds to the “caller” of the current procedure.

• A return address: points to the next instruction of the caller.• Addressing global variables relative to SB (stack base)• Addressing local variables relative to LB (locals base)

Now… we will look at accessing non-local variables.

Or in other words. We will look into the question:

How does lexical scoping work?

Accessing non-local variables: what is this about?

Example: How to access p1,p2 from within Q or S?

let var g1: array 3 of Integer; var g2: Boolean; proc P() ~ let var p1,p2 proc Q() ~ let var q:... in ... ; proc S() ~ let var s: Integer; in ... in ...in ...

Scope Structurevar g1,g2proc P()

var p1,p2proc Q()

proc S()

Q: When inside Q, does the dynamic link always point to frame of P?

Q: When inside Q, does the dynamic link always point to a frame P?A: No! Consider following scenarios:

var g1,g2proc P()

var p1,p2proc Q()

proc S()

We can not rely on the dynamic link to get to the lexically scoped frame(s) of a procedure.

=> Another item is added in the link data: the static link.

The static link in a frame points to the next lexically scoped frame somewhere higher on the stack.

Registers L1, L2, etc. are used to point to the lexical scoped frames. (L1, is most local). A typical instruction for accessing a non-local variable looks like: LOAD [4]L1 LOAD [3]L2

These + LB and SB are called the display registers

What’s in a Frame (revised)?

A frame contains• A dynamic link: to next frame on

the stack (the frame of the caller)• Return address• Local variables for the current

activation

static link

locals

Link data

Local data

dynamic link

return address

proc P()

proc Q() ...proc S() ...

P()frame

globalsSB

S()frame

Q()frame

Dynamic L.

Static Link

Accessing variables, addressing schemas overview

We now have a complete picture of the different kinds of addresses that are used for accessing variables stored on the stack.

Type of variable

Global

Non-local, 1 level up

Non-local, 2 levels up

Load instruction

LOAD offset[SB]

LOAD offset[LB]

LOAD offset[L1]

LOAD offset[L2]

Routines

We call the assembly language equivalent of procedures “routines”.

In the preceding material we already learned some things about the implementation of routines in terms of the stack allocation model:

• Addressing local and globals through LB,L1,L2,… and SB

• Link data: static link, dynamic link, return address.

We have yet to learn how the static link and the L1, L2, etc. registers are set up.

We have yet to learn how routines can receive arguments and return results from/to their caller.

Routines

We call the assembly language equivalent of procedures “routines”.

What are routines? Unlike procedures/functions in higher level languages. They are not directly supported by language constructs. Instead they are modeled in terms of how to use the low-level machine to “emulate” procedures.

What behavior needs to be “emulated”?• Calling a routine and returning to the caller after completion.• Passing arguments to a called routine• Returning a result from a routine• Local and non-local variables.

Routines

• Transferring control to and from routine:Most low-level processors have CALL and RETURN for transferring control from caller to callee and back.

• Transmitting arguments and return values:Caller and callee must agree on a method to transfer argument and return values. => This is called the “routine protocol”

There are many possible ways to pass argument and return values. => A routine protocol is like a “contract” between the caller and the callee.

!The routine protocol is often dictated by the operating system.

Routine Protocol Examples

The routine protocol depends on the machine architecture (e.g. stack machine versus register machine).

Example 1: A possible routine protocol for a RM- Passing of arguments:

first argument in R1, second argument in R2, etc.- Passing of return value:

return the result (if any) in R0

Note: this example is simplistic:- What if more arguments than registers?- What if the representation of an argument is larger than can be stored in a register.

For RM protocols, the protocol usually also specifies who (caller or callee) is responsible for saving contents of registers.

Routine Protocol Examples

Example 2: A possible routine protocol for a stack machine

- Passing of arguments: pass arguments on the top of the stack.

- Passing of return value:leave the return value on the stack top, in place of the arguments.

Note: this protocol puts no boundary on the number of arguments and the size of the arguments.

Most micro-processors, have registers as well as a stack. Such “mixed” machines also often use a protocol like this one.

The “Triangle Abstract Machine” also adopts this routine protocol.We now look at it in detail (in TAM).

TAM: Routine Protocol

globals

just before the call just after the call

globals

result

What happens in between?

(1) just before the call

(2) just after entry

link data

note: Going from (1) -> (2) in TAM is the execution of a single CALL instruction.

(2) just after entry

link data

(3.1) during execution of routine

link data

localdata

shrinks and grows during execution

(3.2) just before return

link data

localdata

result

(4) just after return

ST result

note: Going from (3.2) -> (4) in TAM is the execution of a single RETURN instruction.

TAM: Routine Protocol, Example

let var g: Integer; func F(m: Integer, n: Integer) : Integer ~ m*n ; proc W(i:Integer) ~ let const s ~ i*i in begin putint(F(i,s)); putint(F(s,s)) endin begin getint(var g); W(g+1)end

Example Triangle Program

PUSH 1 -- expand globals make place for gLOADA 0[SB] -- push address of gCALL getint -- read integer into gCALL succ -- add 1CALL(SB) W -- call W (using SB as static link)POP 1 -- contract globalsHALT

TAM assembly code:

let var g: Integer; ... in begin getint(var g); W(g+1)end

F: LOAD -2[LB] -- push value of argument m LOAD -1[LB] -- push value of argument n CALL mult -- multiply m and n RETURN(1) 2 -- return replacing 2 word argument pair by 1 word result

func F(m: Integer, n: Integer) : Integer ~ m*n ; func F(m: Integer, n: Integer) : Integer ~ m*n ;

arguments addressed relative to LB (negative offsets!)

Size of return value and argument space needed for updating the stack on return from call.

W: LOAD -1[LB] -- push value of argument i LOAD -1[LB] -- push value of argument i CALL mult -- multiply: result is value of s LOAD -1[LB] -- push value of argument i LOAD 3[LB] -- push value of local var s CALL(SB) F -- call F (use SB as static link) … RETURN(0) 1 -- return, replacing 1 word argument by 0 word result

proc W(i: Integer) ~ let const s~i*i in ... F(i,s) ...

let var g: Integer; ... in begin getint(var g); W(g+1)end

SB g 3

after reading g

just before call to W

4STSB g

ST arg #1

proc W(i: Integer) ~ let const s~i*i in ... F(i,s) ...

just after entering W

LB arg #1

STlinkdata

just after computing s

LB arg i

linkdata16

just before calling F

LB arg i

linkdata164

arg #1arg #2

static link dynamic link

just before calling F

LB arg i

linkdata164

arg #1arg #2

just after entering F

linkdata164

arg marg n

linkdata

just before return from F

linkdata164

arg marg n

linkdata64

just before return from F

linkdata164

arg marg n

linkdata64

after return from F

LB arg i

linkdata1664

TAM Routine Protocol: Frame Layout Summary

local variablesand intermediate

results

dynamic linkstatic link

return addres

Local data, grows and shrinksduring execution.

Link data

arguments Arguments for current procedurethey were put here by the caller.

Accessing variables, addressing schemas overview(Revised)

We now have a complete picture of the different kinds of addresses that are used for accessing variables and formal parameters stored on the stack.

Type of variable

Global

Parameter

Non-local, 1 level up

Non-local, 2 levels up...

Load instruction

LOAD +offset[SB]

LOAD +offset[LB]

LOAD -offset[LB]

LOAD +offset[L1]

LOAD +offset[L2]

Static Links

We have already seen somewhat how the static link in the callframes is set in the previous: It is initialized from a parameter of the CALL instruction.

But… how can the compiler determine that parameter at compile time?

To understand this we need to know a few things about the Triangle programming language.

• Statically scoped, block-structured language.• The static link points to the scope where the function was defined.• If there are no higher-order funcs or procs. The compiler always knows which func/proc is being called. That func/proc must be defined somewhere within the active scope.=> the static link can always be found in one of the display registers

Static Links

the static link can always be found in one of the display registers

let proc P() let proc Q() let proc Q1 Q1body proc Q2 Q2body in Qbody proc S() let proc S1 S1body proc S2 S2body in Sbody in Pbodyin ...Main Program...

from to

Main P

Static link?

S PS1S2SQ

SBLBLBSBLBLBL1L2

S2 L1L2

Arguments: by value or by reference

Some programming languages allow to two kinds of function/procedure parameters.

Example: in Triangle (similar in Pascal)

let proc S(var n:Integer, i:Integer) ~ n:=n+i; var today: record y:integer, m:Integer, d:Integer end;in begin b := {y~2002, m ~ 2, d ~ 22}; S(var b.m, 6);end

Constant/Value parameterVar/reference parameter

Arguments: by value or by reference

Value parameters:At the call site the argument is an expression, the evaluation of that expression leaves some value on the stack. The value is passed to the procedure/function.A typical instruction for putting a value parameter on the stack:LOADL 6

Var parameters:Instead of passing a value on the stack, the address of a memory location is pushed. This implies a restriction that only “variable-like” things can be passed to a var parameter. In Triangle there is an explicit keyword var at the call-site, to signal passing a var parameter. In Pascal and C++ the reference is created implicitly (but the same restrictions apply). Typical instructions: LOADA 5[LB] LOADA 10[SB]

Recursion

How are recursive functions and procedures supported on a low-level machine?=> Surprise! The stack memory allocation model already works!Example:

let func fac(n:Integer) ~ if (n=1) then 1 else n*fac(n-1);in begin putint(fac(6));end

why does it work? because every activation of a function gets its own activation record on the stack, with its own parameters, locals etc.=> procedures and functions are “reentrant”. Older languages (e.g. FORTRAN) which use static allocation for locals have problems with recursion.

Recursion: General Idea

Why the stack allocation model works for recursion:Like other function/procedure calls, lifetimes of local variables and parameters for recursive calls behave like a stack.

fac(3)

fac(2)

fac(1)

fac(4) fac(4)

fac(3)

fac(2)

fac(4)fac(4)

fac(3) fac(3)

fac(2)

fac(1)

fac(3)

fac(2)

fac(4)

fac(3)?

fac(4)

Recursion: In Detail

let func fac(n:Integer) ~ if (n=1) then 1 else n*fac(n-1);in begin putint(fac(6));end

SB arg 1 6ST

before call to facSB arg 1 6

right after enteringfac

linkdata

SB arg n 6

right before recursivecall to fac

linkdata

6value of n5arg 1:value of n-1

Recursion

SB arg n 6

right before recursivecall to fac

linkdata

6value of n5arg

SB arg n 6

right before next recursive call to fac

linkdata

6value of n5arg n

linkdata

value of narg

SB arg n 6

right before next recursive call to fac

linkdata

6value of n5arg n

linkdata

value of narg

linkdata

value of narg

Recursion

Is the spaghetti of static and dynamic links getting confusing?

Let’s zoom in on just a single activation of the fac procedure. The pattern is always the same:

argument n

link data

to caller context (= previous LB)to lexical context (=SB)

Intermediate results in the computation of n*fac(n-1);

just before recursive call in fac

Recursion

link data

result = 1

just before the return from the “deepest call”: n=1 after return from deepest call

STresult=1

?caller frame

(what’s in here?)

argument n=2

link data

n=2 Next step:multiplyargument n=1

Recursion

just before the return from the “deepest call”: n=1

after return from deepest call and multiply

caller frame(what’s in here?)

argument n=2

link data

2*fac(1)=2 Next step:return

to caller contextto lexical context (=SB)

result

From here on down the stack is shrinking,multiplying each time with a bigger n

Recursion

argument n

link data

nrecurs. arg: n-1

just before recursive call in fac

argument n

link data

nfac(n-1)

after completion of the recursivecall

Calling a recursive function is just like calling any other function. After completion it just leaves its result on the top of the stack!A recursive call can happen in the midst of expression evaluation.Intermediate results. local variables, etc. simply remain on the stack and computation proceeds when the recursive call is completed.

Summary

• Data Representation: how to represent values of the source language on the target machine.

• Storage Allocation: How to organize storage for variables (considering different lifetimes of global, local and heap variables)

• Routines: How to implement procedures, functions (and how to pass their parameters and return values)

languages and compilers (sprog og oversættere)

highlevel program

code store op

highlevel language

equivalent program

machine instructions

bits instructions

code generationa compiler

highlevel structures

Documents

1 languages and compilers (sprog og oversættere) lecture 7...

1 languages and compilers (sprog og oversættere) lecture 1...

languages and compilers (sprog og...

1 languages and compilers (sprog og oversættere) lecture 8...

1 languages and compilers (sprog og oversættere) bent...

1 languages and compilers (sprog og oversættere) parsing

languages and compilers (sprog og...

languages and compilers (sprog og oversættere)

1 languages and compilers (sprog og oversættere) lecture 14...

1 languages and compilers (sprog og oversættere) lecture 10...

languages and compilers (sprog og oversættere) bent thomsen...

languages and compilers (sprog og oversættere) lecture 14...

1 languages and compilers (sprog og oversættere) bent...

1 languages and compilers (sprog og oversættere) lecture 5...

languages and compilers (sprog og oversættere) lecture 15...

1 languages and compilers (sprog og oversættere) lecture 11...

1 languages and compilers (sprog og oversættere) lecture 13...

1 languages and compilers (sprog og oversættere) lecture 15...

languages and compilers (sprog og oversættere) lecture 9...

1 languages and compilers (sprog og oversættere) lecture 4...