Engineering a Compiler: International Student Edition
暂无分享,去创建一个
[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.