CS 375: Compilers: Online

CS 375 Class Web Page

Note: Links will be filled in after the lectures occur.

Lectures from Spring 2025

• January 14, 2025:
  • Lexer vs. Parser; Pascal vs. C
  • Machine Language, Assembly, Programmer Cost
  • Disk and Buffering; Lexical Ambiguity
  • Double Buffering; Character Codes; Tokens

• January 16, 2025:
  • C strings
  • Token fields; Numbers as Characters
  • Integer Number Conversion
  • Floating Point

• January 23, 2025:
  • Running lexanc; Float Representation
  • Float Conversion; Range Test
  • Floating +: Not Associative; SNaN
  • Chomsky Hierarchy; Hierarchy of Parsers
  • Ambiguity

• January 28, 2025:
  • Hierarchy of Parsers; Tree Grammar
  • lex
  • number; return vs yylval; commentsinlex.txt
  • yytext, yyleng

• January 30, 2025:
  • Context Free: Recursive, Counting
  • Derivation; Ambiguity Cases
  • Parser: Recursive Descent; Deep Structure
  • Unambiguous Grammar; Shift, Reduce

• february 4, 2025:
  • string in lex; Parser Options
  • Associativity; Shift and Reduce Operations
  • Operator Precedence Examples
  • Operator Precedence with Parens; Push, Pop
  • Starter Files; Unary Minus
  • Function Call, Array Reference

Lectures from Fall 2024

• August 27, 2024:
  • Pascal vs. C; Cost of Programming
  • Disk; Character Buffer; Lexical Ambiguity
  • Double Buffering; Table Lookup; Character Codes
  • TOKEN Pointer

• August 29, 2024:
  • cs375 files; C strings
  • Identifier strings; Number Character Codes
  • Integer Number Conversion
  • Floating Number Conversion
  • Floating Number Representation

• September 3, 2024:
  • Floating Point; Context Free Grammar
  • Ambiguity; Chomsky Hierarchy
  • Lexer, Parset stack; lex
  • Regular Expressions

• September 5, 2024:
  • Regular Expressions; lex rules
  • return() and yylval; yytext; comments
  • Parser Levels; Context Free
  • Top-Down vs. Bottom-Up Parsing

• September 10, 2024:
  • Top-down Parsing; Parser options
  • Shift and Reduce Operations; Tree Form; Left Associativity
  • Floating Add Is Not Associative
  • Operator Precedence Parsing Examples
  • Parentheses; Push and Pop

• September 12, 2024:
  • Operator Precedence; Starter Files
  • Operator Precedence: Unary, Function Calls
  • Recursive Descent: Grammar Becomes Code
  • Shift-Reduce Parser; Sequence of Statements
  • Constructing Output for Begin Statement

• September 17, 2024:
  • Recycling Tokens
  • Parser Options; Begin Statement
  • If Statement; Building in Observability with Trace Vector
  • Edit Distance, Error Correction; Loop Test

• September 19, 2024:
  • for statement; while statement
  • Binding; Hashing
  • Hash with Buckets; Lexical Scoping
  • Pre-defined Symbols; Starter Files

• September 24, 2024:
  • symtab.txt ; Symbolic Constants, Subrange
  • var statement; block ordering
  • Stack Addressing
  • Address Alignment
  • Padding; Scope; Record References

• September 26, 2024:
  • Record Declaration
  • Array Size; Type Inforence for Operators
  • Type Lattice, Data Sizes; 3 Reference Steps
  • Array Reference and Canonical Form
  • Row-Major Order; Rightmost Subscript Should Be Inner Loop

• October 1, 2024:
  • Structure References: yacc Code, Record, Array
  • Combined Array and Record Reference
  • Circular References
  • References as Walk through Type Tree
  • Ways to Tag Variables; Sound, Complete

• October 3, 2024:
  • Variant Records (Union Types)
  • Java: Meaning of == vs. .equals()
  • Structural Eaquivalence; Intermediate Code
  • Quadruples; Peephole; Reverse Polish

• October 8, 2024:
  • Absolute File; Loader; Memory Banks
  • Backpatching; Collecting Files in Linker
  • Relocation Possibilities; DLL

• October 10, 2024:
  • Formatting Numbers for Output
  • Math Functions; Newton-Raphson Iteration
  • I/O Statements; Maintaing Your Own Free List
  • Buddy System; malloc(); Mark-and-Sweep; Copying
  • Reference Counting Garbage Collection

• October 15, 2024:
  • Function Call Stack
  • Interpreted Code; Code Generation Hierarchy
  • Code Generation for progn, Assignment
  • Code Generation for Expressions; Constants

• October 17, 2024: Review for Midterm
  • Record and Array Addressing
  • Operator Precedence Parsing
  • Hashing; Regular Expression; Grammars
  • Kinds of Grammar, Language
  • Context Free; Floating Point

• October 24, 2024:
  • Record Declarations: instfields, nconc, instrec
  • genarith; Constants and Literals
  • Memory Hierarchy; Register used table
  • Registers Needed; Data Flow

• October 29, 2024:
  • Structure Access; Pointer
  • Subrange, 1-D Array
  • RAX contains EAX; Stack Addressing
  • Arithmetic Instructions and genarith()

• October 31, 2024:
  • Structure References and Types
  • 2-D Array Reference
  • Condition Code Register and Jumps
  • Intrinsic Functions; IF statement
  • IF Optimization; Array Addressing

• November 5, 2024:
  • Call by Reference, Call by Value
  • Algol; C define: Textual Substitution
  • Closed vs. In-Line Subroutine
  • Pareto Distribution: Most Time Spent in Loops
  • Keeping Loop Index in a Register

• November 7, 2024:
  • Partial Evaluation
  • Use of Flow Graph; Bit Vectors to Represent Sets
  • Propagating Available through Graph; Un-Initialized Data

• November 12, 2024:
  • Def-Use Chain; Data Flow for Error Checking
  • Graph Coloring for Register Allocation; Hoisting
  • Strip Mining; Post-Increment
  • Memoization; Moving Code
  • Store Multiple; Multiple Condition Codes; Cache Prefetch
  • SPARC Register Stack and Windows

• November 14, 2024:
  • Getting Started on Code Generation
  • Object Oriented Programming
  • Dynamic Dispatch; Time and Space Overhead

• November 19, 2024:
  • Object = Record + Class Designator
  • Basic Types as Objects; Extending Data
  • Inheritance, Shadowing, vtable
  • Multiple Inheritance Causes Problems

• November 21, 2024:
  • OOP Implementation; Pattern Matching

• December 3, 2024:
  • Saving Register for funcall
  • Starting Code Generation
  • Substitute, Match, Transform
  • Top-down, Recursive Descent Parser

• December 5, 2024: Review
  • Array, Record, Pointer Addressing
  • Grammar and Chomsky Hierarchy
  • Local Optimization; Avaiable, Busy; OOP Overhead
  • Basic Blocks; Call by Reference, Value
  • Architecture and Compiler; Ambiguity; Reverse Polish

Lectures from Spring 2024

• January 16, 2024:
  • Pascal vs. C
  • Cost of Programmer, cost of Bugs
  • Disk and Input Buffering; Double Buffering
  • Character Codes; Table Lookup; Pointer to Token

• January 18, 2024:
  • Strings in C
  • Number Conversion ...
  • Number Conversion
  • Floating Point Numbers

• January 23, 2024:
  • Floating Point: Accuracy
  • Floating Point Add is Not Associative
  • SNaN; Chomsky Hierarchy of Grammars/Languages
  • Context Free: Tree Grammar; Ambiguity and IF

• January 25, 2024:
  • Hierarchy of Parsers; Ambiguity
  • lex Examples; Finite State Machine
  • lex Definitions
  • lex return vs. yylval; comments; making tokens

• January 30, 2024:
  • Hierarchy of Parsers; Context Free
  • Derivation; Top-Down Parsing
  • Expressions: Precedence, Addociativity; Shift

• February 1, 2024:
  • Tree Form; Operator Precedence Example
  • Operator Precedence Examples
  • Associativity; Stack Operations in C
  • Other Considerations in Expressions
  • Function Call; Parser Options
  • Recursive Descent Parsing

• February 6, 2024:
  • yacc; begin-end
  • Tree for begin-end, expressions
  • Observability: Debug Bit Vector

• February 8, 2024:
  • pasgram.txt; trivb.tree; yacc precedence
  • Pascal for loop: Test at Top
  • parse.h: Signatures; Pascal Program Structure

