Compilers and computer architecture:...

Compilers and computer architecture:introduction

Martin Berger 1

Thanks to Chad MacKinney, Alex Jeffery, Justin Crow, Jim Fielding, Shaun Ring and Vilem Liepelt forsuggestions and corrections. Thanks to Benjamin Landers for the RARS simulator.

September 2019

1Email: M.F.Berger@sussex.ac.uk, Office hours: Wed 12-13 inChi-2R312.

1 / 150

Administrative matters: lecturer

I Name: Martin BergerI Email: M.F.Berger@sussex.ac.ukI Web: http://users.sussex.ac.uk/~mfb21/compilersI Lecture notes etc: http://users.sussex.ac.uk/~mfb21/compilers/material.html Linked from Canvas

I Office hour: after the Wednesdays lectures, and onrequest (please arrange by email, seehttp://users.sussex.ac.uk/~mfb21/cal foravailable time-slots)

I My room: Chichester II, 312

2 / 150

I Name: Martin Berger

I Email: M.F.Berger@sussex.ac.ukI Web: http://users.sussex.ac.uk/~mfb21/compilersI Lecture notes etc: http://users.sussex.ac.uk/~mfb21/compilers/material.html Linked from Canvas

3 / 150

I Name: Martin BergerI Email: M.F.Berger@sussex.ac.uk

I Web: http://users.sussex.ac.uk/~mfb21/compilersI Lecture notes etc: http://users.sussex.ac.uk/~mfb21/compilers/material.html Linked from Canvas

4 / 150

I Name: Martin BergerI Email: M.F.Berger@sussex.ac.ukI Web: http://users.sussex.ac.uk/~mfb21/compilers

I Lecture notes etc: http://users.sussex.ac.uk/~mfb21/compilers/material.html Linked from Canvas

5 / 150

6 / 150

7 / 150

8 / 150

Administrative matters: dates, times and assessment

I Lectures: Two lectures per week,Wednesday: 11-12 Lec PEV1-1A7Friday: 17-18 RICH-AS3

I Tutorials: please see your timetables. The TA is ShaunRing sr410@sussex.ac.uk

I There will (probably) be PAL sessions, more soon.I Assessment: coursework (50%) and by unseen

examination (50%). Both courseworks involve writing partsof a compiler. Due dates for courseworks: Fri, 8 Nov 2019,and Fri, 20 Dec 2019, both 18:00.

9 / 150

10 / 150

11 / 150

I There will (probably) be PAL sessions, more soon.

I Assessment: coursework (50%) and by unseenexamination (50%). Both courseworks involve writing partsof a compiler. Due dates for courseworks: Fri, 8 Nov 2019,and Fri, 20 Dec 2019, both 18:00.

12 / 150

13 / 150

Questions welcome!

Please, ask questions ...

I during the lessonI at the end of the lessonI in my office hours (seehttp://users.sussex.ac.uk/~mfb21/cal foravailable time-slots)

I by email M.F.Berger@sussex.ac.ukI on CanvasI in the tutorialsI in the course’s Discord channel (invite is on Canvas)I any other channels (e.g. Telegram, TikTok ...)?

Please, don’t wait until the end of the course to tell me aboutany problems you may encounter.

14 / 150

Questions welcome!Please, ask questions ...

I during the lessonI at the end of the lessonI in my office hours (seehttp://users.sussex.ac.uk/~mfb21/cal foravailable time-slots)

I by email M.F.Berger@sussex.ac.ukI on CanvasI in the tutorialsI in the course’s Discord channel (invite is on Canvas)I any other channels (e.g. Telegram, TikTok ...)?

Please, don’t wait until the end of the course to tell me aboutany problems you may encounter.

15 / 150

Prerequisites

Good Java programming skills are indispensable.This course isnot about teaching you how to program. “Good” in this contextmeans you can do most questions on e.g.

https://leetcode.com/

classified as “Easy” without problems (= without looking up theanswer, and in 1 hour or less). I also recommed that youfamiliarise yourself with the material on “Shell Tools andScripting” and “Command-line Environment” in:

https://missing.csail.mit.edu/

It helps if you have already seen e.g. regular expressions,FSMs etc. But we will cover all this from scratch.

It helps if you have already seen a CPU, e.g. know what aregister is or a stack pointer.

16 / 150

Prerequisites

17 / 150

Prerequisites

18 / 150

Prerequisites

19 / 150

Course content

I’m planning to give a fairly orthodox compilers course thatshow you all parts of a compiler. At the end of this course youshould be able to write a fully blown compiler yourself andimplement programming languages.

We will also look at computer architecture, although moresuperficially.

This will take approximately 9 weeks, so we have time at theend for some advanced material. I’m happy to tailor the courseto your interest, so please let me know what you want to hearabout.

20 / 150

Course content

21 / 150

Course content

22 / 150

Course content

23 / 150

Coursework

Evaluation of assessed courseworks will (largely) be byautomated tests. This is quite different from what you’ve seenso far. The reason for this new approach is threefold.

I Compilers are complicated algorithms and it’s beyondhuman capabilities to find subtle bugs.

I Realism. In industry you don’t get paid for being nice, or forhaving code that “almost” works.

I Fairness. Automatic testing removes subjective element.

Note that if you make a basic error in your compiler then it isquite likely that every test fails and you will get 0 points. So it isreally important that you test your code before submissionthoroughly. I encourage you to share tests and testingframeworks with other students: as tests are not part of thedeliverable, you make share them. Of course the compiler mustbe written by yourself.

24 / 150

CourseworkEvaluation of assessed courseworks will (largely) be byautomated tests. This is quite different from what you’ve seenso far. The reason for this new approach is threefold.

25 / 150

26 / 150

27 / 150

Plan for today’s lecture

Whirlwind overview of the course.

I Why study compilers?I What is a compiler?I Compiler structureI Lexical analysisI Syntax analysisI Semantic analysis, type-checkingI Code generation

28 / 150

29 / 150

I Why study compilers?

I What is a compiler?I Compiler structureI Lexical analysisI Syntax analysisI Semantic analysis, type-checkingI Code generation

30 / 150

I Why study compilers?I What is a compiler?

I Compiler structureI Lexical analysisI Syntax analysisI Semantic analysis, type-checkingI Code generation

31 / 150

I Why study compilers?I What is a compiler?I Compiler structure

I Lexical analysisI Syntax analysisI Semantic analysis, type-checkingI Code generation

32 / 150

I Why study compilers?I What is a compiler?I Compiler structureI Lexical analysis

I Syntax analysisI Semantic analysis, type-checkingI Code generation

33 / 150

I Why study compilers?I What is a compiler?I Compiler structureI Lexical analysisI Syntax analysis

I Semantic analysis, type-checkingI Code generation

34 / 150

I Why study compilers?I What is a compiler?I Compiler structureI Lexical analysisI Syntax analysisI Semantic analysis, type-checking

I Code generation

35 / 150

36 / 150

Why study compilers?

To become a good programmer, you need to understand whathappens ’under the hood’ when you write programs in ahigh-level language.

To understand low-level languages (assembler, C/C++, Rust,Go) better. Those languages are of prime importance, e.g. forwriting operating systems, embedded code and generally codethat needs to be fast (e.g. computer games, ML e.g.TensorFlow).

Most large programs have a tendency to embed a programminglanguage. The skill quickly to write an interpreter or compiler forsuch embedded languages is invaluable.

But most of all: compilers are extremely amazing, beautiful andone of the all time great examples of human ingenuity. After 70years of refinement compilers are a paradigm case of beautifulsoftware structure (modularisation). I hope it inspires you.

37 / 150

Why study compilers?To become a good programmer, you need to understand whathappens ’under the hood’ when you write programs in ahigh-level language.

38 / 150

39 / 150

40 / 150

41 / 150

Overview: what is a compiler?

42 / 150

Overview: what is a compiler?A compiler is a program that translates programs from oneprogramming language to programs in another programminglanguage. The translation should preserve meaning (what does“preserve” and “meaning” mean in this context?).

CompilerSource program Target program

Error messages

Typically, the input language (called source language) is morehigh-level than the output language (called target language)Examples

I Source: Java, target: JVM bytecode.I Source: JVM bytecode, target: ARM/x86 machine codeI Source: TensorFlow, target: GPU/TPU machine code.

43 / 150

Error messages

Typically, the input language (called source language) is morehigh-level than the output language (called target language)

ExamplesI Source: Java, target: JVM bytecode.I Source: JVM bytecode, target: ARM/x86 machine codeI Source: TensorFlow, target: GPU/TPU machine code.

44 / 150

Error messages

45 / 150

Error messages

I Source: Java, target: JVM bytecode.

I Source: JVM bytecode, target: ARM/x86 machine codeI Source: TensorFlow, target: GPU/TPU machine code.

46 / 150

Error messages

I Source: Java, target: JVM bytecode.I Source: JVM bytecode, target: ARM/x86 machine code

I Source: TensorFlow, target: GPU/TPU machine code.

47 / 150

Error messages

48 / 150

Example translation: source program

Here is a little program. (What does it do?)

int testfun( int n ){int res = 1;while( n > 0 ){

n--;res *= 2; }return res; }

Using clang -S this translates to the following x86 machinecode ...

49 / 150

50 / 150

51 / 150

Example translation: target program_testfun: ## @testfun

.cfi_startproc## BB#0:

pushq %rbpLtmp0:

.cfi_def_cfa_offset 16Ltmp1:

.cfi_offset %rbp, -16movq %rsp, %rbp

Ltmp2:.cfi_def_cfa_register %rbpmovl %edi, -4(%rbp)movl $1, -8(%rbp)

LBB0_1: ## =>This Inner Loop Header: Depth=1cmpl $0, -4(%rbp)jle LBB0_3

## BB#2:## in Loop: Header=BB0_1 Depth=1

movl -4(%rbp), %eaxaddl $4294967295, %eax ## imm = 0xFFFFFFFFmovl %eax, -4(%rbp)movl -8(%rbp), %eaxshll $1, %eaxmovl %eax, -8(%rbp)jmp LBB0_1

LBB0_3:movl -8(%rbp), %eaxpopq %rbpretq.cfi_endproc

52 / 150

Compilers have a beautifully simple structure

Analysis phase

Code generation

Source program

Generated program

In the analysis phase two things happen:

I Analysing if the program is well-formed (e.g.checking for syntax and type errors).

I Creating a convenient (for a computer)representation of the source programstructure for further processing. (Abstractsyntax tree (AST), symbol table).

The executable program is then generated fromthe AST in the code generation phase.

Let’s refine this.

53 / 150

Analysis phase

Code generation

Source program

Generated program

54 / 150

Analysis phase

Code generation

Source program

Generated program

55 / 150

Analysis phase

Code generation

Source program

Generated program

56 / 150

Analysis phase

Code generation

Source program

Generated program

57 / 150

Analysis phase

Code generation

Source program

Generated program

58 / 150

Compiler structure

Compilers have a beautifully simple structure. This structurewas arrived at by breaking a hard problem (compilation) intoseveral smaller problems and solving them separately. This hasthe added advantage of allowing to retarget compilers(changing source or target language) quite easily.

Lexical analysis

Syntax analysis

Source program

Semantic analysis,e.g. type checking

Intermediate code generation

Optimisation

Code generation

Translated program

59 / 150

Compiler structureCompilers have a beautifully simple structure. This structurewas arrived at by breaking a hard problem (compilation) intoseveral smaller problems and solving them separately. This hasthe added advantage of allowing to retarget compilers(changing source or target language) quite easily.

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

60 / 150

Compiler structureCompilers have a beautifully simple structure. This structurewas arrived at by breaking a hard problem (compilation) intoseveral smaller problems and solving them separately. This hasthe added advantage of allowing to retarget compilers(changing source or target language) quite easily.

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program61 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

Interesting question: when do these phases happen?

In the past, all happend at ... compile-time. Now some happenat run-time in Just-in-time compilers (JITs). This has profoundinfluences on choice of algorithms and performance.

62 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

63 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

64 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

Another interesting question: do you note some thing about allthese phases?

The phases are purely functional, in that they take one input,and return one output. Modern programming languages likeHaskell, Ocaml, F#, Rust or Scala are ideal for writingcompilers.

65 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

The phases are purely functional, in that they take one input,and return one output. Modern programming languages likeHaskell, Ocaml, F#, Rust or Scala are ideal for writingcompilers.

66 / 150

Compiler structure

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

The phases are purely functional, in that they take one input,and return one output. Modern programming languages likeHaskell, Ocaml, F#, Rust or Scala are ideal for writingcompilers. 67 / 150

Phases: Overview

I Lexical analysisI Syntactic analysis (parsing)I Semantic analysis (type-checking)I Intermediate code generationI OptimisationI Code generation

68 / 150

Phases: Lexical analysis

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

69 / 150

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

70 / 150

What is the input to a compiler?

A (often long) string, i.e. a sequence of characters.

Strings are not an efficient data-structure for a compiler to workwith (= generate code from). Instead, compilers generate codefrom a more convenient data structure called “abstract syntaxtrees” (ASTs). We construct the AST of a program in twophases:

I Lexical anlysis. Where the input string is converted into alist of tokens.

I Parsing. Where the AST is constructed from a token list.

71 / 150

72 / 150

73 / 150

74 / 150

In the lexical analysis, a string is converted into a list of tokens.Example: The program

Is (could be) represented as the list

T_int, T_ident ( "testfun" ), T_left_brack,T_int, T_ident ( "n" ), T_rightbrack,T_left_curly_brack, T_int, T_ident ( "res" ),T_eq, T_num ( 1 ), T_semicolon, T_while, ...

75 / 150

76 / 150

77 / 150

78 / 150

Why is this interesting?

I Abstracts from irrelevant detail (e.g. syntax of keywords,whitespace, comments).

I Makes the next phase (parsing) much easier.

79 / 150

80 / 150

81 / 150

Phases: syntax analysis (parsing)

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

82 / 150

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

83 / 150

This phase converts the program (list of tokens) into a tree, theAST of the program (compare to the DOM of a webpage). Thisis a very convenient data structure because syntax-checking(type-checking) and code-generation can be done by walkingthe AST (cf visitor pattern). But how is a program a tree?

while( n > 0 ){n--;res *= 2; }

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

T_var ( res ) T_mult

T_var ( res ) T_num ( 2 )

84 / 150

Phases: syntax analysis (parsing)This phase converts the program (list of tokens) into a tree, theAST of the program (compare to the DOM of a webpage). Thisis a very convenient data structure because syntax-checking(type-checking) and code-generation can be done by walkingthe AST (cf visitor pattern). But how is a program a tree?

while( n > 0 ){n--;res *= 2; }

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

85 / 150

while( n > 0 ){n--;res *= 2; }

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

86 / 150

while( n > 0 ){n--;res *= 2; }

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

87 / 150

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

I The AST is often implemented as a tree of linked objects.I The compiler writer must design the AST data structure

carefully so that it is easy to build (during syntax analysis),and easy to walk (during code generation).

I The performance of the compiler strongly depends on theAST, so a lot of optimisation goes here for instustrialstrength compilers.

88 / 150

Phases: syntax analysis (parsing)T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

89 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

I The AST is often implemented as a tree of linked objects.

I The compiler writer must design the AST data structurecarefully so that it is easy to build (during syntax analysis),and easy to walk (during code generation).

90 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

91 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

92 / 150

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

The construction of the AST has another important role: syntaxchecking, i.e. checking if the program is syntactically valid!

This dual role is because the rules for constructing the AST areessentially exactly the rules that determine the set ofsyntactically valid programs. Here the theory of formallanguages (context free, context sensitive, and finite automata)is of prime importance. We will study this in detail.

93 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

94 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

95 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

This dual role is because the rules for constructing the AST areessentially exactly the rules that determine the set ofsyntactically valid programs. Here the theory of formallanguages (context free, context sensitive, and finite automata)is of prime importance. We will study this in detail. 96 / 150

T_while

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

Great news: the generation of lexical analysers and parserscan be automated by using parser generators (e.g. lex, yacc).Decades of research have gone into parser generators, and inpractise they generate better lexers and parsers than mostprogrammers would be able to. Alas, parser generators arequite complicated beasts, and in order to understand them, it ishelpful to understand formal languages and lexing/parsing. Thebest way to understand this is to write a toy lexer and parser.

97 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

98 / 150

T_greater

T_var ( n ) T_num ( 0 )

T_semicolon

T_decrement

T_var ( n )

T_update

99 / 150

Phases: semantic analysis

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

100 / 150

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

101 / 150

While parsing can reject syntactically invalid programs, it cannotreject semantically invalid programs, e.g. programs with morecomplicated ’semantic’ mistakes are harder to catch. Examples.

void main() {i = 7int i = 7...

if ( 3 + true ) > "hello" then ...

They are caught with semantic analysis. The key technologyare types. Modern languages like Scala, Rust, Haskell, Ocaml,F# employ type inference.

102 / 150

103 / 150

104 / 150

105 / 150

106 / 150

Phases: intermediate code generation

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

107 / 150

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

108 / 150

There are many different CPUs with different machinelanguages. Often the machine language changes subtly fromCPU version to CPU version. It would be annoying if we had torewrite large parts of the compiler. Fortunately, most machinelanguages are rather similar. This helps us to abstract almostthe whole compiler from the details of the target language. Theway we do this is by using in essence two compilers.

I Develop an intermediate language that captures theessence of almost all machine languages.

I Compile to this intermediate language.I Do compiler optimisations in the intermediate language.I Translate the intermediate representation to the target

machine language. This step can be seen as amini-compiler.

I If we want to retarget the compiler to a new machinelanguage, only this last step needs to be rewritten. Nicedata abstraction.

109 / 150

Phases: intermediate code generationThere are many different CPUs with different machinelanguages. Often the machine language changes subtly fromCPU version to CPU version. It would be annoying if we had torewrite large parts of the compiler. Fortunately, most machinelanguages are rather similar. This helps us to abstract almostthe whole compiler from the details of the target language. Theway we do this is by using in essence two compilers.

110 / 150

111 / 150

I Compile to this intermediate language.

I Do compiler optimisations in the intermediate language.I Translate the intermediate representation to the target

112 / 150

I Compile to this intermediate language.I Do compiler optimisations in the intermediate language.

I Translate the intermediate representation to the targetmachine language. This step can be seen as amini-compiler.

113 / 150

114 / 150

115 / 150

Phases: optimiser

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

116 / 150

Phases: optimiser

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

117 / 150

Phases: optimiser

Translating a program often introduces various inefficiencies,make the program e.g. run slow, or use a lot of memories, oruse a lot of power (important for mobile phones). Optimisers tryto remove these inefficiencies, by replacing the inefficientprogram with a more efficient version (without changing themeaning of the program).

Most code optimisations are problems are difficult (NPcomplete or undecidable), so optimisers are expensive to run,often (but not always) lead to modest improvements only. Theyare also difficult algorithmically. These difficulties areexacerbate for JITs because the are executed at programrun-time.

However, some optimisations are easy, e.g. inlining offunctions: if a function is short (e.g. computing sum of twonumbers), replacing the call to the function with its code, canlead to faster code. (What is the disadvantage of this?)

118 / 150

Phases: optimiserTranslating a program often introduces various inefficiencies,make the program e.g. run slow, or use a lot of memories, oruse a lot of power (important for mobile phones). Optimisers tryto remove these inefficiencies, by replacing the inefficientprogram with a more efficient version (without changing themeaning of the program).

119 / 150

120 / 150

121 / 150

Phases: code generation

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

122 / 150

Lexical analysis

Syntax analysis

Source program

Optimisation

Code generation

Translated program

123 / 150

This straighforward phase translates the generatedintermediate code to machine code. As machine code andintermediate code are much alike, this ’mini-compiler’ is simpleand fast.

124 / 150

This straighforward phase translates the generatedintermediate code to machine code. As machine code andintermediate code are much alike, this ’mini-compiler’ is simpleand fast.

125 / 150

Compilers vs interpreters

Interpreters are a second way to run programs.

CompilerSource program Executable

Output

Source program Interpreter

Output

At runtime.Syntaxerror?

Syntaxerror?

I The advantage of compilers isthat generated code is faster,because a lot of work has tobe done only once (e.g.lexing, parsing, type-checking,optimisation). And the resultsof this work are shared inevery execution. Theinterpreter has to redo thiswork everytime.

I The advantage of interpretersis that they are much simplerthan compilers.

We won’t say much more about interpreters in this course.

126 / 150

Compilers vs interpretersInterpreters are a second way to run programs.

Output

Syntaxerror?

127 / 150

Output

Syntaxerror?

128 / 150

Output

Syntaxerror?

129 / 150

Output

Syntaxerror?

130 / 150

Output

Syntaxerror?

131 / 150

Literature

Compilers are among the most studied and most wellunderstood parts of informatics. Many good books exist. Hereare some of my favourites, although I won’t follow any of themclosely.

I Modern Compiler Implementation in Java (secondedition) by Andrew Appel and Jens Palsberg. Probablyclosest to our course. Moves quite fast.

I Compilers - Principles, Techniques and Tools (secondedition) by Alfred V. Aho, Monica Lam, Ravi Sethi, andJeffrey D. Ullman. The first edition of this book is is theclassic text on compilers, known as the “Dragon Book”, butits first edition is a bit obsolete. The second edition issubstantially expanded and goes well beyond the scope ofour course. For my liking, the book is a tad long.

132 / 150

Literature

133 / 150

Literature

134 / 150

Literature

135 / 150

Literature

Some other material:

I Engineering a Compiler, by Keith Cooper, Linda Torczon.I The Alex Aiken’s Stanford University online course on

compilers. This course coveres similar ground as ours,but goes more in-depth. I was quite influenced by Aiken’scourse when I designed our’s.

I Computer Architecture - A Quantitative Approach (sixthedition) by John Hennessey and David Patterson. This isthe ’bible’ for computer architecture. It goes way beyondwhat is required for our course, but very well written bysome of the world’s leading experts on computerarchitecture. Well worth studying.

136 / 150

Literature

137 / 150

Literature

I Engineering a Compiler, by Keith Cooper, Linda Torczon.

I The Alex Aiken’s Stanford University online course oncompilers. This course coveres similar ground as ours,but goes more in-depth. I was quite influenced by Aiken’scourse when I designed our’s.

138 / 150

Literature

139 / 150

Literature

140 / 150

How to enjoy and benefit from this course

I Assessed coursework is designed to reinforce andintegrate lecture material; it’s designed to help you passthe exam

I Go look at the past papers - now.I Use the tutorials to get feedback on your solutionsI Substantial lab exercise should bring it all togetherI Ask questions, in the lectures, in the labs, on Canvas or in

person!I Design your own mini-languages and write compilers for

them.I Have a look at real compilers. There are many free,

open-source compilers, g.g. GCC, LLVM, TCC, MiniML,Ocaml, the Scala compiler, GHC, the Haskell compiler.

141 / 150

142 / 150

I Go look at the past papers - now.

I Use the tutorials to get feedback on your solutionsI Substantial lab exercise should bring it all togetherI Ask questions, in the lectures, in the labs, on Canvas or in

143 / 150

I Go look at the past papers - now.I Use the tutorials to get feedback on your solutions

I Substantial lab exercise should bring it all togetherI Ask questions, in the lectures, in the labs, on Canvas or in

144 / 150

I Go look at the past papers - now.I Use the tutorials to get feedback on your solutionsI Substantial lab exercise should bring it all together

I Ask questions, in the lectures, in the labs, on Canvas or inperson!

I Design your own mini-languages and write compilers forthem.

I Have a look at real compilers. There are many free,open-source compilers, g.g. GCC, LLVM, TCC, MiniML,Ocaml, the Scala compiler, GHC, the Haskell compiler.

145 / 150

person!

I Design your own mini-languages and write compilers forthem.

146 / 150

147 / 150

148 / 150

Feedback

In this module, you will receive feedback through:I The mark and comments on your assessmentI Feedback to the whole class on assessment and examsI Feedback to the whole class on lecture understandingI Model solutionsI Worked examples in class and lectureI Verbal comments and discussions with tutors in classI Discussions with your peers on problemsI Online discussion forumsI One to one sessions with the tutors

The more questions you ask, the more you participate indiscussions, the more you engage with the course, the morefeedback you get.

149 / 150

Questions?

150 / 150

Compilers and computer architecture:...

Documents

Partial Compilers

DIOS - compilers

Basics Compilers

Register Allocation on the Intel® Itanium® Architecture · 2015. 2. 9. · 1.1 Compilers and Optimizations Optimizing compilers can be thought of a 3-stage process, which transforms

Compilers Notes

Mod02 compilers

Compilers and computer architecture: Semantic …users.sussex.ac.uk/~mfb21/compilers/slides/6-handout.pdfDynamic vs static typing An important distinction is that between dynamically

Honors Compilers

Contemporary Compilers

CS153: Compilers Lecture 13: Compiling functions · Compiling functions Stephen Chong https: ... compilers”, “This is not supposed to be an ocaml ... Basic Architecture Parsing

Compilers and computer architecture: Parsing

Chapter 2 Parallel Architecture, Software And Performance · 2014. 4. 8. · Fast. Easy to use. Vectorizing compilers are good at identifying code to exploit. –Compilers also can

Architecture and Compilers PART I - Florida State Universityengelen/courses/HPC-2008/... · · 2008-09-02Architecture and Compilers PART I HPC Fall 2008 ... CISC instructions to

Compilers Ide

HiPEAC Roadmaps - it.uu.seHiPEAC = High-Performance Embedded Architecture and Compilers-- an EU FP7 Network of Excellence --2

Compilers Overview.ppt

Compilers and computer architecture: Compiling OO languageusers.sussex.ac.uk/~mfb21/compilers/slides/13-handout.pdf · Object layout in memory We solve these problems using the following

Compilers programmingembedded

Machine Learning, Compilers and Mobile Systemshomepages.inf.ed.ac.uk/hleather/publications/2012...Machine Learning, Compilers and Mobile Systems Institute for Computing Systems Architecture

Efficient Formally Secure Compilers to a Tagged Architecture · 2016. 8. 28. · Computers are insecure •devastating low-level vulnerabilities •programming languages, compilers,