LANGUAGES, GRAMMARS AND AUTOMATA Mul- First/Follow conflict the First and Follow of a variable intersect can continue
of a variable intersect can continue to shift too. It cannot deterministically choose
tiple matches - What if multiple DFA’s recognize the same
string? Two options: 1. prioritize the first regular expression in
the specification of the scanner -> keep the DFA’s ordered and
choose the first DFA which accepts 2. Disallow multiple matches,
the specifications must be unambiguous -> requires language
checking when generating the scanner -> for all pairs of Regular
Expressions with languages L1, L2 → check L1 ∩ L2 6= φ Gram-
mar/Language Types regular grammars – regular language ⊂
context-free grammars – context-free language ⊂ context-sensitive
grammars – context-sensitive language ⊂ all grammars – recur-
sively enumerable Grammar definition A grammar is a tuple
G = (V, T, P, S) where - V is a finite set of variables, - T is a finite
set of terminals, - P is a finite set of production rules of the form
α → β with - α ∈ (V ∪ T )∗ V (V ∪ T )∗ and - β ∈ (V ∪ T )∗ , - S ∈ V
is a variable called the start symbol. Context-sensitive gram-
mars either α = S and β = ε or |α| ≤ |β| and S does not appear
in β Context-free grammars α ∈ V Regular grammars
a ∈ V and 1. left-regular: β ∈ T ∗ ∪ (V · T ∗ ) 2. right-regular:
β ∈ T ∗ ∪ (T ∗ .V ) Ambiguous grammar if there’s more than
one derivation tree for the same word and grammar (HAVE NO
PARSER!) Chomsky Normal Form A CFG is in CNF if all its
production rules are of the form: 1. A → BC (B and C cannot
be the start symbol) 2. A → a 3. S → ε Nondeterministic
Pushdown Automata NPDA A is a tuple (Q, Σ, Γ, δ, q0 , Z0 , F )
such that - Q is a finite set of states; - Σ is a finite input alphabet;
- Γ is a finite stack alphabet; - δ : Q × (Σ ∪ {ε}) × Γ → 2Q×Γ
∗
is the transition function; - q0 ∈ Q is the initial state; - Z0 ∈ Γ
is the initial symbol on the stack; and - F ⊆ Q is the set of
accepting states. NPDA ≡ CFG can be transformed into each
other Synthesized vs Inherited attributes an attribute is
synthesized if its value depends on the values of its children in
some derivation tree. Otherwise, it is inherited. Static Sin-
gle Assignment every register can be assigned at most once
- registers are not variables - Advantages: Easier to optimize
because 1. registers correspond to a single value 2. instruction
results go to output registers, and stay there (so we can very
easily determine if a register is never used e.g.) Control Flow
Graph a graph with all the paths that might be traversed by a
program, each node is a basic block Phi-function assigns the
defined value to a variable based on a condition - e.g. %d = phi
i32 [%c1, %iftru], [%c2, %iffls] - only necessary if not doing lazy
solution CFG to PDA one state - for all rules A → B add tran-
sition that pops A and pushes B on empty input - ε, A/B - for all
terminals t ∈ T add transition that pops t when reading t - t, t/ε
k-look-ahead PDA δ : Q × (Σ ∪ {ε}) × Γ × Σ≤k → 2Q×Γ
∗
where Σ≤k = ∪ki=0 Σi First and Follow Firstk (α) :=
{w ∈ T ∗ : α ⇒∗ wx ∧ (|w| = k or |w| < k ∧ x = ε)},
Follow k (α) := {w ∈ T ∗ | ∃β, γ : S ⇒∗ βαγ ∧w ∈ First k (γ)}
First/First conflict two rules for the same variable have inter-
secting First’s - solutions: left factoring, left recursion removal
- solutions: substitution, left
recursion removal strong LL(k)
First k α1 · Follow k (A) ∩ First k α2 · Follow k (A) =