• February 13, 2024:
  • Hashing; Hash with Buckets
  • Lexical Scope; Predefined Symbols; Symbolic Constants
  • Enumerated Types; variable and findid()
  • Program line; Variable Layout in Memory
  • CPU vs. Memory: Data must be Word-Aligned

• February 15, 2024:
  • Notes on trivb.pas Assignment
  • Storage Allocation: Padding; Symbol Functions
  • Variant Records
  • Arrays: Size, Low Bound
  • Type Inference and Coercion

• February 20, 2024:
  • Structures: Grammar; Records, Arrays
  • Array Addressing
  • Row-Major Order, Locality

• February 22, 2024:
  • 3 Addressing Steps; Array Reference Tree
  • Combining aref Constants; Circular Type References
  • Pointer Dereference; Walk through Type Tree
  • static, dynamic, sound, complete
  • Possible Causes of Type Errors

• February 27, 2024:
  • Type Tagging at Runtime
  • eq vs. equal in Lisp; == vs. .equals() in Java
  • Structural Equivalence; Type Signatures; Quadruples
  • Parsing to Reverse Polish

• February 29, 2024:
  • Function Return Type; Repeat Loop
  • Repeat Loop Tree; Absolute File and Loading
  • Intension; Backpatching
  • Linker: Resolving Symbols Across Modules

• March 5, 2024:
  • segfault and function calls; record example
  • Record Definition and Access
  • Operator Precedence Parsing
  • Hashing; Regular Expressions; Regular Grammar
  • Grammar Rewriting; Left-Associative

• March 19, 2024:
  • Links among Program Modules
  • Relocation: No Change, Relocate, External; DLL
  • sqrt: Newton-Raphson Iteration
  • sqrt in your head; sin, cos, exp; Integer Output
  • Floating Output; Compound I/O Statements

• March 21, 2024:
  • findtype(); Making Symbol Records
  • Record Declarations and Symbol Structure
  • Combining Freed Memory Blocks; Own Freelist
  • Garbage Collection

• March 26, 2024:
  • Subrange; 1-D Array Reference
  • 2-D Array Reference
  • Call Overhead; Dynamic Flow Graph and Stack
  • Interpreted Code

• March 28, 2024:
  • Labels; Multiply-dimensioned Arrays
  • Multiply-dimensioned Array Reference; Pointers
  • Code Generation Stack; progn
  • Assignment Statement; genarith()
  • Constants; genarith() in C

• April 2, 2024:
  • Special Functions: writeln and new
  • Memory Hierarchy; Register Pairing; used table
  • Register Use in Expression; Data Flow
  • RAX contains EAX; x86 Stack Addressing

• April 4, 2024:
  • Code Generation; Stack Variable Addressing
  • Arithmetic Expression and Instructions
  • Condition Code Register
  • Intrinsic Functions; IF Statement Generation
  • Special Cases of IF

• April 9, 2024:
  • Array Addressing
  • Call by Value, Reference
  • Call in Java; C macros
  • Closed vs Open Subroutine Call; Inlining

• April 11, 2024:
  • Code Gen Stack; Registers; Hints
  • Pareto Distribution; Optimize Loops!
  • Partial Evaluation

• April 16, 2024:
  • Stack Machine; Common Subexpression; dead code
  • Bit Vectors; Dominator and Back Arc
  • Available; Killed
  • Busy, Def-Use Chains; Graph Coloring
  • 4-Color Theorem (does not apply to compilers)

• April 18, 2024:
  • genaref: Load vs. Store
  • genaref: Pointer vs. Array
  • Def-Use Chain; Graph Coloring; Hoisting
  • Postincrement; Speedup; Strip Mining
  • Memoization; Cache Prefetch
  • Branch Prediction; Register Windows

• April 23, 2024:
  • Object = Record + Class
  • Subclasses: Add Variables, Methods
  • Multiple Inheritance; Optimization

• April 25, 2024:
  • Record and Array Addressing
  • Language Classes
  • Optimization; OOP
  • Call by Referencee, Value
  • Architecture and Compiler

Lectures from Fall 2023

• August 22, 2023:
  • Languages: Pascal, Machine, Assembly
  • Economics of Programming
  • Disk, Buffering; Lexical Ambiguity
  • Double Buffering; Character Codes

• August 24, 2023:
  • Starting Lexer; C strings
  • Storing Identifier Names
  • Integer Number Conversion
  • Overflow; IEEE Floating Point
  • Preview: Floating Point Conversion

• August 29, 2023:
  • Floating Point Conversion
  • Floating Point: Fractions are Approximate; SNaN
  • Grammars; Ambiguity; Chomsky Hierarchy

• August 31, 2023:
  • Hierarchy of Parsers; lex and Finite State Machine
  • lex
  • yytext, yyleng, comments

• September 5, 2023:
  • Contex Free Parsing; Derivation
  • Top-Down vs. Bottom-Up Parsing; Unambiguous Expression Grammar; Shift Operation
  • Associativity; First-Child / Next-Sibling Tree
  • Operator Precedence Parsing Example

• September 7, 2023:
  • Tree; Shift Operation; Operator Precedence
  • Operator Precedence Examples
  • Push, Pop; Detecting Unary -
  • Function Call, Array Reference
  • Recursive Descent

• September 12, 2023:
  • Yacc: begin-end, Expression Tree
  • Observability; Debug Printouts; Tree Form
  • Yacc Conflicts: Reduce/Reduce, Shift/Reduce

• September 14, 2023:
  • lex numbers, strings; Edit Distance; Loops
  • for loop flowchart; parse.h
  • Hashing, Hash with Buckets

• September 19, 2023:
  • Lexical Scope, Pre-defined Names
  • const and subrange
  • Variable and findid(); Block Order
  • Allocating Variables; CPU vs. Memory
  • Storage Alignment

• September 21, 2023:
  • Symbol Table Routines; Record vs. Array
  • Type Inference
  • Type Lattice; Traversing Type Tree
  • Variable Steps; Record Reference
  • Array Reference

• September 26, 2023:
  • Label Number; Function Call
  • Record Example
  • Array Reference; Row-Major Order
  • Locality: Rightmost Subscript is Inner Loop
  • Circular Type Reference; Type Tree
  • Static and Dynamic Types

• September 28, 2023:
  • Static vs. Dynamic Typing
  • Identifying Dynamic Type; eq vs. equal
  • Java: == Means Same Address for Reference Types
  • Sound and Complete; Type Issues
  • Type Checking: Structural vs. Name Equivalence

• October 3, 2023:
  • Quadruples; Parsing to Reverse Polish
  • Executing RPN; Absolute File and Loading
  • Banked Memory; Backpatching

• October 5, 2023:
  • Linker: Links between Programs; Literal vs. Immediate
  • Dynamically Linked Library (DLL); sin() series
  • sqrt(): Newton-Raphson Iteration
  • Converting Numbers for Printing
  • I/O Statements; Stack vs. Heap

• October 10, 2023:
  • Stack and Heap; Free List, Buddy System; malloc
  • Garbage Collection: Mark and Sweep; Copying; Reference Counting
  • Avoiding GC in Java; Function Call Overhead
  • Interpreted Code

• October 12, 2023:
  • Function Result Type
  • Record and Array
  • Operator Precedence Parsing
  • Parsing to Reverse Polish; Hashing
  • Regular Expressions; Grammar
  • Grammar and Tree; Grammar and its Language

• October 19, 2023:
  • Label Table; Record Declaration
  • Record Declaration and Reference
  • Code Generation for Statements
  • Code Generation for Expressions
  • Registers: used table

• October 24, 2023:
  • Subrange; Register Used Table
  • Register usage in Expressions; Data Flow
  • X86 Variable Addressing; Code Generation for Expressions
  • Compare and Jump

• October 26, 2023:
  • Array Reference
  • 2-D Array Reference
  • IF Statement Flowchart
  • Optimizing IF; Array Addressing
  • Pointer Dereference

• October 31, 2023:
  • Call by Value, Reference
  • C Macros; Closed vs. In-line Subroutine
  • Pareto Distribution; Optimization

• November 2, 2023:
  • Loop Unrolling; Partial Evaluation
  • Partial Evaluation Examples
  • Reachability, Dead Code Elimination; Bit Vectors

• November 7, 2023:
  • Pointers and Record References
  • Combined arefs
  • NIL; Dominator; Data Flow; Computed, Killed
  • Available and Basic Blocks

