Engineering a Compiler: International Student Edition

The proliferation of processors, environments, and constraints on systems has cast compiler technology into a wider variety of settings, changing the compiler and compiler writer's role. No longer is execution speed the sole criterion for judging compiled code. Today, code might be judged on how small it is, how much power it consumes, how well it compresses, or how many page faults it generates. In this evolving environment, the task of building a successful compiler relies upon the compiler writer's ability to balance and blend algorithms, engineering insights, and careful planning. Today's compiler writer must choose a path through a design space that is filled with diverse alternatives, each with distinct costs, advantages, and complexities. Engineering a Compiler explores this design space by presenting some of the ways these problems have been solved, and the constraints that made each of those solutions attractive. By understanding the parameters of the problem and their impact on compiler design, the authors hope to convey both the depth of the problems and the breadth of possible solutions. Their goal is to cover a broad enough selection of material to show readers that real tradeoffs exist, and that the impact of those choices can be both subtle and far-reaching. Authors Keith Cooper and Linda Torczon convey both the art and the science of compiler construction and show best practice algorithms for the major passes of a compiler. Their text re-balances the curriculum for an introductory course in compiler construction to reflect the issues that arise in current practice. Focuses on the back end of the compiler-reflecting the focus of research and development over the last decade. Uses the well-developed theory from scanning and parsing to introduce concepts that play a critical role in optimization and code generation. Introduces the student to optimization through data-flow analysis, SSA form, and a selection of scalar optimizations. Builds on this background to teach modern methods in code generation: instruction selection, instruction scheduling, and register allocation. Presents examples in several different programming languages in order to best illustrate the concept. Provides end-of-chapter exercises, with on-line solutions available to instructors. Table of Contents Overview of Compilation; Scanning; Parsing; Context-Sensitive Analysis; Intermediate Representations; Procedure Abstraction; Code Shape; Introduction to Code Optimization; Data-Flow Analysis; Transformations; Instruction Selection; Instruction Scheduling; Register Allocation; Appendix A: ILOC; Appendix B: Data Structures; Appendix C: Abbreviations, Acronyms, and Glossary

[1]  Stephen Richardson,et al.  Interprocedural analysis vs. procedure integration , 1989, Inf. Process. Lett..

[2]  James R. Goodman,et al.  Code scheduling and register allocation in large basic blocks , 2014, ICS 25th Anniversary.

[3]  Michael G. Burke An interval-based approach to exhaustive and incremental interprocedural data-flow analysis , 1990, TOPL.

[4]  Robert E. Tarjan,et al.  Symbolic Program Analysis in Almost-Linear Time , 1982, SIAM J. Comput..

[5]  Keith D. Cooper,et al.  Live Range Splitting in a Graph Coloring Register Allocator , 1998, International Conference on Compiler Construction.

[6]  Steven S. Muchnick,et al.  Efficient instruction scheduling for a pipelined architecture , 1986, SIGPLAN '86.

[7]  Christopher W. Fraser,et al.  Hard‐coding bottom‐up code generation tables to save time and space , 1990, Softw. Pract. Exp..

[8]  Bernhard Steffen,et al.  Lazy code motion , 1992, PLDI '92.

[9]  Thomas W. Reps Optimal-time incremental semantic analysis for syntax-directed editors , 1982, POPL '82.

[10]  Ken Kennedy,et al.  Interprocedural side-effect analysis in linear time , 1988, PLDI '88.

[11]  George Havas,et al.  A Family of Perfect Hashing Methods , 1996, Comput. J..

[12]  Keith D. Cooper,et al.  Optimizing for reduced code space using genetic algorithms , 1999, LCTES '99.

[13]  Christoph M. Hoffmann,et al.  Pattern Matching in Trees , 1982, JACM.

[14]  Thomas R. Wilcox,et al.  Design and implementation of a diagnostic compiler for PL/I , 1973, CACM.

[15]  Roy Dz-Ching Ju,et al.  A new algorithm for scalar register promotion based on SSA form , 1998, PLDI '98.

[16]  Vincenzo Liberatore,et al.  Evaluation of Algorithms for Local Register Allocation , 1999, CC.

[17]  Rajiv Gupta,et al.  Register allocation via clique separators , 1989, PLDI '89.

[18]  Ron Y. Pinter,et al.  Spill code minimization techniques for optimizing compliers , 1989, PLDI '89.