∅ Error recovery vs repair Recovery: ignore the current error
and have the parser reach a correct configuration - Repair: parser
attempts to fix the input to continue Panic Mode parser skips
input tokens until it finds a frequently occurring delimiter (e.g. ;)
Error detection in LL(1) if no entry in action table -> error.
We can output a message with what the parser expected Panic
Mode Recovery in LL(1) every call to not-terminal-function
is given as argument some set of potential end-of-block lexical
units (e.g. ;) - if an error occurs, the function discards tokens
until one of those tokens is matched Undecidable Problems
type checking - line number reachability Static Type Checking
apply inference rules to deduce types of expressions - conservative
approach since some programs will be marked as incorrect, yet
the type-incorrect instructions may not even be reached Argue
type checking and reachability analysis are undecidable
Deciding reachability and type checking amounts to deciding the
halting problem. 1. In the case of type checking, determining
whether a program satisfies the type rules of a programming
language involves analyzing the compatibility of operations and
assignments with types. By reducing the halting problem to type
checking, one can show that deciding type checking is undecidable.
2. Similarly, reachability analysis involves determining if a par-
ticular program state or instruction is reachable during program
execution. By constructing programs that exhibit the same be-
havior as programs in the halting problem, one can demonstrate
that deciding reachability is also undecidable. Henceforth, we
write type checking for static type checking: apply inference rules
to deduce types of expressions (without caring about reachability
of instructions). PARSERS top-down - produce: use a rule
A → α to pop A from the stack and push α. - match: pop the
terminal a from the stack while simultaneously reading a - stack
start with S and accept by empty stack LL(1) easy proof if you
can construct a DFA, it is LL(0) (and therefore LL(1) LL(2),
. . . too of course) LL(1)Action Table terminals in columns,
non-terminals in rows - T (A, a) contains the rule A → β iff a
is in First1 (β) or ε is in First1 (β) and a is in Follow1 (A),
so if a is in First1 (βFollow1 (A)) LL(k) grammar A CFG is
LL(k) iff for all pairs of derivations S ⇒∗ wAγ ⇒ wα1 γ ⇒∗ wx1
and S ⇒∗ wAγ ⇒ wα2 γ ⇒∗ wx2 with w, x1 , x2 ∈ T ∗ , A ∈ V ,
and γ ∈ (V ∪ T )∗ , if Firstk (x1 ) = Firstk (x2 ) then α1 = α2
bottom-up - shift: read a terminal a and push it onto the stack
- - reduce: use a rule A → α to pop the αR from the stack
and push A - stack start with empty stack and accept if stack
contains S reduce-reduce conflicts When the top of the stack
corresponds to the handle for two different rules. The parser can-
not deterministically choose one. shift-reduce conflicts When
the top of the stack corresponds to some handle, but the parser
whether to reduce now or do so later. sentential-form prefixes
on the stack Let (q, w, γZ0 ) be a configuration reached along
an accepting run of the bottom-up parser with q not of the form
(A, . . .). Then: S ⇒∗ γ R · w along a rightmost derivation. This
does not mean however that if we make sure the stack always has
prefixes of valid sentential forms, then we will get an accepting
run. viable prefix A prefix π is viable if it is the prefix of a
right-sentential form that can occur (in reverse) on the top of the
stack along an accepting run of the bottom-up parser. canonical
finite-state machine CFSM is an automaton that recognizes as
its language exactly the set of all viable prefixes of a given CFG
finite language every finite language is regular and therefore
LL(1) (THIS DOES NOT MEAN THE GRAMMAR IS LL(1)!!)
item An item of a grammar is a rule where we have inserted • as
a marker somewhere in the RHS, e.g. A → α1 • α2 closure of an
item The closure of an item A → α1 • Bα2 with B ∈ V is the set
of all items B → •β where B → β is a rule of the grammar. - The
closure of a set I is the minimal closure-closed set that includes
I. CFSM definition The CFSM is the DFA (Q, V ∪ T, δ, q0 )
where - Q is the set of all subsets of items, - q0 is the closure of
{S → •α | S → α is a rule }, - δ(q, a) maps to the closure of
the a-successor of q. - (All states are accepting! Except for the
empty set, i.e. a bad sink.) LR Left scanning, Right parsing
parsers LR(0) simulation shift from left to right, if we recognize
a body, reduce. keep going until we only have S LR(0) action
table Index grammar rules 1 ≤ j ≤ n and states from the CFSM
0 ≤ i ≤ k. The table T maps each i to a set of actions: - T (i) con-
tains (a Reduce) j if state i has the item A → α• with A → α the
j-th rule. - T (i) contains Shift if state i has an item A → α1 • α2 .
- T (i) contains Accept if state i has an item S → α• - T (∅)
contains an Error action only. - Note that every cell of the action
table has at least one action because all states from the CFSM
contain some item (except ∅). Action Table for SLR Index
grammar rules 1 ≤ j ≤ n and states from the CFSM 0 ≤ i ≤ k.
The table T maps each i to a set of actions: - T (i) contains j if
state i has the item A → α• with A → α the j-th rule. - T (i)
contains (a Shift) a if state i has an item A → α1 • aα2 . - T (i)
contains Accept if state i has an item S → α•. - T (∅) contains
an Error action only. Action Table with look-ahead 1. Push
the initial state 0 of the CFSM into the stack S. 2. As long as we
can’t accept or get an error: 2.1 If j ∈ T (top(S)), A → α is the
j-th rule, and the look-ahead ` is in Follow k (A), then 2.1.1 pop
|α| times from S 2.1.2 and put A in variable c. 2.2 Otherwise, if
the look-ahead starts with a, put a into the variable c. 2.3 Let q 0
be the next state δ(top(S), c) of the CFSM after reading c. 2.4
Push q 0 into S. Look-ahead LR(k) parsers similar to SLR(K)
except it uses ItemFollow instead of the general Follow. Use
the LR(k) CFSM, and merge the states with same items (and
different look-aheads). LR(K)-items These are item-look-ahead
pairs (A → α1 • α2 , w) where w ∈ Σ≤k . LR(k)-closure The
closure of an LR(k)-item (A → α1 • Bα2 , w) is the set of all
LR(k)-items (B → •β, y) where B → β is a rule of the gram-
mar, and y ∈ Firstk (α2 w). As before, the closure of a set I
is the minimal closure-closed set including I. LR(k)-CFSM
States of the CFSM are now subsets of LR(k)-items. The a-
successor of a state I, for a ∈ T ∪ V , is the closure of the set
{(A → α1 a • α2 , w) | (A → α1 • aα2 , w) ∈ I} The LR(k)-CFSM
is the DFA (Q, V ∪ T, δ, q0 ) where - Q is the set of all subsets
of LR(k)-items, - q0 is the closure of {(S → •α, ε) | S → α is a
rule }, - δ(q, a) maps to the closure of the a-successor of q. - (All
states are accepting! Except for the empty set, i.e. a bad sink.)
Action Table for LR(k) Index grammar rules 1 ≤ j ≤ n and
states from the CFSM 0 ≤ i ≤ k. The table T maps each i and
look-ahead ` to a set of actions: - T (i, `) contains (a Reduce) j
if state i has the item (A → α•, `) with A → α the j-th rule. -
T (i, `) contains Shift if state i has an item (A → α1 • α2 , y) and
` ∈ Firstk (α2 y). - T (i, ε) contains Accept if state i has an item
S → α•. - T (∅, `) contains an Error action only. GOOD CODE
usage and liveness algorithm go through the instructions in
the block from last to first. For every instruction i : x := y op z
we do the following: 1. attach to i the usage and liveness in-
formation of x, y, z 2. Set x to not live and no next use 3. Set
y, z to live and the next uses of y, z to i Basic block directed
acyclic graph 1. There is a node in G for each initial value of
the variables in the block. 2. There is a node N associated to each
instruction in the block. Its children are the nodes corresponding
to instructions where the operands of i were last defined. Nodes
with the same children are ”merged” 3. A node is labelled by
the operator applied at its corresponding instructions and with
the list of variables for which it is the last definition within the
block. 4. Nodes with values that can be used by successor blocks
are marked as live on exit. E.g. return instructions. Usages of
DAG 1. elimination local common sub-expressions 2. dead-code
elimination 3. instruction reordering 4. reorder operands of in-
struction Register descriptors variable names whose current
value is in a register Address descriptors all locations where
the current value of a variable is stored Register allocation for
operands Ry given by getReg(x := y op z) can be chosen as
follows. 1. If y is currently in a register r then Ry = r. 2. If
y is not in a register but the register r is currently empty then
Ry = r. 3. The remaining case is the difficult one. Let r be a
candidate register: 3.1 If all variables whose descriptor says their
value is in r also have another location then return r. 3.2 If the
only variable whose descriptor says their value is in r is x and
x∈ / {y, z} then return r. (We will overwrite it anyways!) 3.3 If
all variables ... are not used after the instruction (i.e. they are
not live), again return r. 3.4 Otherwise spill the variables into
memory. Register allocation for result x = y OP zSince the
value of x is being computed then a register r currently holding
the value of x is always a safe choice. Otherwise, if y or z are
not live after the current instruction, then Ry or Rz can be used.
Inference graph 1. Nodes correspond to the (infinitely-many)
registers used in the generated code (i.e. the variables). 2. An
edge connects two nodes if they are simultaneously live (i.e. they
are both live at some instruction). Ershov Number Let us label
a binary expression tree as follows. - Leaves are labelled with 1.
- Inner nodes with one child have the same label as their child. -
Inner nodes with two children have the maximal label amongst
its children’s labels if they are different; 1+ the label of its chil-
dren if they are the same. Ershov Theorem the number of
the root corresponds to the minimal number of registers required
to evaluate the expression without using additional memory or
algebraic properties Sethi-Ullman algorithm Consider regis-
ters Rb , Rb+1 , . . . , Rb+k−1 for k the Ershov Number of the given
node and b ≥ 1 a base number. We will leave the result of the
computation in register Rb+k−1 . Algorithm for equal-children
nodes (labelled k − 1 ) 1. Recursively generate code for the
right child using base b. The result of the right child appears in
Rb+k−1 . 2. Recursively generate code for the left child using base
b − 1; its result appears in Rb+k−2 . 3. Generate the instruction
Rb+k−1 = Rb+k−2 op Rb+k−1 . - Algorithm for different-children
nodes (labelled m < k ) 1. Recursively generate code for the
big child, using base b; the result appears in register Rb+k−1 .
2. Recursively generate code for the small child, using base b;
the result appears in register Rb+m−1 . (Note Rb+m , . . . , Rb+k−1
are not used in the computation!) 3. Generate the instruction
Rb+k−1 = Rb+m−1 op Rb+k−1 (or vice versa if the right child is
the small child). Expression evaluation with spilling Mod-
ifications to the Sethi Ullman algorithm If the input node has
label k > r with r the number of registers: -Pick a ”big child”
with label at least r. - Recursively generate code for the big child
using b = 1. The result will appear in register Rr . - Store the
value of Rr in memory. - Generate code for the little child: If
it has a label of at least r then use base b = 1. If the label is
j < r then pick b = r − j. Recursively apply this algorithm to
the little child and the result appears in Rr . - Load into Rr−1
the value computed for the big child. - Issue the instruction to
compute into Rr the value of the node. MIPS ackermann: addi
$sp, $sp, -8; sw $ra, 4($sp); sw $s0, 0($sp); li $v0, -1; blt $a0,
0, exit; blt $a1, 0, exit; addi $v0, $a1, 1; beq $a0, 0, exit; beq
$a1, 0, rec_call; addi $a1, $a1, -1; move $s0, $a0; jal ackermann;
addi $a0, $s0, -1; move $a1, $v0; jal ackermann; j exit; rec_call:
addi $a0, $a0, -1; li $a1, 1; call ackermann; j exit; exit: lw $ra,
4($sp); lw $s0, 0($sp); add $sp, $sp, 8; jr $ra; LLVM IR define
dso_local i32 @ackermann(i32 noundef %0, i32 noundef %1) {
%3 = alloca i32, align 4; %4 = alloca i32, align 4; %5 = alloca
i32, align 4; store i32 %0, ptr %4, align 4; store i32 %1, ptr %5,
align 4; %6 = load i32, ptr %4, align 4; %7 = icmp slt i32 %6, 0;
br i1 %7, label %11, label %8; 8: %9 = load i32, ptr %5, align 4;
%10 = icmp slt i32 %9, 0; br i1 %10, label %11, label %12; 11:
store i32 -1, ptr %3, align 4; br label %33; 12: %13 = load i32,
ptr %4, align 4; %14 = icmp eq i32 %13, 0; br i1 %14, label %15,
label %18; 15: %16 = load i32, ptr %5, align 4; %17 = add nsw
i32 %16, 1; store i32 %17, ptr %3, align 4; br label %33; 18: %19
= load i32, ptr %5, align 4; %20 = icmp eq i32 %19, 0; br i1 %20,
label %21, label %25; 21: %22 = load i32, ptr %4, align 4; %23
= sub nsw i32 %22, 1; %24 = call i32 @ackermann(i32 noundef
%23, i32 noundef 1); store i32 %24, ptr %3, align 4; br label %33;
25: %26 = load i32, ptr %4, align 4; %27 = sub nsw i32 %26, 1;
%28 = load i32, ptr %4, align 4; %29 = load i32, ptr %5, align
4; %30 = sub nsw i32 %29, 1; %31 = call i32 @ackermann(i32
noundef %28, i32 noundef %30); %32 = call i32 @ackermann(i32
noundef %27, i32 noundef %31); store i32 %32, ptr %3, align
4; br label %33; 33: %34 = load i32, ptr %3, align 4; ret i32
%34; } C int ackermann(int x, int y) { if (x < 0 || y < 0) return
-1; if (x == 0) return y+1; if (y == 0) return ackermann(x-1,
1); return ackermann(x-1, ackermann(x, y-1)); array indexing
getelementptr inbounds i32, ptr %18, i64 1 (1 is the index here)