runtime organization (chapter 6) 1 course overview part i: overview material 1introduction 2language...

1Runtime Organization (Chapter 6)

Course Overview

PART I: overview material1 Introduction

2 Language processors (tombstone diagrams, bootstrapping)

3 Architecture of a compiler

PART II: inside a compiler4 Syntax analysis

5 Contextual analysis

6 Runtime organization

7 Code generation

PART III: conclusion8 Interpretation

9 Review


What This Chapter is About

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

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 chapter is not about the compilation process 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.



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: how to represent values of the source language on the target machine.

• Expression Evaluation: How to organize computing the values of expressions (taking care of intermediate results)

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

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

• Heap Storage Allocation: How to organize storage for variables (considering lifetimes of heap variables)

• Object Orientation: Runtime organization for OO languages (how to handle classes, objects, methods)


Data Representation

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

Records

ArraysStrings

Integer

Char

?

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 (why?), but in practice they are not always satisfied:Example: • confusion: approximated floating point numbers.• non-uniqueness: one’s complement representation of integers.


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•pointer

Direct representationof a value x

Indirect representationof a value x

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


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.

large 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 (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 higher order functions)

Java: primitive types direct, “reference types” (objects) indirect.


Data Representation

We now survey representation of the more common data types found in programming languages, assuming direct representations wherever possible.

We will discuss representation of values of:• Primitive Types• Record Types• Disjoint Union Types• Static and Dynamic Array Types• Recursive Types

We will use the following notations (if T is a type):#[T] The cardinality of the type (i.e. the number of possible

different 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] ≥ log2 n bits

Valuefalsetrue

Possible Representations1bit 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 0 1

Multiply by -(215) Multiply by 2n

Value = -1*215 +0*214 +…+0*23+1*22 +1*21 +1*20

n = position from right

Q: What range of values can be represented with 16 bits?



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 and classes in C++)Aggregates of several values of possibly several different types

• ArraysAggregates of several values of the same type

• Disjoint Union TypesDisjoint unions are the “dual” of records. They can have values of several different types, but not more than one at the same time.


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

2004

3

today.y

today.d 2

my.dob.m

1970

5

my.dob.y

my.dob.d 17

false

‘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.

r.I1

r.I2

r.In

value of type T1

value of type T2

value of type Tn

type T = record I1: T1; I2: T2; ... In: Tn;end;

var r: T;

type T = record I1: T1; I2: T2; ... In: Tn;end;

var r: T;



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 these offsets by 2 or 4)



Problem: Real machines:•Don’t address words•Have alignment concerns

Example: C/C++ on the x86 architecture•size[boolean] = 1 byte•size[char] = 1 byte•size[int] = 4 bytes

Alignment: all data must be laid out on “natural” boundaries•Not for correctness, but for performance


Alignment example

struct Date {int y, m, d;

};struct Details {bool female;Date dob;char status;

};

struct Date {int y, m, d;

};struct Details {bool female;Date dob;char status;

};

f y yyy m mmm d ddd s

f ? ??y y yym m mmd d dds ? ??


Data Representation: Disjoint Unions

What are disjoint unions?Like a record, has elements which are of different types. But the elements never exist at the same time. A “type tag” determines which of the elements is currently valid.

Example: Pascal variant records

type Number = record case discrete: Boolean of

true: (i: Integer); false: (r: Real) end;var num: Number



Mathematically we write disjoint union types as: T = T1 | … | Tn


Data Representation: Disjoint UnionsExample: Pascal variant records representation





Assuming size[Integer]=size[Boolean]=1 and size[Real]=2, thensize[Number] = size[Boolean] + MAX(size[Integer], size[Real]) = 1 + MAX(1, 2) = 3

num.i

true

15

num.discrete

unused

num.r

falsenum.discrete

3.14


Data Representation: Disjoint Unions

type T = record case Itag: Ttag of v1: (I1: T1); v2: (I2: T2); ... vn: (In: Tn);end;var u: T

type T = record case Itag: Ttag of v1: (I1: T1); v2: (I2: T2); ... vn: (In: Tn);end;var u: T

v1

type T1

v2

type T2

vn

type Tnor …

u.I1 u.I2

u.Itag

u.In

u.Itag u.Itag

or or

size[T] = size[Ttag] + MAX(size[T1], ..., size[Tn])

address[u.Itag ] = address[u]

address[u.I1] = address[u]+size[Ttag] ...address[u.In] = address[u]+size[Ttag]


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]

me[2]

me[3]

me[4]

me[5]

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

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

names[0][2]

names[0][3]

names[0][4]

names[0][5]

Name

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

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

names[1][2]

names[1][3]

names[1][4]

names[1][5]

Name


Static Arrays

Example:

type Coding = record Char c, Integer n

end

var code: array 3 of Coding

type Coding = record Char c, Integer n

end

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;

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

a[0]

a[1]

a[2]

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[k] ] = address[a]+k*size[TE]…

runtime organization (chapter 6) 1 course overview part i: overview material 1introduction 2language...

Documents

runtime organization

representation schema

representation of integers

indirect representation

highlevel language

constantsize representation

lowlevel program

highlevel structures