[19]  Dhananjay M. Dhamdhere,et al.  A composite algorithm for strength reduction and code movement optimization , 2004, International Journal of Computer & Information Sciences.

[20]  Christopher W. Fraser,et al.  Register allocation and exhaustive peephole optimization , 1984, Softw. Pract. Exp..

[21]  Jeffrey D. Ullman,et al.  Monotone data flow analysis frameworks , 1977, Acta Informatica.

[22]  Jeffrey D. Ullman,et al.  A Simple Algorithm for Global Data Flow Analysis Problems , 1975, SIAM J. Comput..

[23]  Brian Randell,et al.  Algol 60 Implementation: The Translation And Use Of Algol 60 Programs On A Computer , 1975 .

[24]  Gary A. Kildall,et al.  A unified approach to global program optimization , 1973, POPL.

[25]  Gregory J. Chaitin,et al.  Register allocation & spilling via graph coloring , 1982, SIGPLAN '82.

[26]  Arthur Sorkin,et al.  Some comments on “A solution to a problem with Morel and Renvoise's 'Global optimization by suppression of partial redundancies'” , 1989, ACM Trans. Program. Lang. Syst..

[27]  Max Hailperin,et al.  Cost-optimal code motion , 1998, TOPL.

[28]  Olivier Temam,et al.  A quantitative analysis of loop nest locality , 1996, ASPLOS VII.

[29]  Bowen Alpern,et al.  Verifying temporal properties without temporal logic , 1989, TOPL.

[30]  Derick Wood The theory of left factored languages: Part 1 , 1969, Comput. J..

[31]  Ron Cytron,et al.  Code motion of control structures in high-level languages , 1986, POPL '86.

[32]  James R. Larus,et al.  Register allocation in the SPUR Lisp compiler , 1986, SIGPLAN '86.

[33]  David R. Karger,et al.  Near-optimal intraprocedural branch alignment , 1997, PLDI '97.

[34]  John Cocke,et al.  Communication: Strenght Reduction for Division and Modulo with Application to Accessing a Multilevel Store , 1980, IBM J. Res. Dev..

[35]  Chau-Wen Tseng,et al.  Improving data locality with loop transformations , 1996, TOPL.

[36]  Monica S. Lam,et al.  Efficient context-sensitive pointer analysis for C programs , 1995, PLDI '95.

[37]  Jr. Guy L. Steele,et al.  Rabbit: A Compiler for Scheme , 1978 .

[38]  John T. Bagwell Local optimizations , 1970 .

[39]  Jack W. Davidson,et al.  A study of a C function inliner , 1988, Softw. Pract. Exp..

[40]  Keith D. Cooper,et al.  How to build an interference graph , 1998 .

[41]  Mark Smotherman,et al.  Efficient DAG construction and heuristic calculation for instruction scheduling , 1991, MICRO 24.

[42]  Susan L. Graham,et al.  An experiment in table driven code generation , 1982, SIGPLAN '82.

[43]  Ken Kennedy,et al.  Efficient call graph analysis , 1992, LOPL.

[44]  Robert L. Bernstein Producing good code for the case statement , 1985, Softw. Pract. Exp..

[45]  Derick Wood,et al.  The Theory of Left Factored Languages: Part 2 , 1970, Computer/law journal.

[46]  Toshio Nakatani,et al.  A new compilation technique for parallelizing loops with unpredictable branches on a VLIW architecture , 1990 .

[47]  Ken Kennedy,et al.  Interprocedural constant propagation , 1986, SIGP.

[48]  Lori Pollock,et al.  An experimental study of several cooperative register allocation and instruction scheduling strategies , 1995, MICRO 1995.

[49]  Mark N. Wegman,et al.  A Fast and Usually Linear Algorithm for Global Flow Analysis , 1976, J. ACM.

[50]  Paul R. Wilson,et al.  Uniprocessor Garbage Collection Techniques , 1992, IWMM.

[51]  Tadao Kasami,et al.  An Efficient Recognition and Syntax-Analysis Algorithm for Context-Free Languages , 1965 .

[52]  Chris J. Cheney A nonrecursive list compacting algorithm , 1970, Commun. ACM.

[53]  Franklin L. DeRemer,et al.  Simple LR(k) grammars , 1971, Commun. ACM.

[54]  Jay Earley,et al.  An efficient context-free parsing algorithm , 1970, Commun. ACM.