• November 9, 2023:
  • MOV: Addressing for Variables
  • Available, Busy/Live, Use in Error Detection
  • Def-Use Chains, Graph Coloring for Register Allocation
  • Hoisting; Strip Mining; Postincrement

• November 14, 2023:
  • Code Generation for IF Statement
  • Memoization; Reusing Result in Hardware
  • Cache Prefetch; Code Reordering; Branch Prediction Bit
  • Register Windows; Discrete Event Simulation

• November 16, 2023:
  • Code Generation for AREF; Object = Record + Class
  • Extending Instance Variables: Stack
  • Extending Methods; Multiple Inheritance

• November 28, 2023:
  • Code Generation for AREF
  • AREF as LHS of Assignment
  • Pointer op and CLTQ
  • Object Representation; Deadlines

• November 30, 2023:
  • Due Dates and Exam Study Resources
  • Records and Arrays
  • Robot Question; Language Classes; Local Optimization
  • Available, Busy, Killed; OOP Penalties
  • Call by Reference, Value; What to Optimize
  • Context Free; Regular Expression
  • Reverse Polish

Lectures from Summer 2023

• July 10, 2023:
  • Pascal vs. C; Cost of Programmer
  • Buffering Characters; Lexical Ambiguity
  • Double Buffering; Character Codes

• July 11, 2023:
  • Character Classes; C Strings
  • Integer Number Conversion
  • Integer Sizes; Overflow; Other Number Bases
  • Floating Point

• July 12, 2023:
  • Floating Point
  • Floating Point Conversion
  • Associativity, SNaN
  • Languages and Grammar
  • Ambiguity: if statement, Expressions

• July 13, 2023:
  • lex: finite automaton to table-driven parser
  • lex examples
  • lex data; hierarchy of parsers
  • Context Free

• July 14, 2023:
  • Parser; Derivations
  • Ambiguity; Top-Down vs. Bottom-Up Parsers
  • Unambiguous Grammar; Shift Operation; Associativity
  • Operator Precedence Parsing Examples
  • Example with Parentheses

• July 17, 2023:
  • Operator Precedence Parsing
  • Operator Precedence Examples
  • Push and Pop on C Stack
  • Other Parsing Issues: Function Calls
  • Recursive Descent Parsing

• July 18, 2023:
  • String Transfer; Yacc; begin - end
  • begin-end processing; expressions and binop()
  • Trace Vector; Yacc Starter File Example
  • Spelling Correction and DWIM

• July 19, 2023:
  • Looping Statement: Expand into Basic Code
  • Symbol Table; Scope; Hashing
  • Hashed with Buckets; Nested Scopes
  • Pre-Defined Symbols

• July 20, 2023:
  • Symbolic Constant, Subrange
  • Variable Declaration, Block Structure
  • Memory Alignment
  • Records, Array: Fencepost Error

• July 21, 2023:
  • Changes for trivb.pas; Record Padding
  • Variant Records or Union Types
  • Type Coercion; Type Lattice
  • Types as Tree/Graph Structure; 3 Steps
  • Array Reference

• July 24, 2023:
  • Notes on Assignment; 3 Reference Steps
  • AREF for Records, Arrays
  • Importance of Memory Locality; Row-Major Order
  • Compound Reference; Circular References
  • Structure Access is a Walk through Type Graph

• July 25, 2023:
  • Dynamic Type Checking
  • Static Typing, Strongly Typed
  • int vs. Integer Trap : == Means Same Address
  • Structural Equivalence; Quadruples

• July 26, 2023: Review for Midterm
  • Record and Array Addressing
  • Operator Precedence Parsing
  • Hashing, Regular Expressions
  • Grammars and Language Classes

• July 28, 2023:
  • Changes for graph1.pas
  • Function Result Type; Intermediate Code
  • Parsing to Reverse Polish; Absolute File and Loader
  • Backpatching

• July 31, 2023:
  • Questions on graph1.pas; Linking Process
  • Relocation Cases; Dynamically Linked Library (DLL)
  • Math Library; Newton-Raphson Iteration
  • Approximate Square Root

• August 1, 2023:
  • Newton-Raphson Iteration; findtype()
  • Record Declaration and Reference
  • Number Conversion for Output
  • I/O Statements; Maintaining Your Own Free List
  • Fragmentation; Mark-and-Sweep Garbage Collection
  • Copying Garbage Collection; Reference Counting

• August 2, 2023:
  • Array References
  • Multi-Dimensional Array References
  • Stack Frame, Interpreted Code
  • Code Generation: progn, :=

• August 3, 2023:
  • Pointer Dereference
  • Code Generation: Assignment -> genarith()
  • genarith() in C
  • Immediate Operand, Literals, Registers

• August 4, 2023:
  • Register Allocation: Used Table
  • X86 Registers; Volatile Registers
  • Variable Addressing on Stack
  • Arithmetic; Condition Code and Jump

• August 7, 2023:
  • Saving Register for Funcall
  • Code Generation for If Statement
  • Array Reference; Call by Value, Reference
  • Call by Value: Safe; by Reference: Fast for Arrays

• August 8, 2023:
  • Aliasing; C Macros; In-Line Compilation
  • Local vs. Global Optimization; Pareto Distribution
  • Partial Evaluation

• August 9, 2023:
  • Starting Code Generation Assignment
  • genarith(), Code Generation
  • Program Analysis: Detecting Errors, Improving Code
  • Data Flow, Available on Entry
  • Graph Coloring for Register Allocation

• August 10, 2023:
  • Hoisting; Memoization; Cache Prefetch
  • Branch Prediction; Register Windows; Strip Mining
  • Instance = Record + Class; Extending Data in Subclass
  • Shadowing and Inheritance

• August 11, 2023:
  • Aref Parsing and Code
  • Aref Generation; Object, Method
  • Review: Record and Array Storage
  • Array and Record Reference; Language Type
  • Optimization; Call by Reference, Value

Lectures from Spring 2023

• January 10, 2023:
  • Pascal vs. C; Machine, Assembly Language
  • Economics; Disk Latency
  • Character Buffering
  • Character Codes

• January 12, 2023:
  • Strings in C
  • Accessing token parts; Integer Numbers
  • Integer Number Conversion
  • Floating Point; Floats are Approximate

• January 17, 2023:
  • IEEE Floating Point
  • Floating Point Number Conversion
  • Floating Point: Not Associative; SNaN
  • Language,Grammar, Ambiguity
  • IF Statement Ambiguity

• January 19, 2023:
  • Hierarchy of Parsers; Finite Automaton
  • lex
  • lex Rules, return values
  • lex character buffer, comments

• January 24, 2023:
  • Hierarchy of Parsers; Context-Free Grammar
  • Language, Derivation, Ambiguity
  • Unambiguous Parsing; Shift

• January 26, 2023:
  • Left Associative; Parser Options; Shift and Stacks
  • First-Child / Next-Sibling Tree
  • Operator Precedence Parsing
  • Operator Precedence with Parens; Push/Pop
  • Starter Files; Function Calls, Subscripts
  • Recursive Descent Parser

• February 7, 2023:
  • Recursive Descent Parser
  • yacc
  • begin .. end statement; binop()
  • Control Theory; Trace Vector

• February 9, 2023:
  • IF Statement Example Tree
  • Spelling Correction; Loop Testing
  • FOR Loop Flowchart

• February 14, 2023:
  • Hashing, Hashing with Buckets
  • Lexical Scoping, Predefined Symbols
  • Symbolic Constants, Enumerations, Subrange
  • var statement; order of declaration blocks

• February 16, 2023:
  • Symbol Table: Variables
  • Storage Alignment
  • Symbol Table Routines; Records
  • Array Size; Operator Types
  • Coercion; Type Lattice

• February 21, 2023:
  • Structure References
  • Array Reference
  • Row-Major Order, Locality
  • Circular References; Traversing Type Tree

• February 23, 2023:
  • Type Checking: Static, Dynamic; Type Tags
  • Sound, Strong Type Checking; Holes in Type System
  • eq vs. equal; == vs. .equals() in Java
  • Strunctural Equivalence; Intermediate Code

• February 28, 2023:
  • Named Constant; Coercion; Intermediate Code
  • Parsing to Quadruples, Reverse Polish
  • Loader, Absolute File
  • Load, Store Instructions
  • Backpatching

• March 2, 2023:
  • Linking: Bringing in Library Subroutines
  • Sharing a DLL; Newton-Raphson Iteration
  • Square Root
  • Formatting Numbers for Output
  • Closed vs. In-Line Subroutine
  • Expanding Compound I/O Statements

