User:Piccima/Books/Compiler construction

Compiler construction

 * Introduction
 * Compiler construction
 * Compiler
 * Interpreter
 * History of compiler writing


 * Lexical analysis
 * Lexical analysis
 * Regular expression
 * Regular expression examples
 * Finite-state machine
 * Preprocessor


 * Syntactic analysis
 * Parsing
 * Lookahead
 * Symbol table
 * Abstract syntax
 * Abstract syntax tree
 * Context-free grammar
 * Terminal and nonterminal symbols
 * Left recursion
 * Backus–Naur Form
 * Extended Backus–Naur Form
 * TBNF
 * Top-down parsing
 * Recursive descent parser
 * Tail recursive parser
 * Parsing expression grammar
 * LL parser
 * LR parser
 * Parsing table
 * Simple LR parser
 * Canonical LR parser
 * GLR parser
 * LALR parser
 * Recursive ascent parser
 * Parser combinator
 * Bottom-up parsing
 * Chomsky normal form
 * CYK algorithm
 * Simple precedence grammar
 * Simple precedence parser
 * Operator-precedence grammar
 * Operator-precedence parser
 * Shunting-yard algorithm
 * Chart parser
 * Earley parser
 * The lexer hack
 * Scannerless parsing


 * Semantic analysis
 * Attribute grammar
 * L-attributed grammar
 * LR-attributed grammar
 * S-attributed grammar
 * ECLR-attributed grammar
 * Intermediate language
 * Control flow graph
 * Basic block
 * Call graph
 * Data-flow analysis
 * Use-define chain
 * Live variable analysis
 * Reaching definition
 * Three address code
 * Static single assignment form
 * Dominator
 * C3 linearization
 * Intrinsic function
 * Aliasing
 * Alias analysis
 * Array access analysis
 * Pointer analysis
 * Escape analysis
 * Shape analysis
 * Loop dependence analysis
 * Program slicing


 * Code optimization
 * Compiler optimization
 * Peephole optimization
 * Copy propagation
 * Constant folding
 * Sparse conditional constant propagation
 * Common subexpression elimination
 * Partial redundancy elimination
 * Global value numbering
 * Strength reduction
 * Bounds-checking elimination
 * Inline expansion
 * Return value optimization
 * Dead code
 * Dead code elimination
 * Unreachable code
 * Redundant code
 * Jump threading
 * Superoptimization
 * Loop optimization
 * Induction variable
 * Loop fission
 * Loop fusion
 * Loop inversion
 * Loop interchange
 * Loop-invariant code motion
 * Loop nest optimization
 * Manifest expression
 * Polytope model
 * Loop unwinding
 * Loop splitting
 * Loop tiling
 * Loop unswitching
 * Interprocedural optimization
 * Whole program optimization
 * Adaptive optimization
 * Lazy evaluation
 * Partial evaluation
 * Profile-guided optimization
 * Automatic parallelization
 * Loop scheduling
 * Vectorization
 * Superword Level Parallelism


 * Code generation
 * Code generation
 * Name mangling
 * Register allocation
 * Chaitin's algorithm
 * Rematerialization
 * Sethi-Ullman algorithm
 * Data structure alignment
 * Instruction selection
 * Instruction scheduling
 * Software pipelining
 * Trace scheduling
 * Just-in-time compilation
 * Bytecode
 * Dynamic compilation
 * Dynamic recompilation
 * Object file
 * Code segment
 * Data segment
 * .bss
 * Literal pool
 * Overhead code
 * Link time
 * Relocation
 * Library
 * Static build
 * Architecture Neutral Distribution Format


 * Development techniques
 * Bootstrapping
 * Compiler correctness
 * Jensen's Device
 * Man or boy test
 * Cross compiler
 * Source-to-source compiler


 * Tools
 * Compiler-compiler
 * PQCC
 * Compiler Description Language
 * Comparison of regular expression engines
 * Comparison of parser generators
 * Lex
 * Flex lexical analyser
 * Quex
 * Ragel
 * Yacc
 * Berkeley Yacc
 * ANTLR
 * GNU bison
 * Coco/R
 * GOLD
 * JavaCC
 * JetPAG
 * Lemon Parser Generator
 * LALR parser generator
 * ROSE compiler framework
 * SableCC
 * Scannerless Boolean Parser
 * Spirit Parser Framework
 * S/SL programming language
 * SYNTAX
 * Syntax Definition Formalism
 * TREE-META
 * Frameworks supporting the polyhedral model


 * Case studies
 * GNU Compiler Collection
 * Java performance


 * Literature
 * Compilers: Principles, Techniques, and Tools
 * Principles of Compiler Design
 * The Design of an Optimizing Compiler