[55]  Brian L. Marks Compilation to Compact Code , 1980, IBM J. Res. Dev..

[56]  Rodney Farrow,et al.  LINGUIST-86: Yet another translator writing system based on attribute grammars , 1982, SIGPLAN '82.

[57]  Frank DeRemer,et al.  Efficient computation of LALR(1) look-ahead sets , 1979, SIGPLAN '79.

[58]  Christopher W. Fraser,et al.  The Design and Application of a Retargetable Peephole Optimizer , 1980, TOPL.

[59]  J. Heller,et al.  Sequencing Aspects of Multiprogramming , 1961, JACM.

[60]  William A. Wulf,et al.  The Design of an Optimizing Compiler , 1975 .

[61]  Dirk Grunwald,et al.  Reducing branch costs via branch alignment , 1994, ASPLOS VI.

[62]  Michael Rodeh,et al.  Global instruction scheduling for superscalar machines , 1991, PLDI '91.

[63]  Preston Briggs,et al.  Register allocation via graph coloring , 1992 .

[64]  John H. Reif,et al.  Symbolic evaluation and the global value graph , 1977, POPL.

[65]  Christopher W. Fraser,et al.  Engineering a simple, efficient code-generator generator , 1992, LOPL.

[66]  John R. Ellis,et al.  Bulldog: A Compiler for VLIW Architectures , 1986 .

[67]  Christopher W. Fraser,et al.  Analyzing and compressing assembly code , 1984, SIGPLAN '84.

[68]  Jeffrey D. Ullman,et al.  Fast algorithms for the elimination of common subexpressions , 1972, Acta Informatica.

[69]  John E. Hopcroft,et al.  An n log n algorithm for minimizing states in a finite automaton , 1971 .

[70]  Mark Scott Johnson,et al.  Effectiveness of a machine-level, global optimizer , 1986, SIGPLAN '86.

[71]  Manuvir Das,et al.  Unification-based pointer analysis with directional assignments , 2000, PLDI '00.

[72]  Charles N. Fischer,et al.  Probabilistic register allocation , 1992, PLDI '92.

[73]  Cliff Click,et al.  Global code motion/global value numbering , 1995, PLDI '95.

[74]  Donald E. Knuth,et al.  On the Translation of Languages from Left to Right , 1965, Inf. Control..

[75]  Ken Kennedy,et al.  Fast interprocedual alias analysis , 1989, POPL '89.

[76]  Glenn Krasner,et al.  Smalltalk-80: bits of history, words of advice , 1983 .

[77]  Dhananjay M. Dhamdhere,et al.  A composite hoisting-strength reduction transformation for global program optimization part ii , 1982 .

[78]  Henry Massalin Superoptimizer: a look at the smallest program , 1987, ASPLOS 1987.

[79]  Thomas P. Murtagh An improved storage management scheme for block structured languages , 1991, TOPL.

[80]  Mehdi Jazayeri,et al.  Alternating semantic evaluator , 1975, ACM '75.

[81]  Donald E. Knuth,et al.  Semantics of context-free languages , 1968, Mathematical systems theory.

[82]  Edward S. Lowry,et al.  Object code optimization , 1969, CACM.

[83]  Donald Ervin Knuth,et al.  The Art of Computer Programming , 1968 .

[84]  Thomas R. Gross,et al.  Postpass Code Optimization of Pipeline Constraints , 1983, TOPL.

[85]  Timothy J. Harvey,et al.  Practical improvements to the construction and destruction of static single assignment form , 1998 .

[86]  Robert Fenichel,et al.  A LISP garbage-collector for virtual-memory computer systems , 1969, CACM.

[87]  Friedrich L. Bauer,et al.  Revised report on the algorithm language ALGOL 60 , 1963, CACM.

[88]  B. Ramakrishna Rau,et al.  Some scheduling techniques and an easily schedulable horizontal architecture for high performance scientific computing , 1981, MICRO 14.

[89]  Mikkel Thorup,et al.  Dominators in Linear Time , 1999, SIAM J. Comput..

[90]  Brian R. Nickerson Graph coloring register allocation for processors with multi-register operands , 1990, PLDI '90.

[91]  Alfred V. Aho,et al.  Optimal Code Generation for Expression Trees , 1976, J. ACM.

[92]  Alfred V. Aho,et al.  On finding lowest common ancestors in trees , 1973, SIAM J. Comput..