• March 7, 2023: Review for Midterm Exam
  • Record Layout and Array Size
  • Record and Array Reference; Regular Expressions
  • Operator Precedence Parsing
  • Grammars and Languages
  • Associativity; Language; Reverse Polish; Loop Order
  • Static and Dynamic Type Checking

• March 21, 2023:
  • Steps for Record Declaration
  • Stack and Heap
  • Free List and Garbage Collection
  • Avoiding GC by Maintaining Private Free List
  • Function Calls and Runtime Stack

• March 23, 2023:
  • Array Declaration and Reference
  • 2-D Array Reference
  • Code Generation Stack
  • Memory Hierarchy; Code Generation for Expressions

• March 28, 2023:
  • Leaving Loop Index in Register; Register Pairing
  • Register Used Table; Data Flow
  • X86 Registers, Operations; Condition Code Register

• March 30, 2023:
  • findtype(); Conditional Jump
  • Intrinsic Functions; If Statement Flowchart
  • Op Code Tables; If Statement Optimization
  • Array Addressing; Pointer Dereference
  • Call by Value, Reference

• April 4, 2023:
  • Call by Value, Reference; C macros; In-line
  • Inline Small Procedures; Pareto Distribution
  • Compile Once, Run Many Times; Partial Evaluation
  • Partial Evaluation Example: power

• April 6, 2023:
  • Partial Evaluation; Data Flow Analysis
  • Code Flow; Bit Vector; Dominator
  • Available, Busy, Def-Use Chain
  • Graph Coloring for Register Allocation

• April 11, 2023:
  • Getting Performance from Multiple CPUs
  • Improving Loops over Arrays; Memoization
  • Multiple Condition Codes; Cache Prefetch
  • Branch Prediction; Register Windows
  • OOP: Class, Method Call

• April 13, 2023:
  • Code Gen: Saving Register; Getting Started
  • OOP: Instance, Boxed Number
  • Java: Number Types, Extending Classes
  • Java: field, method call: Inheritance, Shadowing
  • Multiple Inheritance: Problems

• April 18, 2023:
  • Class Implementation

• April 20, 2023:
  • Records, Arrays
  • Grammar, Local Optimization
  • Data Flow, OOP Overhead
  • Basic Blocks, Flow Graph; Call by Reference, Value
  • Things to Oprimize
  • Reverse Polish, Branch Prediction, Locality
  • Integer vs. int

Lectures from Fall 2022

• August 23, 2022:
  • Pascal vs. C; Assembly Language
  • Cost of Error Increases with Time to Detection
  • Disk, Buffer, Double Buffering
  • Ambiguity and Lookahead

• August 25, 2022:
  • Table Lookup; C strings
  • Integer Number Conversion
  • Detecting Overflow; Getting Started on Assignment 1
  • Intro to Float Conversion

• August 30, 2022:
  • Floating Point; left shift; normalize; exponent bias
  • Floating point number conversion; approximations
  • SNaN; Chomsky Language Hierarchy; Context Free Grammar
  • Hierarchy of Parsers

• September 1, 2022:
  • Context Free Grammar; Hierarchy of Parsers
  • Ambiguity: some string with 2 parse trees
  • Chomsky Hierarchy; Finite Automaton and lex
  • lex specifications

• September 6, 2022:
  • Regular Expressions and lex
  • yytext, yyleng, comments
  • Parsing: Context-Free Grammar

• September 8, 2022:
  • Top-Down, Bottom-Up; Grammar vs. Counter
  • Ambiguous, Unambiguous Expression Grammar; Shift
  • Shift and Reduce; Associativity; Parser Options
  • Tree Format; Operator Precedence Examples

• September 13, 2022:
  • Operator Precedence Examples
  • Operator Precedence Example; Push and Pop
  • Intermediate Code Tree; Parser Options
  • Recursive Descent: Grammar Rule as Code

• September 15, 2022:
  • Operator Precedence: errors, unary, function call, array
  • Yacc: begin...end statement
  • begin...end code; control theory

• September 20, 2022:
  • Debug Mask; progn; Spelling Correction
  • for statement

• September 22, 2022:
  • Hashing for Symbol Table
  • Hash with Buckets; Hierarchy of Name Spaces
  • Symbolic Constants and Enumerations
  • Variables: Alignment and Padding

• September 27, 2022:
  • Alignment, Records
  • Arrays
  • Array Size; Types and Coercion
  • Type Lattice; References in Grammar

• September 29, 2022:
  • Structure Reference Steps; Nested AREF
  • Array Reference
  • Row-Major Order
  • Java Arrays; Combined References
  • Circular References

• October 4, 2022:
  • References as Traversal of Type Tree
  • Dynamic Type Checking: Tag, Speed Penalty
  • Overly Strict Types; Not Everything Can Be Checked Statically
  • Variant Records; Complexity of Equality Testing
  • Java: == vs. .equals()

• October 6, 2022:
  • Pascal block structure; Intermediate Code
  • Quadruples, Reverse Polish
  • Absolute File and Loading Process
  • Disk Access; Intension vs. Extension

• October 11, 2022:
  • Backpatching; Linker
  • Relocation
  • DLL: Dynamically Linked Library

• October 13, 2022:
  • Record Layout
  • Array, Storage, Reference
  • Operator Precedence Parsing
  • Hashing; Regular Expressions; Regular Language
  • Regular Language, Grammar, Parse Tree

• October 20, 2022:
  • Details of Record Declaration
  • Math Functions; Newton-Raphson; sqrt
  • Number Output; I/O Statements
  • Pointer and new(); Local Free List
  • Buddy System and malloc()

• October 25, 2022:
  • Array Declaration and Reference
  • Multi-Dimensional Array Reference
  • Stack, Heap, Pointer; Garbage Collection
  • Reference Counting; Function Call Overhead

• October 27, 2022:
  • Stack and Program Execution
  • Interpreted Code; progn
  • Assignment Statement, Expression
  • Code Generation for Expression

• November 1, 2022:
  • Code Generation for Operators
  • Register Allocation
  • Registers Used, Data Flow
  • x86 Registers, Addressing

• November 3, 2022:
  • x86 Op Codes; Condition Code Register
  • Condition Code and Conditional Branch
  • Registers and Function Call; IF Statement
  • IF Optimization; Array Reference Addressing

• November 8, 2022:
  • Record Structures
  • Subrange, Arrays
  • Call by Value, Reference

• November 10, 2022:
  • In-Line vs. Closed Subroutine
  • Optimization
  • Partial Evaluation
  • Data Flow Analysis can Detect Errors

• November 15, 2022:
  • Register Assignment; Program Analysis
  • Dominatore; computed, killed
  • Available, busy, def-use chain; Graph Coloring
  • Graph Coloring for Register Assignment

• November 17, 2022:
  • Pareto Distribution; Hoisting; Strip Mining
  • Strip Mining: Multiple CPUs; Post-Increment
  • Memoization; Runtime Data Flow
  • CPU Techniques for Speedup; Cache Prefetch
  • Branch Prediction; Register Windows

• November 29, 2022:
  • OOP: Object = Record + Pointer to Class
  • Data and Method Inheritance
  • Multiple Inheritance; Optimization

• December 1, 2022:
  • Review: Records
  • Grammar, Local Opt., Available, Busy, Killed
  • Object-Oriented; Call by Reference, Value
  • Language, Reverse Polish, Call with Integer in Java

Lectures from Summer 2022

• July 11, 2022:
  • Pascal vs. C; Programming Economics
  • Cost of Error Increases with Time; Disk Access
  • Buffer; Lexical Ambiguity; Double Buffering
  • Character Codes; Table Lookup

• July 12, 2022:
  • C strings, Identifiers
  • Integer Number Conversion
  • Other Number Bases, Error Checking
  • Floating Point

• July 13, 2022:
  • Floating Point Conversion
  • Floating Point; Chomsky Hierarchy
  • Ambiguity

• July 14, 2022:
  • Finite State Machine; Hierarchy of Parsers
  • lex: return() and yylval
  • number and conversion
  • strings and comments

• July 15, 2022:
  • Context Free Grammars: Recursion and Trees
  • Floating Point Add Is Not Associative
  • Top-Down vs. Bottom-Up Parsing; Deep Structure
  • Unambiguous Parsing; Shift and Reduce

