Exam Topics Hal Perkins Winter 2008

Slides:

Advertisements

Similar presentations

Compiler construction in4020 – lecture 4 Koen Langendoen Delft University of Technology The Netherlands.

Advertisements

Mooly Sagiv and Roman Manevich School of Computer Science

6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture (From slides by G. Necula & R. Bodik)

Cpeg421-08S/final-review1 Course Review Tom St. John.

Recap Mooly Sagiv. Outline Subjects Studied Questions & Answers.

FE.1 CSE4100 Final Exam Advice and Hints Prof. Steven A. Demurjian, Sr. Computer Science & Engineering Department The University of Connecticut 191 Auditorium.

Compiler Summary Mooly Sagiv html://

Table-driven parsing Parsing performed by a finite state machine. Parsing algorithm is language-independent. FSM driven by table (s) generated automatically.

Parsing Wrap-up. from Cooper and Torczon2 Filling in the A CTION and G OTO Tables The algorithm Many items generate no table entry  Closure( ) instantiates.

CSE 413 Programming Languages & Implementation Hal Perkins Autumn 2012 Context-Free Grammars and Parsing 1.

8/19/2015© Hal Perkins & UW CSEC-1 CSE P 501 – Compilers Parsing & Context-Free Grammars Hal Perkins Winter 2008.

10/1/2015© Hal Perkins & UW CSEG-1 CSE P 501 – Compilers Intermediate Representations Hal Perkins Autumn 2009.

COP 4620 / 5625 Programming Language Translation / Compiler Writing Fall 2003 Lecture 10, 10/30/2003 Prof. Roy Levow.

Joey Paquet, Lecture 12 Review. Joey Paquet, Course Review Compiler architecture –Lexical analysis, syntactic analysis, semantic.

CS 153 A little bit about LR Parsing. Background We’ve seen three ways to write parsers:  By hand, typically recursive descent  Using parsing combinators.

Syntactic Analysis Natawut Nupairoj, Ph.D. Department of Computer Engineering Chulalongkorn University.

1 Lecture 5: Syntax Analysis (Section 2.2) CSCI 431 Programming Languages Fall 2002 A modification of slides developed by Felix Hernandez-Campos at UNC.

Compiler Principles Fall Compiler Principles Lecture 0: Local Optimizations Roman Manevich Ben-Gurion University.

Compiler Principles Fall Compiler Principles Lecture 6: Parsing part 5 Roman Manevich Ben-Gurion University.

Compiler Introduction 1 Kavita Patel. Outlines 2  1.1 What Do Compilers Do?  1.2 The Structure of a Compiler  1.3 Compilation Process  1.4 Phases.

Top-Down Parsing CS 671 January 29, CS 671 – Spring Where Are We? Source code: if (b==0) a = “Hi”; Token Stream: if (b == 0) a = “Hi”; Abstract.

10/10/2002© 2002 Hal Perkins & UW CSED-1 CSE 582 – Compilers LR Parsing Hal Perkins Autumn 2002.

Compiler Principles Fall Compiler Principles Lecture 5: Parsing part 4 Roman Manevich Ben-Gurion University.

CH4.1 CSE244 Midterm Subjects Aggelos Kiayias Computer Science & Engineering Department The University of Connecticut 371 Fairfield Road, Box U-155 Storrs,

1 Compiler Construction Overview. 2 Today’s Goals Summary of the subjects we’ve covered Perspectives and final remarks.

Review 1.Structure of the course Lexical Analysis Syntax Analysis Grammar & Language RG & DFA Top-down LL(1) Parsing Bottom-Up LR Layered Automation Semantic.

2016/7/9Page 1 Lecture 11: Semester Review COMP3100 Dept. Computer Science and Technology United International College.

Compiler Summary Lexical analysis—scanner – String of characters  token – Finite automata. Syntactical analysis – parser – Sequence of tokens –> language.

Announcements/Reading

Chapter 1 Introduction.

Closed book, closed notes

Parsing & Context-Free Grammars

Programming Languages Translator

50/50 rule You need to get 50% from tests, AND

Table-driven parsing Parsing performed by a finite state machine.

Chapter 1 Introduction.

Fall Compiler Principles Lecture 4: Parsing part 3

Compiler Lecture 1 CS510.