[93]  Philippe Aigrain,et al.  Experience with a Graham-Glanville style code generator , 1984, SIGPLAN '84.

[94]  Allen,et al.  Optimizing Compilers for Modern Architectures , 2004 .

[95]  Susan J. Eggers,et al.  Integrating register allocation and instruction scheduling for RISCs , 1991, ASPLOS IV.

[96]  Christopher W. Fraser,et al.  Automatic generation of fast optimizing code generators , 1988, PLDI '88.

[97]  Joseph A. Fisher,et al.  Trace Scheduling: A Technique for Global Microcode Compaction , 1981, IEEE Transactions on Computers.

[98]  Ken Kennedy,et al.  Scalar replacement in the presence of conditional control flow , 1994, Softw. Pract. Exp..

[99]  Michael D. Smith,et al.  Procedure placement using temporal-ordering information , 1999, TOPL.

[100]  David F. Bacon,et al.  Compiler transformations for high-performance computing , 1994, CSUR.

[101]  Charles N. Fischer,et al.  Description-driven code generation using attribute grammars , 1982, POPL '82.

[102]  Edgar T. Irons A syntax directed compiler for ALGOL 60 , 1983, CACM.

[103]  Susan L. Graham,et al.  A new method for compiler code generation , 1978, POPL '78.

[104]  Robert S. Cohn,et al.  Hot cold optimization of large Windows/NT applications , 1996, Proceedings of the 29th Annual IEEE/ACM International Symposium on Microarchitecture. MICRO 29.

[105]  Woody Lichtenstein,et al.  The multiflow trace scheduling compiler , 1993, The Journal of Supercomputing.

[106]  John Cocke,et al.  A program data flow analysis procedure , 1976, CACM.

[107]  Ken Thompson,et al.  Programming Techniques: Regular expression search algorithm , 1968, Commun. ACM.

[108]  Alain Deutsch,et al.  Interprocedural may-alias analysis for pointers: beyond k-limiting , 1994, PLDI '94.

[109]  Keith D. Cooper,et al.  Combining analyses, combining optimizations , 1995, TOPL.

[110]  Robert E. Noonan,et al.  A code generator generator language , 1979, SIGPLAN '79.

[111]  Todd A. Proebsting Optimizing an ANSI C interpreter with superoperators , 1995, POPL '95.

[112]  Frances E. Allen,et al.  Control-flow analysis , 2022 .

[113]  John Cocke Global common subexpression elimination , 1970 .

[114]  Gerhard Goos,et al.  Experience with an automatic code generator generator , 1982, SIGPLAN '82.

[115]  Jong-Deok Choi,et al.  Interprocedural pointer alias analysis , 1999, TOPL.

[116]  Melvin E. Conway,et al.  Design of a separable transition-diagram compiler , 1963, CACM.

[117]  Randolph G. Scarborough,et al.  Improved Optimization of FORTRAN Object Programs , 1980, IBM J. Res. Dev..

[118]  Jeffrey D. Ullman,et al.  Global Data Flow Analysis and Iterative Algorithms , 1976, J. ACM.

[119]  S C Kleene,et al.  Representation of Events in Nerve Nets and Finite Automata , 1951 .

[120]  Murray Hill,et al.  Yacc: Yet Another Compiler-Compiler , 1978 .

[121]  M. Wegman,et al.  Global value numbers and redundant computations , 1988, POPL '88.

[122]  Jong-Deok Choi,et al.  Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects , 1993, POPL '93.

[123]  Shlomit S. Pinter,et al.  Register allocation with instruction scheduling , 1993, PLDI '93.

[124]  Dhananjay M. Dhamdhere Practical adaption of the global optimization algorithm of Morel and Renvoise , 1991, TOPL.

[125]  Andrew Ayers,et al.  Aggressive inlining , 1997, PLDI '97.

[126]  Robert E. Tarjan,et al.  Fast Algorithms for Solving Path Problems , 1981, JACM.

[127]  Mark N. Wegman,et al.  Efficiently computing static single assignment form and the control dependence graph , 1991, TOPL.

[128]  David R. Chase,et al.  An improvement to bottom-up tree pattern matching , 1987, POPL '87.

[129]  R. G. G. Cattell,et al.  Automatic Derivation of Code Generators from Machine Descriptions , 1980, TOPL.