• July 18, 2022:
  • Parser Options; Associativity; Shift Action
  • Operator Precedence Parsing Examples
  • Parsing with Parens; First-Child / Next-Sibling Tree
  • Tree for Operations; Push and Pop in C
  • Parsing Function Calls, Array References
  • Top-Down Recursive-Descent Parser

• July 19, 2022:
  • Yacc; begin-end syntax
  • Constructing begin-end code; arithmetic ops
  • Trace printouts; starter file examples

• July 20, 2022:
  • error in yacc; Parser Options
  • for loop
  • Declarations and Symbol Table

• July 21, 2022:
  • Hashing; Lexical Scope
  • Inheritance of Symbols from Surrounding Scopes
  • Constant Symbols
  • Subranges as Lists of Constants
  • Variable Declarations and Block Structure

• July 22, 2022:
  • Allocating Storage; CPU-Memory Connection
  • Storage Alignment and Padding
  • Creating Symbols; Records
  • Arrays in Symbol Table
  • Type Coercion
  • Type Lattice

• July 25, 2022:
  • Structure References: Record
  • Array Reference, Canonical Form
  • Row-Major Order; Fortran and Java Arrays
  • Combined Array and Record References
  • Types as Trees, References as Traversal

• July 26, 2022:
  • Getting Started on Parser
  • Dynamic Type Checking
  • Dynamic vs. Static Type Checking
  • Holes in Type Checking
  • Pointer vs. Structural Equality; Java == vs. .equals()
  • Structural Equivalence

• July 27, 2022: Review for Midterm Exam
  • Record and Array Storage
  • Record and Array Access
  • Operator Precedence Parsing
  • Regular Expressions and Grammar
  • Chomsky Hierarchy, Grammars, Languages

• July 29, 2022:
  • Functions; Polymorphism in OOP
  • Intermediate Code: Quadruples, Reverse Polish
  • Reverse Polish; Steps From Source Code to Execution
  • Loading and Execution; BSS: Intension for Storage

• August 1, 2022:
  • Memory Banks; Backpatching; Adding Library Modules
  • Code Relocation Options
  • Dynamically Linked Library; Math Functions

• August 2, 2022:
  • sqrt, Newton-Raphson Iteration
  • Approximate sqrt; Printing Numbers
  • I/O Statements; new()
  • Recycling Unused Storage; Mark-and-Sweep
  • Copying Garbage Collection, Reference Counting; Doing Your Own Free List

• August 3, 2022:
  • Stack and Stack Frame; Interpreted Code
  • Code Generation Hierarchy; Code for Statements
  • Expressions: Postorder
  • Code Generation for Expressions

• August 4, 2022:
  • Register Allocation
  • Register Reuse; x86 Registers; Data Addressing

• August 5, 2022:
  • Base-Offset Addressing; 3 Steps for Reference
  • Records: Declaration Steps and Use
  • Array Reference
  • Pointer Reference; x86 Addressing

• August 8, 2022:
  • Arithmetic Instructions on x86
  • Condition Code and Conditional Jump
  • Saving Intermediate Result on Stack; IF Statement
  • IF Statement Optimization; Array Addressing

• August 9, 2022:
  • Call by Value, Call by Reference
  • Java Arrays; C Macros; Overhead of Procedure Call
  • Inlining: Best for Small Procedures
  • Pareto Distribution; Where to Optimize: Loops

• August 10, 2022:
  • Symbol Table Structure for Pointers
  • Optimization; Partial Evaluation
  • Data Flow Analysis

• August 11, 2022:
  • Data Flow Analysis
  • Def-Use Chains, Graph Coloring, Strip Mining
  • Cache Prefetch, Branch Prediction, Register Windows
  • Object Storage, Class Structure
  • Method Call: Dynamic Dispatch

• August 12, 2022: Review for Final
  • Record/Array Declaration and Access
  • Grammar, Chomsky Hierarchy, Local Optimization
  • Optimization, Object-Oriented Programming, Call
  • Optimization
  • Reverse Polish

Lectures from Spring 2022

• January 18, 2022:
  • Pascal vs. C; Programming Economics
  • Bug Cost Increases with Time; Buffering
  • Lexical Ambiguity; Double Buffering

• January 20, 2022:
  • characters and strings in C
  • representing identifier names
  • integer number conversion
  • floating point representation
  • floating point number conversion

• January 25, 2022:
  • Number Conversion: Other Bases
  • Floating: Fractions Not Exact, + Not Associative
  • Chomsky Hierarchy; Ambiguity
  • Hierarchy of Languages, Parsers

• January 27, 2022:
  • Floating SNaN; Hierarchy of Parsers
  • lex: Table-driven Parser
  • lex Examples
  • yytext and yyleng
  • Context Free Grammars and Languages

• February 1, 2022:
  • Floating Overflow; Hierarchy of Parsers
  • Derivations, Parse Tree, Ambiguity
  • Top-Down, Bottom-Up; Parser Options
  • Unambiguous Parse Tree; Shift Action

• February 8, 2022:
  • string in lex; shift in parsing
  • Associativity; First-Child/Next-Sibling Tree
  • Operator Precedence Parsing Examples
  • Stack Operations in C
  • Reduce; Error Checking and Unary Minus

• February 10, 2022:
  • Parser Options; Unary Operator
  • Parsing Function Calls, Array References
  • Recursive Descent Parser
  • Shift-Reduce Parser; Synthetic Translation
  • yacc; begin-end = { ...}

• February 15, 2022:
  • Trees for progn, expression
  • Observability: Trace Vector; Tree for Example
  • Error Correction; Point Op

• February 17, 2022:
  • for loop: flowchart
  • for loop: code and tree
  • Symbol Table: scope, hashing
  • Symbol Table: levels; constants

• February 22, 2022:
  • Grammar Debugging; Constants
  • Enumerated Constants; Variable Declarations
  • Order of Declarations; Simple vs. Reference Vars
  • Alignment and Padding
  • findtype(), Putting a Type in symtype

• February 24, 2022:
  • Understanding Trees; Starting Parser Assignment
  • Record Declaration
  • Variant Records
  • Array Declaration
  • binop: Inferring Type, Type Coercion

• March 1, 2022:
  • Record Declaration
  • Type Lattice; Walk through Type Tree
  • Addressing: 3 Steps; aref operator
  • Array Reference
  • Row-Major Order; Combining Constants

• March 3, 2022:
  • Combining Constants in aref; Circular Reference
  • Circular Reference; Pointer Reference
  • Structure vs Name Equivalence; Type Tree
  • Dynamic Type Checking
  • Sound Type System; Array Dimensions
  • Type Problems: Array Bounds, Variant Records

• March 8, 2022:
  • Page Table for Tags
  • Review: Record, Array
  • Operator Precedence Parsing
  • Hashing; Regular Expressions
  • Kind of Grammar, Language
  • Context Free vs. Regular
  • Function Signature; Polymorphic Procedure

• March 22, 2022:
  • Handling Symbolic Constants
  • Label Numbers; Intermediate Code; Quadruples
  • Reverse Polish
  • Absolute File and Loading; Branches to Labels

• March 24, 2022:
  • Back-patching
  • Link Editor: Assembling the Cast
  • 3 Cases for Relocation: Nothing, Address, External
  • Shared Dynamically Linked Library; Newton-Raphson
  • sqrt()

• March 29, 2022:
  • Constants; Coercion; segfault
  • Compound I/O Statements; new item; free list
  • Buddy System; malloc(); kinds of storage
  • Garbage Collection: Mark and Sweep, Copying, Reference Count

• March 31, 2022:
  • Procedure Call Overhead; Runtime Stack
  • Record Declaration
  • findtype for record; Interpreted Code
  • Code Generation for progn

• April 5, 2022:
  • Symbol Table for Arrays
  • Symbol Table for Subrange
  • Code Generation: progn
  • Code Generation: genarith()
  • Numeric Constants: Immediate, Literal

• April 7, 2022:
  • Assertions; findtype(): Type Name vs. Type
  • Variable Reference: 3 Steps; Record Reference
  • Subrange, simple aref
  • aref + record
  • multiple subscripts; pointer
  • searchins() for circular references; special functions

• April 12, 2022:
  • Code Generation for Expressions
  • Register Allocation
  • Variable Addressing on Stack

• April 14, 2022:
  • Stack Addressing; Array; Arithmetic Insgtruction
  • Condition Code and Conditional Jump
  • If Statement Code

