1 / 42

Compiler Construction

Compiler Construction. Overview . Today ’ s Goals. Summary of the subjects we ’ ve covered Perspectives and final remarks. High-level View. Definitions Compiler consumes source code & produces target code usually translate high-level language programs into machine code

ariadne
Download Presentation

Compiler Construction

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Compiler Construction Overview

  2. Today’s Goals • Summary of the subjects we’ve covered • Perspectives and final remarks

  3. High-level View Definitions • Compiler consumes source code & produces target code • usually translate high-level language programs into machine code • Interpreter consumes executables & produces results • virtual machine for the input code

  4. Why Study Compilers? • Compilers are important • Enabling technology for languages, software development • Allow programmers to focus on problem solving, hiding the hardware complexity • Responsible for good system performance • Compilers are useful • Language processing is broadly applicable • Compilers are fun • Combine theory and practice • Overlap with other CS subjects • Hard problems • Engineering and trade-offs • Got a taste in the labs!

  5. Structure of Compilers

  6. The Front-end

  7. Lexical Analysis • Scanner • Maps character stream into tokens • Automate scanner construction • Define tokens using Regular Expressions • Construct NFA (Nondeterministic Finite Automata) to recognize REs • Transform NFA to DFA • Convert NFA to DFA through subset construction • DFA minimization (set split) • Building scanners from DFA • Tools • ANTLR, lex

  8. Syntax Analysis • Parsing language using CFG (context-free grammar) • CFG grammar theory • Derivation • Parse tree • Grammar ambiguity • Parsing • Top-down parsing • recursive descent • table-driven LL(1) • Bottom-up parsing • LR(1) shift reduce parsing • Operator precedence parsing

  9. Top-down Predictive Parsing • Basic idea Build parse tree from root. Given A → α | β,use look-ahead symbol to choose between α & β • Recursive descent • Table-driven LL(1) • Left recursion elimination

  10. Bottom-up Shift-Reduce Parsing • Build reverse rightmost derivation • The key is to find handle (rhs of production) • All active handles include top of stack (TOS) • Shift inputs until TOS is right end of a handle • Language of handles is regular (finite) • Build a handle-recognizing DFA • ACTION & GOTO tables encode the DFA

  11. Semantic Analysis • Analyze context and semantics • types and other semantic checks • Attribute grammar • associate evaluation rules with grammar production • Ad-hoc • build symbol table

  12. Intermediate Representation

  13. Intermediate Representation • Front-end translates program into IR format for further analysis and optimization • IR encodes the compiler’s knowledge of the program • Largely machine-independent • Move closer to standard machine model • AST Tree: high-level • Linear IR: low-level • ILOC 3-address code • Assembly-level operations • Expose control flow, memory addressing • unlimited virtual registers

  14. Procedure Abstraction • Procedure is key language construct for building large systems • Name Space • Caller-callee interface: linkage convention • Control transfer • Context protection • Parameter passing and return value • Run-time support for nested scopes • Activation record, access link, display • Inheritance and dynamic dispatch for OO • multiple inheritance • virtual method table

  15. The Back-end

  16. The Back-end Instruction selection • Mapping IR into assembly code • Assumes a fixed storage mapping & code shape • Combining operations, using address modes Instruction scheduling • Reordering operations to hide latencies • Assumes a fixed program (set of operations) • Changes demand for registers Register allocation • Deciding which values will reside in registers • Changes the storage mapping, may add false sharing • Concerns about placement of data & memory operations

  17. Code Generation • Expressions • Recursive tree walk on AST • Direct integration with parser • Assignment • Array reference • Boolean & Relational Values • If-then-else • Case • Loop • Procedure call

  18. Instruction Selection • Hand-coded tree-walk code generator • Automatic instruction selection • Pattern matching • Peephole Matching • Tree-pattern matching through tiling

  19. Instruction Scheduling The Problem Given a code fragment for some target machine and the latencies for each individual operation, reorder the operations to minimize execution time Build Precedence Graph List scheduling NP-complete problem Heuristics work well for basic blocks • forward list scheduling • backward list scheduling Scheduling for larger regions • EBB and cloning • Trace scheduling

  20. Register Allocation • Local register allocation • top-down • bottom-up • Global register allocation • Find live-range • Build an interference graph GI • Construct a k-coloring of interference graph • Map colors onto physical registers

  21. Web-based Live Ranges • Connect common defs and uses • Solve the Reaching data-flow problem!

  22. Interference Graph The interference graph, GI • Nodes in GI represent live ranges • Edges in GI represent individual interferences • For x, y ∈ GI, <x,y> ∈ iff x and y interfere • A k-coloring of GI can be mapped into an • allocation to k registers

  23. Key Observation on Coloring • Any vertex n that has fewer than k neighbors in the interference graph (n°< k) can always be colored ! • Remove nodes n°< k for GI’, coloring for GI’ is also coloring for GI

  24. Chaitin’s Algorithm • While ∃ vertices with < k neighbors in GI • Pick any vertex n such that n°< k and put it on the stack • Remove that vertex and all edges incident to it from GI • This will lower the degree of n’s neighbors • If GI is non-empty (all vertices have k or more neighbors) then: • Pick a vertex n (using some heuristic) and spill the live range associated with n • Remove vertex n from GI , along with all edges incident to it and put it on the stack • If this causes some vertex in GI to have fewer than k neighbors, then go to step 1; otherwise, repeat step 2 • If no spill, successively pop vertices off the stack and color them in the lowest color not used by some neighbor; otherwise, insert spill code, recompute GI and start from step 1

  25. Brigg’s Improvement Nodes can still be colored even with > k neighbors if some neighbors have same color • While ∃ vertices with < k neighbors in GI • Pick any vertex n such that n°< k and put it on the stack • Remove that vertex and all edges incident to it from GI • This may create vertices with fewer than k neighbors • If GI is non-empty (all vertices have k or more neighbors) then: • Pick a vertex n (using some heuristic condition), push n on the stack and remove n from GI , along with all edges incident to it • If this causes some vertex in GI to have fewer than k neighbors, then go to step 1; otherwise, repeat step 2 • Successively pop vertices off the stack and color them in the lowest color not used by some neighbor • If some vertex cannot be colored, then pick an uncolored vertex to spill, spill it, and restart at step 1

  26. The Middle-end: Optimizer

  27. Principles of Compiler Optimization • safety • Does applying the transformation change the results of executing the code? • profitability • Is there a reasonable expectation that applying the transformation will improve the code? • opportunity • Can we efficiently and frequently find places to apply optimization • Optimizing compiler • Program Analysis • Program Transformation

  28. Program Analysis • Control-flow analysis • Data-flow analysis

  29. Control Flow Analysis • Basic blocks • Control flow graph • Dominator tree • Natural loops • Dominance frontier • the join points for SSA • insert Ф node

  30. Data Flow Analysis • “compile-time reasoning about the runtime flow of values” • represent effects of each basic block • propagate facts around control flow graph

  31. DFA: The Big Picture • Set up a set of equations that relate program properties at different program points in terms of the properties at "nearby" program points • Transfer function • Forward analysis: compute OUT(B) in terms IN(B) • Available expressions • Reaching definition • Backward analysis: compute IN(B) in terms of OUT(B) • Variable liveness • Very busy expressions • Meet function for join points • Forward analysis: combine OUT(p) of predecessors to form IN(B) • Backward analysis: combine IN(s) of successors to form OUT(B)

  32. Available Expression Basic block b • IN(b): expressions available at b’s entry • OUT(b): expressiongs available at b’s exit • Local sets • def(b): expressions defined in b and available on exit • killed(b): expressions killed in b • An expression is killed in b if operands are assigned in b • Transfer function • OUT(b) = def(b) ∪ (IN(b) – killed(b)) • Meet function • IN(b) =

  33. More Data Flow Problems • AVAIL Equations • More data flow problems • Reaching Definition • Liveness

  34. Compiler Optimization • Local optimization • DAG CSE • Value numbering • Global optimization enabled by DFA • Global CSE (AVAIL) • Constant propagation (Def-Use) • Dead code elimination (Use-Def) • Advanced topic: SSA

  35. Perspective • Front end: essentially solved problem • Middle end: domain-specific language • Back end: new architecture • Verifying compiler, reliability, security

  36. Interesting Stuff We Skipped • Interprocedural analysis • Alias (pointer) analysis • Garbage collection • Check the literature reference in EaC

  37. How will you use the knowledge? • As informed programmer • As informed small language designer • As informed hardware engineer • As compiler writer

  38. Informed Programmer • “Knowledge is power” • Compiler is no longer a black box • Know how compiler works • Implications • Use of language features • Avoid those can cause problem • Give compiler hints • Code optimization • Don’t optimize prematurely • Don’t write complicated code • Debugging • Understand the compiled code

  39. Solving Problem the Compiler Way • Solve problems from language/compiler perspective • Implement simple language • Extend language

  40. Informed Hardware Engineer • Compiler support for programmable hardware • pervasive computing • new back-ends for new processors • Design new architectures • what can compiler do and not do • how to expose and use compiler to manage hardware resources

  41. Compiler Writer • Make a living by writing compilers! • Theory • Algorithms • Engineering • We have built: • scanner • parser • AST tree builder, type checker • register allocator • instruction scheduler • Used compiler generation tools • ANTLR, lex, yacc, etc On track to jump into compiler development!

  42. Final Remarks • Compiler construction • Theory • Implementation • How to use what you learned in this lecture? • As informed programmer • As informed small language designer • As informed hardware engineer • As compiler writer … and live happily ever after

More Related