[130]  Peter B. Sheridan,et al.  The arithmetic translator-compiler of the IBM FORTRAN automatic coding system , 1959, CACM.

[131]  Michael Hind,et al.  Which pointer analysis should I use? , 2000, ISSTA '00.

[132]  John W. Backus,et al.  The history of FORTRAN I, II, and III , 1978, SIGP.

[133]  Manfred P. Stadel,et al.  A variation of Knoop, Rüthing, and Steffen's Lazy Code Motion , 1993, SIGP.

[134]  David R. Hanson Fast allocation and deallocation of memory based on object lifetimes , 1990, Softw. Pract. Exp..

[135]  William H. Harrison A New Strategy for Code Generation - the General-Purpose Optimizing Compiler , 1979, IEEE Trans. Software Eng..

[136]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1987, TOPL.

[137]  Alfred V. Aho,et al.  The Design and Analysis of Computer Algorithms , 1974 .

[138]  Henry Lieberman,et al.  A real-time garbage collector based on the lifetimes of objects , 1983, CACM.

[139]  Scott Kipling Warren The coroutine model of attribute grammar evaluation. , 1976 .

[140]  Bowen Alpern,et al.  Interactive proof checking , 1984, POPL.

[141]  Philip H. Sweany,et al.  Dominator-path scheduling: a global scheduling method , 1992, MICRO 1992.

[142]  Linda Torczon,et al.  An efficient representation for sparse sets , 1993, LOPL.

[143]  C. Norris,et al.  A schedular-sensitive global register allocator , 1993, Supercomputing '93.

[144]  Keith D. Cooper,et al.  An experiment with inline substitution , 1991, Softw. Pract. Exp..

[145]  Charles N. Fischer,et al.  Crafting a Compiler with C , 1991 .

[146]  Monica S. Lam,et al.  A data locality optimizing algorithm , 1991, PLDI '91.

[147]  Dov Harel,et al.  A linear algorithm for finding dominators in flow graphs and related problems , 1985, STOC '85.

[148]  Jack W. Davidson,et al.  Profile guided code positioning , 1990, SIGP.

[149]  Robert M. Shapiro,et al.  THE REPRESENTATION OF ALGORITHMS , 1969 .

[150]  C. Robert Morgan,et al.  Building an Optimizing Compiler , 1998 .

[151]  Michael Sipser,et al.  Introduction to the Theory of Computation , 1996, SIGA.

[152]  J. M. Foster,et al.  A syntax improving program , 1968, Comput. J..

[153]  Keith D. Cooper,et al.  Operator strength reduction , 2001, TOPL.

[154]  Richard Kenner,et al.  Eliminating branches using a superoptimizer and the GNU C compiler , 1992, PLDI '92.

[155]  Ken Kennedy,et al.  Constructing the Procedure Call Multigraph , 1990, IEEE Trans. Software Eng..

[156]  Derick Wood A Further Note on Top-Down Deterministic Languages , 1971, Comput. J..

[157]  Robert Giegerich,et al.  A truly generative semantics-directed compiler generator , 1982, SIGPLAN '82.

[158]  Anne Rogers,et al.  Software support for speculative loads , 1992, ASPLOS V.

[159]  Christopher W. Fraser Automatic inference of models for statistical code compression , 1999, PLDI '99.

[160]  Robert W. Floyd,et al.  An algorithm for coding efficient arithmetic operations , 1961, CACM.

[161]  Bowen Alpern,et al.  Detecting equality of variables in programs , 1988, POPL '88.

[162]  Michael Wolfe,et al.  High performance compilers for parallel computing , 1995 .

[163]  Robin Milner,et al.  Definition of standard ML , 1990 .

[164]  Thomas W. Christopher,et al.  High-quality code generation via bottom-up tree pattern matching , 1986, POPL '86.

[165]  Dhananjay M. Dhamdhere A fast algorithm for code movement optimisation , 1988, SIGP.

[166]  Susan Horwitz,et al.  Fast and accurate flow-insensitive points-to analysis , 1997, POPL '97.

[167]  Rajiv Gupta,et al.  Region Scheduling: An Approach for Detecting and Redistributing Parallelism , 1990, IEEE Trans. Software Eng..

[168]  Robert E. Tarjan,et al.  Amortized efficiency of list update and paging rules , 1985, CACM.

[169]  Walter L. Ruzzo,et al.  An Improved Context-Free Recognizer , 1980, ACM Trans. Program. Lang. Syst..