• April 19, 2022:
  • Pointer; Call by Value vs. Reference
  • Passing Array by Reference; Constants with Reference
  • Macros; Closed vs. Inline Subroutine
  • Inline Small Subroutines

• April 21, 2022:
  • Pareto Distribution; Common Subexpression
  • Peephole Optimization; Partial Evaluation Rules
  • Partial Evaluation Example; Data Flow

• April 26, 2022:
  • genarith() for Id; Bit Vector
  • Dominator; Data Flow; Available
  • Available on Exit; Def-Use Chain
  • Error Detection; Graph Coloring
  • Register Assignment from Graph Coloring

• April 28, 2022:
  • Hoisting; Strip Mining
  • Memoization; Hardware Optimizations
  • Cache Prefetch; Branch Prediction
  • Register Stack

• May 3, 2022:
  • Object Storage
  • Storage: Instance Variables Added at End
  • Method Lookup, Inheritance
  • Multiple Inheritance; Inherit Method and Re-Compile

• May 5, 2022:
  • Review: Records, Arrays Addressing
  • Grammar and Language
  • Optimization, OOP
  • Basic Block, Control Flow, Call by Reference, Value
  • Optimization and Architecture

Lectures from Fall 2021

• August 26, 2021:
  • Pascal vs. C, Java; Programming Economics
  • Disk, Buffering for Characters
  • Tokens; Getting Started

• August 31, 2021:
  • Getting Started; C strings
  • Integer Number Conversion
  • Floating Point
  • Associativity, SNaN

• September 2, 2021:
  • Floating Point
  • Ambiguity
  • Grammar Hierarchy
  • Context Free

• September 7, 2021:
  • lex
  • lex: Specifications and Return Values
  • lex: Text Buffer and Comments
  • Context Free Languages and Parsing

• September 9, 2021:
  • Derivations and Parse Trees
  • Cocke-Kasami-Younger Parser
  • Unambiguous Expression Parsing; Shift
  • Left Associativity

• September 14, 2021:
  • First-Child/Next-Sibling Tree
  • Operator Precedence Parsing
  • Operations on Stacks
  • Recursive Descent Parsing

• September 16, 2021:
  • Parser Project Options
  • begin - end statement
  • Expressions; Observability and Trace Vector

• September 21, 2021:
  • Making Intermediate Code for begin-end, if
  • Error Correction in Handwritten Parser
  • Making Code for Loops

• September 23, 2021:
  • Hashing
  • Making New Token; Inheriting Symbols
  • Symbolic Constants; Getting Started on Parser
  • Calling findid()

• September 28, 2021:
  • blocks structure: declarations in right order
  • Symbol Table Levels; Allocating Memory, Alignment
  • Alignment and Padding
  • Field Access in Various Languages

• September 30, 2021: and September 30, 2021:
  • Array Declaration: Size
  • Type Coercion
  • Structure References; Record Field
  • Array Reference
  • Row-Major Order and Locality

• October 5, 2021:
  • Connecting Identifier to Symbol Table; Row-Major Order
  • Adding Constants in an AREF
  • Circular References in Declarations
  • Structure References Specify a Walk through Type Tree
  • Dynamic Typing: Ways to Implement

• October 7, 2021:
  • Notes on Assignment
  • Sound and Complete; Type Equivalence
  • Polymorphic Procedure; Quadruples
  • Reverse Polish; Loader

• October 12, 2021:
  • Backpatching
  • References between Files; Immediate Instruction
  • Dynamically Linked Library; Newton-Raphson Iteration
  • Sine Function; Number Conversion for Output

• October 14, 2021: Review for Midterm
  • Record Storage
  • Record Reference
  • Operator Precedence Parsing
  • Hashing; Regular Expressions
  • Regular and Context Free Grammars
  • Examples of Context Free

• October 21, 2021:
  • I/O Statements; Maintaining a Free List
  • Coalescing Free Blocks
  • Garbage Collection
  • Procedure Calls, Variables, Stack
  • Virtual Machine Code

• October 26, 2021:
  • Code Generation
  • Memory Hierarchy
  • genarith()
  • Immediate vs. Literal; used table
  • Few Registers Needed

• October 28, 2021:
  • Register Allocation
  • Record Declaration
  • Record Reference
  • Nested Registers on X86

• November 2, 2021:
  • Record Declaration; Reference with Pointer
  • Stack Addressing; aref, Multiply via Shift
  • Expression Operands; Compare and Jump
  • Type Change Functions

• November 4, 2021:
  • Array Declaration and Reference
  • Subrange in Array Declaration; Types as Tree
  • If Statement: General Case
  • If Statement Optimization; Array Addressing
  • Call by Value and by Reference

• November 9, 2021:
  • Call by Reference, Value; Arrays in Java
  • Call by Name; Constants with Reference; Macros in C
  • Closed vs Open (Inline) Subroutine
  • Optimization; Materialization

• November 11, 2021:
  • insttype(), record, subrange
  • changes to findtype(); partial evaluation
  • Partial Evaluation Example: power(x,n)
  • Common Subexpression Elimination

• November 16, 2021:
  • Labels; subrange for subscript
  • Arrays: 1-dimension, 2-dimension
  • 2-dimension array; multiple record references
  • program flow analysis; available, busy, def-use
  • def-use chain: registers, error detection

• November 18, 2021:
  • new() with Pointer; Def-Use Chain
  • Def-Use Chains, Register Allocation by Graph Coloring
  • Code Motion; Strip Mining
  • Memoization
  • Cache Prefetch; Branch Prediction; Register Windows

• November 23, 2021:
  • Code Generation Overview
  • genarith() Outline in C
  • Register Allocation; Stack Addressing
  • Op Code Tables; IF Statement
  • IF Statement Flowchart

• November 30, 2021:
  • Code Gen: Op Code Table; Register Allocation
  • OOP Instance; Data Added at Bottom of Record
  • Methods: Inheritance, Shadowing
  • Multiple Inheritance; Recompiling Methods at Lower Level

• December 2, 2021:
  • Saving Register Across Function Call
  • Review: Record Layout, Array Size
  • Review: Record Access, Grammar
  • Review: Optimization; OOP
  • Review: Optimization
  • Review: Peephole Opt.; Call by Reference, Value
  • Review: Architecture + Compiler

Lectures from Summer 2021

• July 12, 2021:
  • Pascal vs. C; cost of programming
  • Input Buffer
  • Double Buffering; Lexical Ambiguity
  • Token; Strings in C

• July 13, 2021:
  • Integer Number Conversion
  • Errors, Other Bases
  • IEEE Floating Point
  • Floating Point Conversion

• July 14, 2021:
  • Floating Point; Grammar
  • Ambiguity; Language Classes
  • Hierarchy of Grammars; Regular Grammar

• July 15, 2021:
  • Hierarchy of Grammars; lex
  • lex; commentsinlex.txt
  • lex character buffer; context free

• July 16, 2021:
  • Top-Down Recursive Descent Parser
  • Unambiguous Expression Grammar
  • Shift Action; Associativity; Tree form
  • Operator Precedence Examples
  • Operator Precedence with Parens

• July 19, 2021:
  • Operator Precedence; Stack in C
  • cons(): push onto stack
  • Parsing Function Call, Subscript
  • Recursive Descent: Top-Down Parser
  • yacc: table-driven parser

• July 20, 2021:
  • yacc; begin-end parsing
  • Observability: in-process traces

• July 21, 2021:
  • Spelling Correction; Abstract Syntax Tree
  • Loop: where to test; parser subroutines; declarations
  • Symbol Table; Getting Started with Parser

• July 22, 2021:
  • Hashing, Hash with Buckets
  • Symbol Table Levels; const declaration
  • Enumberated Types; vblock etc.

• July 23, 2021:
  • Placing Variables in Memory: Alignment, Padding
  • Record Declaration
  • Array Declaration
  • Type Coercion

• July 26, 2021:
  • Record and Reference
  • Array Reference
  • Row-Major Order and Loop/Subscript Order

• July 27, 2021:
  • AREF for record, array reference
  • Circular References; Pointer Dereference
  • Types as Tree/Graph Structure; Static, Dynamic
  • Dynamic Type Checking, Java Reference Types

• July 28, 2021:
  • Types: too strong, sound, complete, dynamic, holes
  • Structural Equivalence, Name Equivalence
  • Polymorphic Procedure: OOP Method
  • Exam Sample: Record, Array
  • Exam Sample: Operator Precedence Parsing
  • Exam Sample: Regular Expression, Modifying Grammar