CMPE 152: Compiler Design December 5 Class Meeting

Fall Compiler Principles Lecture 4: Parsing part 3

CS416 Compiler Design lec00-outline September 19, 2018

Parsing & Context-Free Grammars Hal Perkins Autumn 2011

(Slides copied liberally from Ruth Anderson, Hal Perkins and others)

Top-Down Parsing CS 671 January 29, 2008.

Intermediate Representations Hal Perkins Autumn 2011

Introduction CI612 Compiler Design CI612 Compiler Design.

CPSC 388 – Compiler Design and Construction

Optimizing Transformations Hal Perkins Autumn 2011

CSE401 Introduction to Compiler Construction

LALR Parsing Adapted from Notes by Profs Aiken and Necula (UCB) and

Compiler Construction

Optimizing Transformations Hal Perkins Winter 2008

LL and Recursive-Descent Parsing Hal Perkins Autumn 2011

Register Allocation Hal Perkins Summer 2004

Subject: Language Processor

Exam Topics Hal Perkins Autumn 2009

Intermediate Representations Hal Perkins Autumn 2005

CS416 Compiler Design lec00-outline February 23, 2019

Fall Compiler Principles Lecture 4: Parsing part 3

Compiler Construction

Kanat Bolazar February 16, 2010

Parsing & Context-Free Grammars Hal Perkins Summer 2004

LL and Recursive-Descent Parsing Hal Perkins Autumn 2009

LL and Recursive-Descent Parsing Hal Perkins Winter 2008

Lec00-outline May 18, 2019 Compiler Design CS416 Compiler Design.

CSE P 501 – Compilers SSA Hal Perkins Autumn /31/2019

Parsing & Context-Free Grammars Hal Perkins Autumn 2005

Lecture 11 LR Parse Table Construction

Compiler design Review COMP 442/6421 – Compiler Design

Presentation transcript:

Exam Topics Hal Perkins Winter 2008 CSE P 501 – Compilers Exam Topics Hal Perkins Winter 2008 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Logistics Exam targeted for 90 min. Open textbook(s) – whichever one or two books you use regularly Open slides with annotations But no additional sources, laptops, pdas, etc. 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Content Most anything covered this quarter, with a bias towards things you’ve done on assignments or in the project General familiarity with other topics we’ve talked about, but not implementation details Note: This is the ppt version of the summary already on the course web – hopefully nothing new or surprising 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Grammars Regular expressions and DFAs Scanners – principle of longest match, describing scanners with a DFA, etc. Context-free grammars Derivations (leftmost, rightmost) Ambiguities and how to resolve them Particularly precedence and associativity First, follow, and nullable 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Parsing Basics of LL and LR parsing LL parsing and recursive descent LR (shift-reduce) parsing Items, constructing LR states and tables Conflicts – significance of shift/reduce and reduce/reduce; how to fix LR(0) vs SLR lookahead 11/20/2019 © 2002-08 Hal Perkins & UW CSE

IRs and Static Semantics AST representation of programs Symbol tables & type checking What sort of information is collected? What sort of questions can this analysis answer? 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Code Shape – Particularly x86 Implementing common language constructs in x86 (assignment, loops, conditionals) Procedural programming Function call conventions Stack layout and storage allocation Object-oriented programming Object creation and layout Dynamic dispatch and method override Be able to read/write simple x86 code 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Overview of Back-End Issues Instruction selection Instruction scheduling – particularly list scheduling; operation latencies Register allocation – interference graphs, graph coloring Know the general ideas here; you are not expected to, e.g., be able to implement a graph-coloring allocator in detail 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Optimization Basics (1) Control flow graph and basic blocks Analysis overview Value numbering Dataflow equations (in, out, use, def) Dominator relationships Be able to set up analysis framework for a problem, or solve simple instances of a problem (e.g., live variables) 11/20/2019 © 2002-08 Hal Perkins & UW CSE

Optimization Basics (2) Know some common optimizations and what is needed to allow them Common subexpression elimination, dead code elimination, loop hoisting, induction variables, etc. Conservative analysis – when is a proposed transformation safe? Basic ideas about interaction between code and memory hierarchy – loop transformations for better cache utilization 11/20/2019 © 2002-08 Hal Perkins & UW CSE