[170]  Soo-Mook Moon,et al.  Optimistic register coalescing , 1998, Proceedings. 1998 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.98EX192).

[171]  David Callahan,et al.  Register allocation via hierarchical graph coloring , 1991, PLDI '91.

[172]  Ken Kennedy,et al.  An algorithm for reduction of operator strength , 1977, Commun. ACM.

[173]  Barbara G. Ryder,et al.  Pointer-induced aliasing: a problem classification , 1991, POPL '91.

[174]  Olin Shivers,et al.  Control flow analysis in scheme , 1988, PLDI '88.

[175]  Alfred V. Aho,et al.  Code generation using tree matching and dynamic programming , 1989, ACM Trans. Program. Lang. Syst..

[176]  Dexter Kozen,et al.  Automata and Computability , 1997, Undergraduate Texts in Computer Science.

[177]  Fred C. Chow,et al.  A portable machine-independent global optimizer--design and measurements , 1984 .

[178]  Martin Hopkins,et al.  An overview of the PL.8 compiler , 1982, SIGPLAN '82.

[179]  David Gries,et al.  Compiler Construction for Digital Computers , 1971 .

[180]  A. P. Yershóv ALPHA—An Automatic Programming System of High Efficiency , 1966, JACM.

[181]  Michael D. Smith,et al.  Efficient superscalar performance through boosting , 1992, ASPLOS V.

[182]  Ken Kennedy,et al.  Coloring heuristics for register allocation , 1989, SIGP.

[183]  Alfred V. Aho,et al.  Compilers: Principles, Techniques, and Tools , 1986, Addison-Wesley series in computer science / World student series edition.

[184]  Gordon D. Plotkin,et al.  Call-by-Name, Call-by-Value and the lambda-Calculus , 1975, Theor. Comput. Sci..

[185]  Robert E. Tarjan,et al.  A Unified Approach to Path Problems , 1981, JACM.

[186]  Frances E. Allen,et al.  The History of Language Processor Technology in IBM , 1981, IBM J. Res. Dev..

[187]  Ken Kennedy,et al.  Node listings applied to data flow analysis , 1975, POPL '75.

[188]  Linda Torczon,et al.  Interprocedural optimization: eliminating unnecessary recompilation , 1986, SIGPLAN '86.

[189]  Vivek Sarkar,et al.  Combining Register Allocation and Instruction Scheduling , 1995 .

[190]  Charles N. Fischer,et al.  Zero-cost range splitting , 1994, PLDI '94.

[191]  V. Klema LINPACK user's guide , 1980 .

[192]  Ken Kennedy,et al.  Improving register allocation for subscripted variables , 1990, SIGP.

[193]  Richard Edwin Stearns,et al.  Syntax-Directed Transduction , 1966, JACM.

[194]  Clark Wiedmann Steps toward an APL compiler , 1979 .

[195]  Ken Kennedy,et al.  Applications of a graph grammar for program control flow analysis , 1977, POPL.

[196]  Robert Paige,et al.  Using Multiset Discrimination to Solve Language Processing Problems Without Hashing , 1995, Theor. Comput. Sci..

[197]  Jeffrey D. Ullman,et al.  The Generation of Optimal Code for Arithmetic Expressions , 1970, JACM.

[198]  Christopher W. Fraser,et al.  Automatic generation of peephole optimizations , 1984, SIGPLAN '84.

[199]  Richard M. Karp,et al.  Index Register Allocation , 1966, JACM.

[200]  Jr. Kenneth Wade Kennedy Global flow analysis and register allocation for simple code structures , 1971 .

[201]  Keith D. Cooper,et al.  Non-local Instruction Scheduling with Limited Code Growth , 1998, LCTES.

[202]  Andrew W. Appel,et al.  Iterated register coalescing , 1996, TOPL.

[203]  Mark N. Wegman,et al.  Analysis of pointers and structures , 1990, SIGP.

[204]  Jeffrey M. Barth An interprocedural data flow analysis algorithm , 1977, POPL '77.

[205]  Keith D. Cooper,et al.  Register promotion in C programs , 1997, PLDI '97.

[206]  Peter Lucas Die Strukturanalyse von Formelübersetzern / Analysis of the structure of formula translators , 1961, Elektron. Rechenanlagen.