• July 30, 2021:
  • Intermediate Code: Quadruples, Triples, Tree to RPN
  • Stack execution; Absolute File
  • Back-patching; Notes for graph1.pas
  • Notes for graph1.pas

• August 2, 2021:
  • Changing binop() for type propagation and coercion
  • Linker: Finding Modules, Relocation
  • DLL; Breaking I/O Statements into Parts

• August 3, 2021:
  • Record Declarations and Reference
  • Memory: Explicit Request, Release
  • Own freelist in Java; Identifying Runtime Type
  • Garbage Collection; Runtime Stack

• August 4, 2021:
  • Common Errors; JVM Code; Code Generation Hierarchy
  • Code Gen for progn, assignment
  • genarith() example; Memory Hierarchy
  • Register Allocation

• August 5, 2021:
  • Notes on pasrec.pas assignment
  • Code Generation, Load/Store
  • Register Used Table; Data Flow
  • X86 Addressing: Stack Variables, Pointer

• August 6, 2021:
  • Array References
  • Code Generation for Arithmetic Expression
  • Condition Code Register
  • Code Generation for IF Statement

• August 9, 2021:
  • Call by Reference, Call by Value
  • Call by Value in Java; Inlining
  • Inlining: Best for Small Subroutines

• August 10, 2021:
  • Pareto Distribution; Partial Evaluation
  • Partial Evaluation Example
  • Control Flow Analysis; Bit Vector
  • Data Flow Example

• August 11, 2021:
  • Reusing Expressions: Computed, Killed
  • Available; Error Detection
  • Graph Coloring for Register Assignment
  • Strip Mining; Postincrement; Memoization
  • Hardware Can Dynamically Reuse Expression

• August 12, 2021:
  • Cache Prefetch, Speculative Execution
  • Register Windows; Object Implementation
  • OOP Class Hierarchy, Instance Variables, Methods

• August 13, 2021:
  • Object Implementation and Method Call
  • Multiple Inheritance
  • Final Exam Example: Record, Array
  • Examples: Grammar, Avaiable, Busy, Killed
  • Examples: Call by Reference, Value; x[i] in Loop

Lectures from Spring 2021

• January 19, 2021:
  • C vs. Pascal
  • Cost of Programmer
  • Double Buffering
  • Intro to Number Conversion

• January 21, 2021:
  • C strings
  • Integer Number Conversion
  • Floating Point
  • Floating Point Conversion

• January 26, 2021:
  • Facts re Floating Point
  • Floating Point; Grammar
  • Ambiguity; Nested Grammars
  • Grammar Hierarchy; Lex Implementation

• January 28, 2021:
  • Grammars and lex
  • lex
  • Context-Free Grammars and Languages

• February 2, 2021:
  • Derivation; Top-down Parsing; Deep Structure
  • Augmented Transition Net; Expression Parsing
  • Associativity; First-Child/Next-Sibling Tree
  • Operator Precedence Example

• February 4, 2021:
  • Parsing Methods; Shift, Reduce, Tree
  • Operator Precedence Examples
  • Operator Precedence Examples
  • Stack Handling in C
  • Parsing Function Calls and Arrays

• February 9, 2021:
  • Recursive Descent
  • Shift-Reduce Parser: yacc
  • begin statement

• February 11, 2021:
  • Intermediate Code; Trace Bit Vector
  • Edit Distance for Error Correction
  • Intermediate Code for Loops

• February 25, 2021:
  • Notes on trivb.pas Assignment
  • Hashing for Symbol Table
  • Symbol Table Levels; Constants

• March 2, 2021:
  • const declaration
  • program declaration, blocks
  • variable allocation in memory
  • variable lookup in symbol table

• March 4, 2021:
  • Notes on trivb.pas assignment; allocating storage
  • Record Declaration
  • Array Declaration; Operator Type and Coercion
  • Type Coercion, Type Lattice

• March 9, 2021:
  • Structure References
  • Row-Major Order
  • Type Structure
  • Array Example from Midterm Study Guide

• March 23, 2021:
  • Moving through type graph
  • Type tagging methods; sound, complete
  • Type Equivalence
  • Java Integer; Polymorphic method
  • Intermediate code: Quadruples

• March 25, 2021:
  • Producing Intermediate Code during Parsing
  • Absolute File and Loader
  • Back-patching

• March 30, 2021:
  • Absolute File; Following References; Relocation
  • Relocation; Dynamically Linked Library; Math Functions
  • Newton-Raphson and sqrt
  • Output Conversions; I/O statements

• April 1, 2021:
  • Installing Record in Symbol Table
  • Heap Storage
  • Garbage Collection Methods
  • Maintaining Your Own Free List

• April 6, 2021:
  • Runtime Stack
  • Code Generation
  • Code Generation: Assignment, Expression
  • Code Generation: genarith()

• April 8, 2021:
  • aref assignment
  • Multiple aref
  • Code Generation: Assignment, Expressions
  • Register Allocation
  • Data Flow and Register Reuse

• April 13, 2021:
  • x86-64: Registers, Addressing
  • x86-64: Arithmetic, Condition Code
  • Conditional Jump
  • Subroutine Call

• April 15, 2021:
  • Record Declaration and Reference
  • Structure Declarations and References
  • Labels and If Statement
  • If Statement Optimization

• April 20, 2021:
  • Making record symbol table entry
  • Pointer reference; call by value, reference
  • Closed vs Open (In-line) Subroutine
  • aref in a loop is good to optimize

• April 22, 2021:
  • Optimization: Partial Evaluation
  • Partial Evaluation: Removal of Interpretation
  • Global Optimization: Flow Graph Analysis

• April 27, 2021:
  • Getting Started on Code Generation; Bit Vectors
  • Global Optimization: Computed, Killed
  • Available, Busy
  • Def-Use Chains
  • Graph Coloring for Register Allocation

• April 29, 2021:
  • Get a Register, genarith()
  • Strip Mining; Finite Differencing
  • Memoization
  • Cache Prefetch; Branch Prediction; Register Windows
  • Object Representation

• May 4, 2021:
  • aref and jump table
  • aref details
  • Object; Java Integer
  • Extending a Class: Data

• May 6, 2021:
  • Inheritance
  • Multiple Inheritance

Lectures from Fall 2020

• August 28, 2020:
  • Pascal; Assembly Language; Economics of Programming
  • Double Buffering; Lexical Ambiguity
  • Character Codes; Table Lookup

• September 1, 2020:
  • Strings in C
  • Integer Conversion
  • Basic Float Conversion
  • Floating Point Representation

• September 3, 2020:
  • Associativity and Floating Point
  • Chomsky Language Hierarchy
  • Ambiguity
  • Eliminating Ambiguity

• September 8, 2020:
  • lex
  • lex; language hierarchy
  • context free languages; derivation
  • examples of ambiguity in programming languages

• September 10, 2020:
  • Top-Down Parsing
  • Ambiguity and Parsing
  • Shift-Reduce Parsing, First-Child/Next-Sibling Tree
  • Shift-Reduce Examples
  • Shift-Reduce Examples

• September 15, 2020:
  • Operator Precedence Examples
  • Parsing Function Call
  • Operator Precedence + Recursive Descent
  • Stack in C
  • Yacc: default action, begin-end

• September 17, 2020:
  • Intermediate Code for Begin-End
  • Building in Observability
  • Yacc vs. Hand-written Parser

• September 22, 2020:
  • For Loop; Hashing
  • Hash with Buckets; Symbol Table Levels
  • Symbolic Constants; Subrange

• September 24, 2020:
  • var Declaration and Block Structure
  • Relative Addressing
  • Data Alignment and Padding
  • Runtime Stack, Record

• September 29, 2020:
  • Record and Array Declarations
  • Type Coercion and Type Lattice
  • Structure References
  • Array References

• October 1, 2020:
  • Structure References
  • Row-Major Order
  • Combined AREFs; Circular Structures
  • Traversal of Type Structure
  • Dynamic Type Checking

• October 6, 2020:
  • Function signature; sound, complete
  • Type Equivalence
  • Polymorphic method; Quadruples
  • Reverse Polish

• October 8, 2020: and second part:
  • Loader; Banked Memory
  • Backpatching; Link Editing
  • Relocation Cases

• October 13, 2020:
  • DLL; I/O Statement Expansion
  • Keeping a Free Storage List
  • Garbage Collection Methods
  • Number Conversion for Output

• October 15, 2020: Review for Midterm
  • array and record calculations
  • operator precedence parsing
  • regular expressions and languages
  • Chomsky hierarchy, grammars, languages

