CS 375, Compilers: Study Guide for Final Exam

Date: Saturday, December 13, 2025, 3:30 - 5:30 PM on Canvas.

Material on the Midterm Study Guide is included on the final.

Reading:

Aho, Lam, Sethi, and Ullman, Compilers: Principles, Techniques, and Tools, Chapters 7 through 9.

Material covered in class:

Topics in parsing programming language constructs: current status variable (last thing seen was start of expression, operand, operator); type coercion; conversion of names with constant compile-time values to constants; intermediate code for non-arithmetic statements.
Array references: methods for storing arrays (row-major order, column-major order); effect of array order and loop order on efficiency; computation of effective address (formula); why optimization of array references is important.
Record structure declarations and references: what information is stored in symbol table from declaration; generation of intermediate code for references to records; references using pointers; records with variant parts.
Type systems, type checking. Failure of type checking due to aliasing, variant records, pointer arithmetic.
Intermediate representations: assembly language, machine language, reverse Polish, quadruples, triples, trees: advantages and disadvantages of each, comparisons. Any of these forms can be produced by a shift-reduce parser.
Link editor: functions it performs: find needed code modules (find undefined symbols in libraries), allocate storage to modules, relocate the code.
Code generation: absolute code, relocatable code, assembly language (advantages, disadvantages); generation of executable code, calls, interpreted code; how to generate code from trees; ways to improve generated code.
Runtime storage organization:
- Data area, base address, offset, location counter; representation of addresses in relocatable binary output and how the link editor handles them.
- Static allocation: program relocation.
- Storage management for recursive languages: stack frame, stack pointer; procedure entry and exit; local and global variables and how they correspond to symbol table organization.
- Records; dynamic storage management: heap, storage leak, garbage collection (requires a strong type system).
Formal, actual, implicit parameters; call by reference, call by value, pointer. Macros.
Optimization: economic considerations; constant folding, partial evaluation, inlining, peephole optimization, eliminating dead code, common subexpression removal, moving non-changing code out of loops, reduction in strength, optimization of subscript expressions, loop unrolling, finite differencing. Basic blocks: definition; relation to program flow graph; be able to mark the blocks in a sequence of code. Bit vectors: referenced, defined, computed, killed, available, busy; graphs, transitive closure, dominators; intervals; global program analysis; graph coloring for register assignment.
OOP: representation of an object; process of message sending (method call); efficiency issues, compiler optimization, just-in-time compilation.
Hardware support: register windows, memory prefetching, postincrement.

Vocabulary:

absolute code	actual parameter	adjacency matrix
aliasing	antisymmetric	automatic programming
available	backpatching	backward reference
basic block	bit vector	Boolean matrix
boxed number	BSS storage	busy
cache prefetch	call by name	call by reference
call by value	callee-saved	caller-saved
canonical form	Cartesian product	class
code motion	column-major order	computed
condition code register	constant folding	control flow analysis
dangling reference	data flow analysis	dead code
defined	definition-use chain	dereference a pointer
dominator	dynamic	dynamic memory
dynamic type checking	epilogue	formal parameter
forward reference	fragmentation	garbage
garbage collection	global optimization	graph
graph coloring	heap	implicit parameter
induction variable	inherit	inherited attribute
inlining	instance	instance variable
interpreted code	interval	keyword
killed	lexical scoping	link editor
live variable	loader	local optimization
location counter	loop unrolling	macro
mark-and-sweep	materialization	memory hierarchy
memory leak	message	method
multiple inheritance	name equivalence	nonvolatile register
object	object-oriented programming	overloading
Pareto distribution	partial evaluation	partial order
partition	peephole optimization	polymorphic function
postamble	postincrement	preamble
prologue	quadruples	reduction in strength
referenced	reflexive transitive closure	register windows
relation	relocatable code	relocation
restore registers	return address	reverse Polish
RISC	row-major order	save registers
selector	send a message	shadowing
sound type system	spill code	stack frame
stack pointer	static	static analysis
static type checking	strong typing	structural equivalence
superclass	superscalar	synthesized attribute
tag	transitive closure	triples
type coercion	type hierarchy	type signature
union type	unreachable code	volatile register