[207]  Haim Kaplan,et al.  Linear-time pointer-machine algorithms for least common ancestors, MST verification, and dominators , 1998, STOC '98.

[208]  Etienne Morel,et al.  Global optimization by suppression of partial redundancies , 1979, CACM.

[209]  Martin Richards The portability of the BCPL compiler , 1971, Softw. Pract. Exp..

[210]  Trevor N. Mudge,et al.  Improving code density using compression techniques , 1997, Proceedings of 30th Annual International Symposium on Microarchitecture.

[211]  Susan J. Eggers,et al.  Balanced scheduling: instruction scheduling when memory latency is uncertain , 1993, PLDI '93.

[212]  Robert E. Tarjan,et al.  Testing flow graph reducibility , 1973, J. Comput. Syst. Sci..

[213]  Steven S. Muchnick,et al.  Advanced Compiler Design and Implementation , 1997 .

[214]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[215]  John Cocke,et al.  Programming languages and their compilers: Preliminary notes , 1969 .

[216]  Charles N. Fischer,et al.  The Implementation of Run-Time Diagnostics in Pascal , 1980, IEEE Transactions on Software Engineering.

[217]  Thomas J. Pennello,et al.  Very fast LR parsing , 1986, SIGPLAN '86.

[218]  Matthew T. O'Keefe,et al.  Spill code minimization via interference region spilling , 1997, PLDI '97.

[219]  Charles N. Fischer,et al.  Linear-time, optimal code scheduling for delayed-load architectures , 1991, PLDI '91.

[220]  Daniel G. Bobrow,et al.  Combining generational and conservative garbage collection: framework and implementations , 1989, POPL '90.

[221]  Thomas R. Gross,et al.  Global Register Allocation Based on Graph Fusion , 1996, LCPC.

[222]  Robert E. Tarjan,et al.  A fast algorithm for finding dominators in a flowgraph , 1979, TOPL.

[223]  Daniel H. Younger,et al.  Recognition and Parsing of Context-Free Languages in Time n^3 , 1967, Inf. Control..

[224]  Andrew Binstock,et al.  Practical algorithms for programmers , 1995 .

[225]  Alfred V. Aho,et al.  Deterministic parsing of ambiguous grammars , 1975, Commun. ACM.

[226]  Hans-Juergen Boehm,et al.  Garbage collection in an uncooperative environment , 1988, Softw. Pract. Exp..

[227]  Sidney B. Gasser Program optimization , 1972 .

[228]  S. Lavrov Store economy in closed operator schemes , 1962 .

[229]  KEN KENNEDY,et al.  Use-Definition Chains with Applications , 1978, Comput. Lang..

[230]  Monica S. Lam,et al.  RETROSPECTIVE : Software Pipelining : An Effective Scheduling Technique for VLIW Machines , 1998 .

[231]  R. G. G. Cattell,et al.  Code generation in a machine-independent compiler , 1979, SIGPLAN '79.

[232]  Robert McNaughton,et al.  Regular Expressions and State Graphs for Automata , 1960, IRE Trans. Electron. Comput..

[233]  Peter L. Bird An implementation of a code generator specification language for table driven code generators , 1982, SIGPLAN '82.

[234]  George E. Collins,et al.  A method for overlapping and erasure of lists , 1960, CACM.

[235]  John L. Hennessy,et al.  The priority-based coloring approach to register allocation , 1990, TOPL.

[236]  Christopher W. Fraser,et al.  Automatic inference and fast interpretation of peephole optimization rules† , 1987, Softw. Pract. Exp..

[237]  Christopher W. Fraser,et al.  Integrating code generation and optimization , 1986, SIGPLAN '86.

[238]  Scott A. Mahlke,et al.  The superblock: An effective technique for VLIW and superscalar compilation , 1993, The Journal of Supercomputing.

[239]  Keith D. Cooper,et al.  Improvements to graph coloring register allocation , 1994, TOPL.

[240]  Keith D. Cooper,et al.  Stochastic instruction scheduling , 2000 .

[241]  William M. Waite,et al.  An efficient machine-independent procedure for garbage collection in various list structures , 1967, CACM.

[242]  Susan L. Graham,et al.  Table-Driven Code Generation , 1980, Computer.

[243]  David Alex Lamb Construction of a peephole optimizer , 1981, Softw. Pract. Exp..

[244]  Robert R. Kessler,et al.  Peep: an architectural description driven peephole optimizer , 1984, SIGPLAN '84.