• October 20, 2020: Midterm Exam

• October 22, 2020:
  • Notes on graph1 assignment
  • Type Coercion in binop(), funcall
  • Newton-Raphson Iteration for sqrt()
  • Easy sqrt(), preamble, stack frame
  • Function calls and stack; virtual machine code
  • Code generation for progn

• October 27, 2020:
  • Code Generation for Expressions
  • Immediate Instruction; Registers
  • Simple Register Allocation

• October 29, 2020:
  • x86 Addressing, Arithmetic
  • Condition Code Register and Jump
  • Code Generation for If
  • Addressing for Array Reference

• November 3, 2020:
  • Record Declarations
  • Record Reference
  • Call by Reference and Value
  • Creation of Alias by Call
  • Call by Reference vs. Value

• November 5, 2020:
  • Processing Array Declarations
  • Simple Array References
  • Compound Array References
  • Open (Inline) vs. Closed Subroutine
  • Pareto Distribution; what to Optimize

• November 10, 2020:
  • Array Declaration and Reference
  • Pointers
  • Multiple aref's; padding
  • Peephole optimization; Partial Evaluation
  • Partial Evaluation Example

• November 12, 2020:
  • Stack Machine
  • Bit Vector; Flow Graph
  • Available and Busy

• November 17, 2020:
  • Array References
  • Two-dimensional Array References
  • Definition-Use Chains
  • Graph Coloring
  • Strip Mining

• November 19, 2020:
  • Memoization, Advanced Hardware
  • PowerPC Features
  • Register Windows; Discrete Event Simulation

• November 24, 2020:
  • genarith(): Literals
  • genarith(): Binary Ops
  • genarith(): Unary Ops
  • Object Storage; Java Integer
  • Extending Objects
  • Inheritance and Shadowing

• December 1, 2020:
  • Object, Method Inheritance
  • Multiple Inheritance
  • Just In Time Compilation

• December 3, 2020: Review
  • Review A
  • Review B
  • Review C
  • Review D
  • Review E
  • Review F

-->

Lectures from Summer 2020

• July 13, 2020:
  • Pascal vs. C; kinds of code; cost of errors grows
  • Disk and input buffer; Lexical ambiguity
  • Character codes; starting assignment
  • Strings in C

• July 14, 2020:
  • Double Buffering; Assignment 1
  • Lexer; tokens
  • Integer Conversion
  • Integer Overflow
  • Floating Point Representation

• July 15, 2020:
  • Floating Point Conversion
  • Floating Point Values
  • Significant Digits; Ambiguity
  • Ambiguity; Language Classes

• July 16, 2020:
  • lex: table; special variables
  • lex: making output tokens
  • lex comments; language hierarchy
  • recursion; agreement; derivations
  • Left Recursion

• July 17, 2020:
  • Top-Down vs. Bottom-Up; Ambiguity; Deep Struture
  • Stack; Ambiguous vs Unambiguous Expression Grammar
  • Expression Trees; Associativity
  • First-Child/Next-Sibling Tree; Operator Precedence
  • Operator Precedence Parsing Example

• July 20, 2020:
  • Operator Precedence Examples
  • Operator Precedence; Stack in C
  • Parser Options
  • Parsing Function Call and Subscripts
  • Writing Recursive Descent Code

• July 21, 2020:
  • begin intermediate code
  • binop(); Building In Observability
  • Tree for IF Example

• July 22, 2020:
  • Edit Distance; For Loop Flowchart
  • For Loop Tree
  • Hashing variants
  • Lexical Scoping

• July 23, 2020:
  • Symbol Table: Constants
  • Declaration Statements
  • Addressing and Alignment
  • Notes on trivb.pas Assignment

• July 24, 2020:
  • Symbol Table Entry for Record
  • Array Size; Type Coercion
  • Type Lattice
  • Walk through Type Tree
  • Record and Array References

• July 27, 2020:
  • Array Reference Code
  • Row Major Order
  • Combined References; Circular Type References
  • Circular Function Calls; Pointer Dereference
  • Dynamic Typing and == in Java

• July 28, 2020:
  • Dynamic Typing
  • Type Equivalence
  • Polymorphic Method
  • Quadruples and Polish

• July 29, 2020: Review for Midterm
  • Record and Array Size
  • Operator Precedence Parsing
  • Hashing; Regular Expressions
  • Context Free and Regular Grammars
  • Converting Tree to Reverse Polish

• July 30, 2020: No Lecture; Midterm Exam

• July 31, 2020:
  • Installing Record Declaration
  • Executable File and Loader
  • Backpatching process

• August 3, 2020:
  • Array References
  • Pointers; Linker
  • Relocation options
  • Dynamically Linked Library; Number Conversion for Output

• August 4, 2020:
  • Math Library
  • Compound I/O Statements
  • Free List and Garbage Collection
  • Garbage Collection, Roll-your-own Free List
  • Subroutine Call Overhead

• August 5, 2020:
  • Runtime Stack; Interpreted Code
  • Code Generation
  • Expression Generation
  • Expression Generation; Memory Hierarchy

• August 6, 2020:
  • Register Allocation
  • x86 Addressing
  • x86 Arithmetic Instructions

• August 7, 2020:
  • Op Code Table; Condition Code Register
  • Conditional Jump
  • Saving Registers across Subroutine Call
  • If Statement Generation
  • Call by Reference

• August 10, 2020:
  • Call by Reference vs. Call by Value
  • Call by Value in Java; C Macros
  • Open or Inline Subroutine
  • Optimization: Pareto Distribution

• August 11, 2020:
  • Partial Evaluation
  • Common Subexpressions
  • Matrix Representation of Graph
  • Bit Vector; Control Flow
  • Data Flow

• August 12, 2020:
  • Saving Register Across Funcall
  • Data Flow, Def-Use Chain
  • Graph Coloring for Register Assignment
  • Strip Mining
  • Advancced Hardware Features

• August 13, 2020:
  • Array Reference Addressing; Object Representation
  • Class Hierarchy; Multiple Inheritance
  • Mixin Methods

• August 14, 2020: Review
  • Array size and reference
  • Grammar example
  • OOP; flow graph
  • Optimization; advanced CPU features
  • Row-major Order; Substitution, def-use chaain

Lectures from Spring 2020

• March 31, 2020:
  • Record Declarations
  • Link Editor
  • DLL
  • Math Library
  • Number Conversion for Output
  • Writeln

• April 2, 2020:
  • Free List of Released Memory
  • Identifying Type of Dynamic Storage
  • Following Pointers for Garbage Collection
  • Copying Garbage Collection
  • Private Free List in Java
  • Reference Counting
  • Call Graph and Runtime Stack

• April 7, 2020:
  • Generation of progn
  • genarith
  • Register Allocation
  • Register Reuse

• April 9, 2020:
  • Array Addressing
  • AREF Canonical Form
  • Multi-Dimensional Array Addressing
  • x86 Registers and Addressing
  • x86 Arithmetic Instructions
  • x86 Compare and Jump
  • Identity Functions

• April 14, 2020:
  • Compare/Jump Example
  • Code for genarith()
  • Flowchart for IF Statement
  • IF Statement Optimization
  • Addressing for AREF
  • Record Addressing

• April 16, 2020:
  • Call by Reference
  • Call by Value
  • Call by Value in Java
  • Call by Name
  • Closed vs. Open (inline) Subroutine
  • Pareto Distribution
  • repeat statement tree; pointer; record reference (office hours)

• April 21, 2020:
  • Pointer and Record References
  • Partial Evaluation
  • Common Subexpressions

• April 23, 2020:
  • Set as Bit Vector
  • Common Subexpressions
  • Def-Use Chain
  • Graph Coloring
  • Strip Mining

• April 28, 2020:
  • Finite Differencing, Memoization
  • Advanced CPU Features
  • Speculative Execution
  • Register Stack

• April 30, 2020:
  • Integer vs. int in Java
  • Integer cache and == : Potential Bug
  • Inheritance in Java: Fields, Methods
  • Method Inheritance and Shadowing
  • C++ Methods; Multiple Inheritance
  • Multiple Inheritance: Mixin Conflicts

• May 5, 2020:
  • Dynamic Method Dispatch
  • OOP Overhead
  • THINGLAB; Lisp REPL

• May 7, 2020:
  • Review A
  • Review B
  • Review C
  • Review D
  • Review E
  • Review F
  • Review G