[245]  John L. Hennessy,et al.  Register allocation by priority-based coloring , 1984, SIGPLAN '84.

[246]  Paul Walton Purdom,et al.  Immediate Predominators in a Directed Graph [H] (Algorithm 430) , 1972, Commun. ACM.

[247]  Jacques Cohen,et al.  Garbage Collection of Linked Data Structures , 1981, CSUR.

[248]  Ronald L. Rivest,et al.  On self-organizing sequential search heuristics , 1976, CACM.

[249]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[250]  Philip H. Sweany,et al.  Post-compaction register assignment in a retargetable compiler , 1990, [1990] Proceedings of the 23rd Annual Workshop and Symposium@m_MICRO 23: Microprogramming and Microarchitecture.

[251]  Andrei P. Ershov On programming of arithmetic operations , 1958, CACM.

[252]  Barbara G. Ryder,et al.  Constructing the Call Graph of a Program , 1979, IEEE Transactions on Software Engineering.

[253]  Kathryn S. McKinley,et al.  Tile size selection using cache organization and data layout , 1995, PLDI '95.

[254]  Laurie J. Hendren,et al.  Context-sensitive interprocedural points-to analysis in the presence of function pointers , 1994, PLDI '94.

[255]  John Banning,et al.  : An Efficient , 2022 .

[256]  William E. Weihl,et al.  Interprocedural data flow analysis in the presence of pointers, procedure variables, and label variables , 1980, POPL '80.

[257]  Manfred P. Stadel,et al.  A solution to a problem with Morel and Renvoise's “Global optimization by suppression of partial redundancies” , 1988, TOPL.

[258]  Keith D. Cooper,et al.  Coloring register pairs , 1992, LOPL.

[259]  W. M. McKeeman,et al.  Peephole optimization , 1965, CACM.

[260]  Eduardo Pelegrí-Llopart,et al.  Optimal code generation for expression trees: an application BURS theory , 1988, POPL '88.

[261]  Phil Pfeiffer,et al.  Dependence analysis for pointer variables , 1989, PLDI '89.

[262]  Rodney Farrow Automatic generation of fixed-point-finding evaluators for circular, but well-defined, attribute grammars , 1986, SIGPLAN '86.

[263]  Kristen Nygaard,et al.  The development of the SIMULA languages , 1978, SIGP.

[264]  Susan J. Eggers,et al.  Improving balanced scheduling with compiler optimizations that increase instruction-level parallelism , 1995, PLDI '95.

[265]  Keith D. Cooper,et al.  Value-driven redundancy elimination , 1996 .

[266]  Alexander Aiken,et al.  Optimal loop parallelization , 1988, PLDI '88.

[267]  Thomas Reps,et al.  The Synthesizer Generator: A System for Constructing Language-Based Editors , 1988 .

[268]  Sanjay M. Krishnamurthy,et al.  A brief survey of papers on scheduling for pipelined processors , 1990, SIGP.

[269]  Daniel G. Bobrow,et al.  An efficient, incremental, automatic garbage collector , 1976, CACM.

[270]  Alan M. Bauer,et al.  Does APL really need run‐time checking? , 1974, Softw. Pract. Exp..

[271]  Jeffrey D. Ullman,et al.  Characterizations of Reducible Flow Graphs , 1974, JACM.

[272]  Rajiv Gupta,et al.  Complete removal of redundant expressions , 1998, PLDI 1998.

[273]  Douglas T. Ross,et al.  Automatic generation of efficient lexical processors using finite state techniques , 1968, CACM.

[274]  Todd A. Proebsting Simple and efficient BURS table generation , 1992, PLDI '92.

[275]  Laszlo A. Belady,et al.  A Study of Replacement Algorithms for Virtual-Storage Computer , 1966, IBM Syst. J..

[276]  Daniel J. Rosenkrantz,et al.  Properties of Deterministic Top-Down Grammars , 1970, Inf. Control..

[277]  David B. Whalley,et al.  Avoiding unconditional jumps by code replication , 1992, PLDI '92.

[278]  Hans-Juergen Boehm,et al.  Implementing RUSSELL , 1986, SIGPLAN '86.

[279]  J. Bradley Chen,et al.  Improving instruction locality with just-in-time code layout , 1997 .

[280]  Susan Horwitz,et al.  Generating editing environments based on relations and attributes , 1986, TOPL.