%%% -*-BibTeX-*- %%% ==================================================================== %%% BibTeX-file{ %%% author = "Nelson H. F. Beebe", %%% version = "1.16", %%% date = "05 February 2021", %%% time = "15:04:34 MST", %%% filename = "lcc.bib", %%% address = "University of Utah %%% Department of Mathematics, 110 LCB %%% 155 S 1400 E RM 233 %%% Salt Lake City, UT 84112-0090 %%% USA", %%% telephone = "+1 801 581 5254", %%% FAX = "+1 801 581 4148", %%% URL = "http://www.math.utah.edu/~beebe", %%% checksum = "35847 1471 6474 68615", %%% email = "beebe at math.utah.edu, beebe at acm.org, %%% beebe at computer.org (Internet)", %%% codetable = "ISO/ASCII", %%% keywords = "bibliography; BibTeX; lcc C compiler", %%% license = "public domain", %%% supported = "yes", %%% docstring = "This is a bibliography on publications %%% about, or based on, the AT&T/Princeton %%% lcc C compiler. %%% %%% The compiler developers maintain at Web site %%% with lcc-related publications at %%% %%% http://www.cs.princeton.edu/software/lcc/doc/ %%% %%% At version 1.16, the year coverage looked %%% like this: %%% %%% 1990 ( 1) 1995 ( 6) 2000 ( 0) %%% 1991 ( 2) 1996 ( 4) 2001 ( 7) %%% 1992 ( 4) 1997 ( 1) 2002 ( 1) %%% 1993 ( 2) 1998 ( 1) 2003 ( 2) %%% 1994 ( 1) 1999 ( 3) 2004 ( 2) %%% %%% Article: 28 %%% Book: 1 %%% InProceedings: 4 %%% Misc: 3 %%% Proceedings: 1 %%% %%% Total entries: 37 %%% %%% The checksum field above contains a CRC-16 %%% checksum as the first value, followed by the %%% equivalent of the standard UNIX wc (word %%% count) utility output of lines, words, and %%% characters. This is produced by Robert %%% Solovay's checksum utility.", %%% } %%% ==================================================================== %%% ==================================================================== %%% Acknowledgement abbreviations: @String{ack-nhfb = "Nelson H. F. Beebe, University of Utah, Department of Mathematics, 110 LCB, 155 S 1400 E RM 233, Salt Lake City, UT 84112-0090, USA, Tel: +1 801 581 5254, FAX: +1 801 581 4148, e-mail: \path|beebe@math.utah.edu|, \path|beebe@acm.org|, \path|beebe@computer.org| (Internet), URL: \path|http://www.math.utah.edu/~beebe/|"} %%% ==================================================================== %%% Journal abbreviations: @String{j-CACM = "Communications of the ACM"} @String{j-INFO-PROC-LETT = "Information Processing Letters"} @String{j-LINUX-J = "Linux Journal"} @String{j-LOPLAS = "ACM Letters on Programming Languages and Systems"} @String{j-SIGPLAN = "ACM SIG{\-}PLAN Notices"} @String{j-SPE = "Soft\-ware\emdash Prac\-tice and Experience"} @String{j-TOPLAS = "ACM Transactions on Programming Languages and Systems"} %%% ==================================================================== %%% Publisher abbreviations: @String{pub-ACM = "ACM Press"} @String{pub-ACM:adr = "New York, NY, USA"} @String{pub-BENCUM = "Benjamin/Cummings Pub. Co."} @String{pub-BENCUM:adr = "Redwood City, CA, USA"} %%% ==================================================================== %%% Bibliography entries: @Article{Hanson:1990:FAD, author = "David R. Hanson", title = "Fast Allocation and Deallocation of Memory Based on Object Lifetimes", journal = j-SPE, volume = "20", number = "1", pages = "5--12", month = jan, year = "1990", CODEN = "SPEXBL", DOI = "https://doi.org/10.1002/spe.4380200104", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Sat May 31 13:36:16 MDT 1997", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www.math.utah.edu/pub/tex/bib/spe.bib", URL = "http://drhanson.s3.amazonaws.com/storage/documents/fastalloc.pdf", acknowledgement = ack-nhfb, ajournal = "Softw. Pract. Exp.", fjournal = "Software --- Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", onlinedate = "30 Oct 2006", } @Article{Fraser:1991:CGI, author = "Christopher W. Fraser and David R. Hanson", title = "A Code Generation Interface for {ANSI C}", journal = j-SPE, volume = "21", number = "9", pages = "963--988", month = sep, year = "1991", CODEN = "SPEXBL", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Fri Feb 17 18:38:52 2006", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://storage.webhop.net/documents/interface.pdf", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", } @Article{Fraser:1991:RCA, author = "Christopher W. Fraser", title = "A retargetable compiler for {ANSI C}", journal = j-SIGPLAN, volume = "26", number = "10", pages = "29--43", month = oct, year = "1991", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Fri Feb 17 18:38:15 2006", bibsource = "http://portal.acm.org/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://storage.webhop.net/documents/overview.pdf", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", } @Article{Fraser:1992:ESE, author = "Christopher W. Fraser and David R. Hanson and Todd A. Proebsting", title = "Engineering a simple, efficient code-generator generator", journal = j-LOPLAS, volume = "1", number = "3", pages = "213--226", month = sep, year = "1992", CODEN = "ALPSE8", ISSN = "1057-4514 (print), 1557-7384 (electronic)", ISSN-L = "1057-4514", bibdate = "Fri Feb 17 18:41:11 2006", bibsource = "http://www.acm.org/pubs/toc/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://storage.webhop.net/documents/iburg.pdf; http://www.acm.org/pubs/toc/Abstracts/1057-4514/151642.html; http://www.cs.princeton.edu/software/iburg/", abstract = "Many code-generator generators use tree pattern matching and dynamic programming. This paper describes a simple program that generates matchers that are fast, compact, and easy to understand. It is simpler than common alternatives: 200-700 lines of Icon or 950 lines of C versus 3000 lines of C for Twig and 5000 for burg. Its matchers run up to 25 times faster than Twig's. They are necessarily slower than burg's BURS (bottom-up rewrite system) matchers, but they are more flexible and still practical.", acknowledgement = ack-nhfb, fjournal = "ACM Letters on Programming Languages and Systems", keywords = "languages", subject = "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Translator writing systems and compiler generators. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Code generation. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Compilers.", } @Article{Fraser:1992:SRS, author = "Christopher W. Fraser and David R. Hanson", title = "Simple Register Spilling in a Retargetable Compiler", journal = j-SPE, volume = "22", number = "1", pages = "85--99", month = jan, year = "1992", CODEN = "SPEXBL", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Fri Feb 17 18:39:19 2006", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://storage.webhop.net/documents/spills.pdf", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", } @Article{Proebsting:1992:PRA, author = "Todd A. Proebsting and Charles N. Fischer", title = "Probabilistic register allocation", journal = j-SIGPLAN, volume = "27", number = "7", pages = "300--310", month = jul, year = "1992", CODEN = "SINODQ", ISBN = "0-89791-475-9", ISBN-13 = "978-0-89791-475-8", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", LCCN = "QA76.7.S53 1992", bibdate = "Sun Dec 14 09:16:22 MST 2003", bibsource = "Compendex database; http://portal.acm.org/; http://www.acm.org/pubs/contents/proceedings/pldi/143095/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/pldi/143095/p300-proebsting/", abstract = "A new global register allocation technique, {\em probabilistic register allocation\/}, is described. Probabilistic register allocation quantifies the costs and benefits of allocating variables to registers over live ranges so that excellent allocation choices can be made. Local allocation is done first, and then global allocation is done iteratively beginning in the most deeply nested loops. Because local allocation precedes global allocation, probabilistic allocation does not interfere with the use of well-known, high-quality local register allocation and instruction scheduling techniques.", acknowledgement = ack-nhfb, affiliation = "Univ of Wisconsin-Madison", affiliationaddress = "WI, USA", annote = "Published as part of the Proceedings of PLDI'92.", classification = "723.1; 922.1", conference = "Proceedings of the ACM SIGPLAN '92 Conference on Programming Language Design and Implementation", conferenceyear = "1992", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", journalabr = "SIGPLAN Not", keywords = "algorithms; Computer systems programming; Graph coloring allocators; Instruction scheduling; performance; Probability; Register allocation", meetingaddress = "San Francisco, CA, USA", meetingdate = "Jun 17--19 1992", meetingdate2 = "06/17--19/92", remark = "The authors extend for the {\tt lcc}code generator for the MIPS R2000 with their new register allocator.", sponsor = "ACM", subject = "{\bf G.2.2} Mathematics of Computing, DISCRETE MATHEMATICS, Graph Theory. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Compilers. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Optimization.", } @Article{Ramsey:1992:RD, author = "Norman Ramsey and David R. Hanson", title = "A retargetable debugger", journal = j-SIGPLAN, volume = "27", number = "7", pages = "22--31", month = jul, year = "1992", CODEN = "SINODQ", ISBN = "0-89791-475-9", ISBN-13 = "978-0-89791-475-8", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", LCCN = "QA76.7.S53 1992", bibdate = "Fri Feb 17 18:40:31 2006", bibsource = "Compendex database; http://portal.acm.org/; http://www.acm.org/pubs/contents/proceedings/pldi/143095/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://storage.webhop.net/documents/retargetable.pdf; http://www.acm.org:80/pubs/citations/proceedings/pldi/143095/p22-ramsey/", abstract = "We are developing techniques for building retargetable debuggers. Our prototype, 1db, debugs C programs compiled for the MIPS R3000, Motorola 68020, SPARC, and VAX architectures. It can use a network to connect to faulty processes and can do cross-architecture debugging. 1db's total code size is about 16,000 lines, but it needs only 250-550 lines of machine-dependent code for each target. 1db owes its retargetability to three techniques: getting help from the compiler, using a machine-independent embedded interpreter, and choosing abstractions that minimize and isolate machine-dependent code. 1db reuses existing compiler function by having the compiler emit PostScript code that 1db later interprets; PostScript works well in this unusual context.", acknowledgement = ack-nhfb, affiliation = "Princeton Univ", affiliationaddress = "Princeton, NJ, USA", annote = "Published as part of the Proceedings of PLDI'92.", classification = "723.1", conference = "Proceedings of the ACM SIGPLAN '92 Conference on Programming Language Design and Implementation", conferenceyear = "1992", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", journalabr = "SIGPLAN Not", keywords = "Computer programming; design; languages; Post script code; Program debugging; Retargetable debugger", meetingaddress = "San Francisco, CA, USA", meetingdate = "Jun 17--19 1992", meetingdate2 = "06/17--19/92", sponsor = "ACM", subject = "{\bf D.2.5} Software, SOFTWARE ENGINEERING, Testing and Debugging, Debugging aids. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, C. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Compilers. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, PostScript.", } @Article{Ball:1993:BPF, author = "Thomas Ball and James R. Larus", title = "Branch prediction for free", journal = j-SIGPLAN, volume = "28", number = "6", pages = "300--313", month = jun, year = "1993", CODEN = "SINODQ", ISBN = "0-89791-598-4", ISBN-13 = "978-0-89791-598-4", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:16:37 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/pubs/contents/proceedings/pldi/155090/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/pldi/155090/p300-ball/", abstract = "Many compilers rely on branch prediction to improve program performance by identifying frequently executed regions and by aiding in scheduling instructions.{\em Profile-based\/} predictors require a time-consuming and inconvenient compile-profile-compile cycle in order to make predictions. We present a {\em program-based\/} branch predictor that performs well for a large and diverse set of programs written in C and Fortran. In addition to using natural loop analysis to predict branches that control the iteration of loops, we focus on heuristics for predicting non-loop branches, which dominate the dynamic branch count of many programs. The heuristics are simple and require little program analysis, yet they are effective in terms of coverage and miss rate. Although program-based prediction does not equal the accuracy of profile-based prediction, we believe it reaches a sufficiently high level to be useful. Additional type and semantic information available to a compiler would enhance our heuristics.", acknowledgement = ack-nhfb, affiliation = "Dept. of Comput. Sci., Wisconsin Univ., Madison, WI, USA", annote = "Published as part of the Proceedings of PLDI'93.", classification = "C6110 (Systems analysis and programming); C6120 (File organisation); C6150C (Compilers, interpreters and other processors)", confdate = "23-25 June 1993", conflocation = "Albuquerque, NM, USA", confsponsor = "ACM", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", keywords = "Branch prediction; C; Compile-profile-compile cycle; Dynamic branch count; Fortran; Frequently executed regions; Heuristics; languages; Miss rate; Natural loop analysis; Non-loop branches; performance; Program performance; Program-based branch predictor; Scheduling instructions; Semantic information", remark = "Compares performance with that of {\tt lcc}.", subject = "{\bf G.2.2} Mathematics of Computing, DISCRETE MATHEMATICS, Graph Theory. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, FORTRAN. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Optimization. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Compilers.", thesaurus = "Program compilers; Programming; Tree data structures", } @Article{Bumbulis:1993:RMV, author = "Peter Bumbulis and Donald D. Cowan", title = "{RE2C}: a more versatile scanner generator", journal = j-LOPLAS, volume = "2", number = "4", pages = "70--84", month = mar, year = "1993", CODEN = "ALPSE8", ISSN = "1057-4514 (print), 1557-7384 (electronic)", ISSN-L = "1057-4514", bibdate = "Thu May 30 15:54:54 MDT 1996", bibsource = "http://www.acm.org/pubs/toc/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org/pubs/toc/Abstracts/1057-4514/176487.html", abstract = "It is usually claimed that lexical analysis routines are still coded by hand, despite the widespread availability of scanner generators, for efficiency reasons. While efficiency is a consideration, there exist freely available scanner generators such as GLA [Gray 1988] that can generate scanners that are faster than most hand-coded ones. However, most generated scanners are tailored for a particular environment, and retargeting these scanners to other environments, if possible, is usually complex enough to make a hand-coded scanner more appealing. In this paper we describe RE2C, a scanner generator that not only generates scanners that are faster (and usually smaller) than those produced by any other scanner generator known to the authors, including GLA, but that also adapt easily to any environment.", acknowledgement = ack-nhfb, fjournal = "ACM Letters on Programming Languages and Systems", keywords = "algorithms, languages, performance", remark = "Compares scanner efficiency with that of {\tt lcc}.", subject = "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Parsing. {\bf D.3.2}: Software, PROGRAMMING LANGUAGES, Language Classifications, Specialized application languages.", } @Article{Engler:1994:DER, author = "Dawson R. Engler and Todd A. Proebsting", title = "{DCG}: an efficient, retargetable dynamic code generation system", journal = j-SIGPLAN, volume = "29", number = "11", pages = "263--272", month = nov, year = "1994", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:16:57 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/pubs/toc/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/asplos/195473/p263-engler/", abstract = "Dynamic code generation allows aggressive optimization through the use of runtime information. Previous systems typically relied on ad hoc code generators that were not designed for retargetability, and did not shield the client from machine-specific details. We present a system, {\em dcg\/}, that allows clients to specify dynamically generated code in a machine-independent manner. Our one-pass code generator is easily retargeted and extremely efficient (code generation costs approximately 350 instructions per generated instruction). Experiments show that dynamic code generation increases some application speeds by over an order of magnitude.", acknowledgement = ack-nhfb, classification = "C6115 (Programming support); C6150C (Compilers, interpreters and other processors)", conflocation = "San Jose, CA, USA; 4-7 Oct. 1994", conftitle = "Sixth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS-VI)", corpsource = "Lab. for Comput. Sci., MIT, Cambridge, MA, USA", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", keywords = "aggressive optimization; application generators; automatic programming; DCG; design; dynamically generated code; experimentation; languages; machine-independent; measurement; one-pass code generator; optimising compilers; performance; retargetable dynamic code generation system; runtime information; theory", sponsororg = "ACM; IEEE Comput. Soc", subject = "{\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Code generation.", treatment = "P Practical", } @Article{Fernandez:1995:SEL, author = "Mary F. Fern{\'a}ndez", title = "Simple and effective link-time optimization of {Modula-3} programs", journal = j-SIGPLAN, volume = "30", number = "6", pages = "103--115", month = jun, year = "1995", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:17:06 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/pubs/contents/proceedings/pldi/207110/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/pldi/207110/p103-fernandez/", abstract = "Modula-3 supports development of modular programs by separating an object's interface from its implementation. This separation induces a runtime overhead in the implementation of objects, because it prevents the compiler from having complete information about a program's type hierarchy. This overhead can be reduced at link time, when the entire type hierarchy becomes available. We describe opportunities for link-time optimization of Modula-3, present two link-time optimizations that reduce the runtime costs of Modula-3's opaque types and methods, and show how link-time optimization could provide C++ with the benefits of opaque types at no additional runtime cost. Our optimization techniques are implemented in mld, a retargetable linker for the MIPS, SPARC, and Intel 486. mld links a machine-independent intermediate code that is suitable for link-time optimization and code generation. Linking intermediate code simplifies implementation of the optimizations and makes it possible to evaluate them on a wide range of architectures. mld's optimizations are effective: they reduce the total number of instructions executed by up to 14\% and convert as many as 79\% of indirect calls to direct calls.", acknowledgement = ack-nhfb, affiliation = "Dept. of Comput. Sci., Princeton Univ., NJ, USA", annote = "Published as part of the Proceedings of PLDI'95.", classification = "C6110B (Software engineering techniques); C6110J (Object-oriented programming); C6115 (Programming support); C6120 (File organisation); C6140D (High level languages); C6150C (Compilers, interpreters and other processors)", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", keywords = "algorithms; Architectures; C++; Code generation; Compiler; Direct calls; Executed instructions; Indirect calls; Intel 486; Intermediate code linking; languages; Link-time optimization; Machine-independent intermediate code; measurement; MIPS; Mld retargetable linker; Modula-3 programs; Modular programs; Object interface; Opaque types; performance; Program type hierarchy; Runtime costs; Runtime overhead; SPARC", remark = "{\tt mlcc}, a compiler for Modula-3, is based on {\tt lcc}.", subject = "{\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, Modula-3. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Optimization. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, C++. {\bf D.2.2} Software, SOFTWARE ENGINEERING, Design Tools and Techniques, Modules and interfaces.", thesaurus = "Abstract data types; Modula; Object-oriented languages; Object-oriented programming; Optimisation; Optimising compilers; Software libraries; Software reusability", } @Misc{Fraser:1995:MRC, author = "C. W. Fraser and D. R. Hanson", title = "A Minimalist's Retargetable {C} Compiler", howpublished = "World Wide Web document", day = "28", month = apr, year = "1995", bibdate = "Fri Feb 17 18:25:37 2006", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", note = "Talk at the University of Delaware.", URL = "http://www.cs.princeton.edu/software/lcc/doc/lcc.pdf", acknowledgement = ack-nhfb, } @Book{Fraser:1995:RCC, author = "Chris W. Fraser and David R. Hanson", title = "A Retargetable {C} Compiler: Design and Implementation", publisher = pub-BENCUM, address = pub-BENCUM:adr, pages = "xv + 564", year = "1995", ISBN = "0-8053-1670-1", ISBN-13 = "978-0-8053-1670-4", LCCN = "QA76.73.C15F75 1995", bibdate = "Wed Feb 08 10:55:34 1995", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www.math.utah.edu/pub/tex/bib/litprog.bib; http://www.math.utah.edu/pub/tex/bib/master.bib; http://www.math.utah.edu/pub/tex/bib/texbook2.bib", note = "From the authors' announcement: ``\ldots this book is an example of a `literate program.' Like {\em {\TeX}: The Program\/} by D. E. Knuth (Addison-Wesley, 1986), this book is lcc's source code and the prose that describes it. The code is presented in the order that best suits understanding, not in the order dictated by the C programming language. The source code that appears on the diskette is extracted automatically from the book's text files. \ldots{} The distribution is available via `anonymous' ftp from \path=ftp.cs.princeton.edu= \path=(128.112.152.13)= in the directory \path=pub/lcc=. \ldots{} Additional information about lcc and about our book is available on the WWW at URL \path=http://www.cs.princeton.edu/software/lcc=.''", price = "US\$55.95", URL = "https://www.pearson.com/us/higher-education/program/Hanson-Retargetable-C-Compiler-A-Design-and-Implementation/PGM166351.html", abstract = "This new text examines the design and implementation of lcc, a production-quality, retargetable compiler, designed at AT\&T Bell Laboratories and Princeton University for the ANSI C programming language. The authors' innovative approach --- a ``literate program'' that intermingles the text with the source code --- gives a detailed tour of the code that explains the implementation and design decisions reflected in the software. And while most books describe toy compilers or focus on isolated pieces of code, the authors have made available the entire source code for a real compiler. Structured as a self-study guide that describes the real-world tradeoffs encountered in building a production-quality compiler, A Retargetable C Compiler is also useful to individuals who work in application areas using or creating language-based tools and techniques. Features: discusses the implementation and design tradeoffs made while constructing a real ANSI C compiler, illustrating the interaction between theory and practice; covers compiler theory only as needed to understand the implementation of lcc, focusing instead on practical, applied issues; encourages a deeper understanding of programming in C, by providing C programmers with a tour of the language from the perspective of compiler authors; includes coverage of code generators for the MIPS R3000, SPARC, and Intel 386 and its successors; and provides access to the full source code for the lcc compiler, the three back ends, and the code-generator generator, either on disk or via FTP.", acknowledgement = ack-nhfb, tableofcontents = "1. Introduction: Literate Programs \\ How to Read This Book \\ Overview \\ Design \\ Common Declarations \\ Syntax Specifications \\ Errors \\ 2. Storage Management: Memory Management Interface \\ Arena Representation \\ Allocating Space \\ Deallocating Space \\ Strings \\ 3. Types: Representing Symbols \\ Representing Symbol Tables \\ Changing Scope \\ Finding and Installing Identifiers \\ Labels \\ Constants \\ Generated Variables \\ 4. Code Generation Interface: Representing Types \\ Type Management \\ Type Predicates \\ Type Constructors \\ Function Types \\ Structure and Enumeration Types \\ Type-Checking Functions \\ Type Mapping \\ 5. Lexical Analysis: Type Metrics \\ Interface Records \\ Symbols \\ Types \\ Dag Operators \\ Interface Flags \\ Initialization \\ Definitions \\ Constants \\ Functions \\ Interface Binding \\ Upcalls \\ 6. Parsing: Input \\ Recognizing Tokens \\ Recognizing Keywords \\ Recognizing Identifiers \\ Recognizing Numbers \\ Recognizing Character Constants and Strings \\ 7. Expressions \\ Languages and Grammars \\ Ambiguity and Parse Trees \\ Top-Down Parsing \\ FIRST and FOLLOW Sets \\ Writing Parsing Functions \\ Handling Syntax Errors \\ 8. Expressions: Representing Expressions \\ Parsing Expressions \\ Parsing C Expressions \\ Assignment Expressions \\ Conditional Expressions \\ Binary Expressions \\ Unary and Postfix Expressions \\ Primary Expressions \\ 9. Expression Semantics: Conversions \\ Unary and Postfix Operators \\ Function Calls \\ Binary Operators \\ Assignments \\ Conditionals \\ Constant Folding \\ 10. Statements: Representing Code \\ Execution Points \\ Recognizing Statements \\ If Statements \\ Labels and Gotos \\ Loops \\ Switch Statements \\ Return Statements \\ Managing Labels and Jumps \\ 11. Declarations: Translation Units \\ Declarations \\ Declarators \\ Function Declarators \\ Structure Specifiers \\ Function Definitions \\ Compound Statements \\ Finalization \\ The Main Program \\ 12. Generating Immediate Code: Eliminating Common Subexpressions \\ Building Nodes \\ Flow of Control \\ Assignments \\ Function Calls \\ Enforcing Evaluation Order \\ Driving Code Generation \\ Eliminating Multiply Referenced Nodes \\ 13. Structuring the Code Generator: Organization of the Code Generator \\ Interface Extensions \\ Upcalls \\ Node Extensions \\ Symbol Extensions \\ Frame Layout \\ Generating Code to Copy Blocks \\ Initialization \\ 14. Selecting and Emitting instructions: Specifications \\ Labelling the Tree \\ Reducing the Tree \\ Cost Functions \\ Debugging \\ The Emitter \\ Register Targeting \\ Coordinating Instruction Selection \\ Shared Rules \\ Writing Specifications \\ 15. Register Allocation: Organization \\ Tracking the Register State \\ Allocating Registers \\ Spilling \\ 16. Generating MIPS R3000 Code: Registers \\ Selecting Instructions \\ Implementing Functions \\ Defining Data \\ Segments \\ Copying Blocks \\ 17. Generating SPARC Code: Registers \\ Selecting Instructions \\ Implementing Functions \\ Defining Data \\ Copying Blocks, 18. Generating X86 Code: Registers \\ Selecting Instructions \\ Implementing Functions \\ Defining Data \\ 19. Retrospective: Data Structures \\ Interface \\ Syntactic and Semantic Analyses \\ Code Generation and Optimization \\ Testing and Validation", } @Article{Proebsting:1995:BAG, author = "Todd A. Proebsting", title = "{BURS} Automata Generation", journal = j-TOPLAS, volume = "17", number = "3", pages = "461--486", month = may, year = "1995", CODEN = "ATPSDT", ISSN = "0164-0925 (print), 1558-4593 (electronic)", ISSN-L = "0164-0925", bibdate = "Fri Jan 5 07:58:42 MST 1996", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org/pubs/toc/Abstracts/0164-0925/203098.html", abstract = "A simple and efficient algorithm for generating bottom-up rewrite system (BURS) tables is described. A small code-generator generator implementation produces BURS tables efficiently, even for complex instruction set descriptions. The algorithm does not require novel data structures or complicated algorithmic techniques. Previously published methods for on-the-fly elimination of states are generalized and simplified to create a new method, triangle trimming, that is employed in the algorithm. A prototype implementation, burg, generates BURS tables very efficiently.", acknowledgement = ack-nhfb, fjournal = "ACM Transactions on Programming Languages and Systems", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J783", keywords = "algorithms; languages", subject = "{\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Translator writing systems and compiler generators. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Code generation. {\bf D.3.4}: Software, PROGRAMMING LANGUAGES, Processors, Compilers.", } @InProceedings{Proebsting:1995:OAC, author = "Todd A. Proebsting", title = "Optimizing an {ANSI C} interpreter with superoperators", crossref = "ACM:1995:CRP", pages = "322--332", year = "1995", bibdate = "Mon May 3 12:52:30 MDT 1999", bibsource = "http://www.acm.org/pubs/toc/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/plan/199448/p322-proebsting/", abstract = "This paper introduces {\em superoperators\/}, an optimization technique for bytecoded interpreters. Superoperators are virtual machine operations automatically synthesized from smaller operations to avoid costly per-operation overheads. Superoperators decrease executable size and can double or triple the speed of interpreted programs. The paper describes a simple and effective heuristic for inferring powerful superoperators from the usage patterns of simple operators. The paper describes the design and implementation of a hybrid translator/interpreter that employs superoperators. From a specification of the superoperators (either automatically inferred or manually chosen), the system builds an efficient implementation of the virtual machine in assembly language. The system is easily retargetable and currently runs on the MIPS R3000 and the SPARC.", acknowledgement = ack-nhfb, keywords = "algorithms; design; experimentation; languages", remark = "{\tt hti} uses {\tt lcc}'s front end to translate ANSI C programs into its intermediate representation (IR).", subject = "{\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Interpreters. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Optimization. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Translator writing systems and compiler generators. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, C.", } @Article{Erlingsson:1996:EMR, author = "{\'U}lfar Erlingsson and Mukkai Krishnamoorthy and T. V. Raman", title = "Efficient multiway radix search trees", journal = j-INFO-PROC-LETT, volume = "60", number = "3", pages = "115--120", day = "11", month = nov, year = "1996", CODEN = "IFPLAT", ISSN = "0020-0190 (print), 1872-6119 (electronic)", ISSN-L = "0020-0190", MRclass = "68N20 (68P05)", MRnumber = "1 423 917", bibdate = "Fri Feb 17 18:47:15 2006", bibsource = "http://www.elsevier.com:80/inca/publications/store/5/0/5/6/1/2/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "ftp://ftp.cs.princeton.edu/pub/packages/lcc/contrib/mrst.shar; http://www.cs.princeton.edu/software/lcc/doc/mrst.pdf", acknowledgement = ack-nhfb, classification = "C1160 (Combinatorial mathematics); C6120 (File organisation)", corpsource = "Rensselaer Polytech. Inst., Troy, NY, USA", fjournal = "Information Processing Letters", journal-URL = "http://www.sciencedirect.com/science/journal/00200190", keywords = "code generation; file organisation; imperative languages; multiway radix search trees; set theory; sparse case sets; static search trees; switch statements; timing; tree searching", treatment = "P Practical; T Theoretical or Mathematical", } @Article{Fraser:1996:CCF, author = "Christopher W. Fraser and David R. Hanson", title = "Compile {C} Faster on {Linux}", journal = j-LINUX-J, volume = "25", pages = "32--33", month = may, year = "1996", CODEN = "LIJOFX", ISSN = "1075-3583 (print), 1938-3827 (electronic)", ISSN-L = "1075-3583", bibdate = "Fri Feb 17 18:34:29 2006", bibsource = "ftp://ftp.math.utah.edu/pub/tex/bib/linux-journal.bib; http://noframes.linuxjournal.com/lj-issues/issue25/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.cs.princeton.edu/software/lcc/doc/linux.html", abstract = "An introduction to lcc, a compiler 75\% smaller than gcc that also compiles more quickly and helps prevent some porting bugs.", acknowledgement = ack-nhfb, fjournal = "Linux Journal", journal-URL = "http://portal.acm.org/citation.cfm?id=J508", } @Misc{Fraser:1996:LRC, author = "C. W. Fraser and D. R. Hanson", title = "A Lean Retargetable {C} Compiler", howpublished = "World Wide Web document", day = "4", month = apr, year = "1996", bibdate = "Fri Feb 17 18:27:39 2006", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", note = "Talk at New York University", URL = "http://www.cs.princeton.edu/software/lcc/doc/lean.pdf", acknowledgement = ack-nhfb, } @Article{Hanson:1996:MID, author = "David R. Hanson and Mukund Raghavachari", title = "A Machine-Independent Debugger", journal = j-SPE, volume = "26", number = "11", pages = "1277--1299", month = nov, year = "1996", CODEN = "SPEXBL", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Thu Jul 29 15:11:07 MDT 1999", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www3.interscience.wiley.com/journalfinder.html", URL = "http://storage.webhop.net/documents/cdb.pdf; http://storage.webhop.net/documents/cdbtalk.pdf; http://www.cs.princeton.edu/software/lcc/cdb; http://www3.interscience.wiley.com/cgi-bin/abstract?ID=16773", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", } @Article{Poletto:1997:TSF, author = "Massimiliano Poletto and Dawson R. Engler and M. Frans Kaashoek", title = "{\tt tcc}: {A} System for Fast, Flexible, and High-level Dynamic Code Generation", journal = j-SIGPLAN, volume = "32", number = "5", pages = "109--121", month = may, year = "1997", CODEN = "SINODQ", ISBN = "0-89791-907-6", ISBN-13 = "978-0-89791-907-4", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:17:32 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/pubs/contents/proceedings/pldi/258915/index.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org:80/pubs/citations/proceedings/pldi/258915/p109-poletto/", acknowledgement = ack-nhfb, annote = "Published as part of the Proceedings of PLDI'97.", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", keywords = "design; experimentation; languages; measurement; performance; standardization; theory", subject = "{\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Code generation. {\bf D.3.4} Software, PROGRAMMING LANGUAGES, Processors, Compilers. {\bf D.3.2} Software, PROGRAMMING LANGUAGES, Language Classifications, C. {\bf K.6.2} Computing Milieux, MANAGEMENT OF COMPUTING AND INFORMATION SYSTEMS, Installation Management, Benchmarks.", } @Misc{Hanson:1998:EEA, author = "D. R. Hanson", title = "Early Experience with {ASDL} in {{\tt lcc}}", howpublished = "World Wide Web document", day = "19", month = jun, year = "1998", bibdate = "Fri Feb 17 18:27:39 2006", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", note = "National Compiler Infrastructure Tutorial, SIGPLAN'98 Conference on Programming Language Design and Implementation, Montr{\'e}al, Qu{\'e}bec, Canada.", URL = "http://www.cs.princeton.edu/software/lcc/doc/nci@pldi98.pdf", acknowledgement = ack-nhfb, } @Article{Hanson:1999:EEA, author = "David R. Hanson", title = "Early experience with {ASDL} in {\tt lcc}", journal = j-SPE, volume = "29", number = "5", pages = "417--435", day = "25", month = apr, year = "1999", CODEN = "SPEXBL", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Fri Feb 17 18:37:07 2006", bibsource = "ftp://ftp.math.utah.edu/pub/tex/bib/spe.bib; http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www3.interscience.wiley.com/journalfinder.html", URL = "http://storage.webhop.net/documents/asdl.pdf; http://www.cs.princeton.edu/software/lcc/asdl.html; http://www3.interscience.wiley.com/cgi-bin/abstract?ID=55003854; http://www3.interscience.wiley.com/cgi-bin/fulltext?ID=55003854&PLACEBO=IE.pdf", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", } @Article{Hanson:1999:MID, author = "David R. Hanson", title = "A machine-independent debugger --- revisited", journal = j-SPE, volume = "29", number = "10", pages = "849--862", month = aug, year = "1999", CODEN = "SPEXBL", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Tue Aug 31 11:31:54 MDT 1999", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www3.interscience.wiley.com/journalfinder.html", URL = "http://www3.interscience.wiley.com/cgi-bin/abstract?ID=63001366; http://www3.interscience.wiley.com/cgi-bin/fulltext?ID=63001366&PLACEBO=IE.pdf", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", } @Article{Poletto:1999:CTL, author = "Massimiliano Poletto and Wilson C. Hsieh and Dawson R. Engler and M. Frans Kaashoek", title = "{'C} and tcc: a language and compiler for dynamic code generation", journal = j-TOPLAS, volume = "21", number = "2", pages = "324--369", month = mar, year = "1999", CODEN = "ATPSDT", ISSN = "0164-0925 (print), 1558-4593 (electronic)", ISSN-L = "0164-0925", bibdate = "Tue Sep 26 10:12:58 MDT 2000", bibsource = "http://www.acm.org/pubs/contents/journals/toplas/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", URL = "http://www.acm.org/pubs/citations/journals/toplas/1999-21-2/p324-poletto/", abstract = "Dynamic code generation allows programmers to use run-time information in order to achieve performance and expressiveness superior to those of static code. The 'C({\em Tick C\/}) language is a superset of ANSI C that supports efficient and high-level use of dynamic code generation. 'C provides dynamic code generation at the level of C expressions and statements and supports the composition of dynamic code at run time. These features enable programmers to add dynamic code generation to existing C code incrementally and to write important applications (such as ``just-in-time'' compilers) easily. The article presents many examples of how 'C can be used to solve practical problems. The tcc compiler is an efficient, portable, and freely available implementation of 'C. tcc allows programmers to trade dynamic compilation speed for dynamic code quality: in some applications, it is most important to generate code quickly, while in others code quality matters more than compilation speed. The overhead of dynamic compilation is on the order of 100 to 600 cycles per generated instruction, depending on the level of dynamic optimization. Measurements show that the use of dynamic code generation can improve performance by almost an order of magnitude; two- to four-fold speedups are common. In most cases, the overhead of dynamic compilation is recovered in under 100 uses of the dynamic code; sometimes it can be recovered within one use.", acknowledgement = ack-nhfb, fjournal = "ACM Transactions on Programming Languages and Systems", generalterms = "Algorithms; Languages; Performance", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J783", keywords = "ANSI C; compilers; dynamic code generation; dynamic code optimization", remark = "The {\tt tcc} compiler is based on {\tt lcc}.", subject = "Software --- Programming Languages --- Language Classifications (D.3.2): {\bf Specialized application languages}; Software --- Programming Languages --- Language Classifications (D.3.2); Software --- Programming Languages --- Language Constructs and Features (D.3.3); Software --- Programming Languages --- Processors (D.3.4): {\bf Code generation}; Software --- Programming Languages --- Processors (D.3.4); Software --- Programming Languages --- Processors (D.3.4): {\bf Compilers}; Software --- Programming Languages --- Processors (D.3.4): {\bf Run-time environments}", } @Article{Evans:2001:BCP, author = "William S. Evans and Christopher W. Fraser", title = "Bytecode Compression via Profiled Grammar Rewriting", journal = j-SIGPLAN, volume = "36", number = "5", pages = "148--155", month = may, year = "2001", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:18:26 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/sigplan/pldi/pldi2001/pldi_program.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", } @InProceedings{Fischer:2001:SDT, author = "Dirk Fischer and J{\"u}rgen Teich and Ralph Weper and Uwe Kastens and Michael Thies", booktitle = "Proceedings of the 2001 international conference on Compilers, architecture, and synthesis for embedded systems", title = "Synthesis and Design Tools: Design space characterization for architecture\slash compiler co-exploration", publisher = pub-ACM, address = pub-ACM:adr, pages = "108--115", year = "2001", ISBN = "1-58113-399-5", ISBN-13 = "978-1-58113-399-8", LCCN = "", bibdate = "Mon Apr 18 15:24:55 2005", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, remark = "The compiler described in this article is based on the {\tt lcc} frontend.", } @Article{Gay:2001:LSR, author = "David Gay and Alex Aiken", title = "Language Support for Regions", journal = j-SIGPLAN, volume = "36", number = "5", pages = "70--80", month = may, year = "2001", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:18:26 MST 2003", bibsource = "http://portal.acm.org/; http://www.acm.org/sigplan/pldi/pldi2001/pldi_program.html; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", remark = "Compares performance with {\tt lcc}.", } @InProceedings{Jung:2001:COV, author = "Sungjoon Jung and Yunheung Paek", booktitle = "CASES 01, November 16--17, 2001, Atlanta, Georgia, USA: Proceedings of the 2001 international conference on Compilers, architecture, and synthesis for embedded systems", title = "Compilers and Optimization: The very portable optimizer for digital signal processors", publisher = pub-ACM, address = pub-ACM:adr, pages = "84--92", month = nov, year = "2001", ISBN = "1-58113-399-5", ISBN-13 = "978-1-58113-399-8", LCCN = "", bibdate = "Tue Apr 19 08:27:56 2005", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, remark = "The authors extend {\tt lcc} for the TMS320C5402 processor.", } @Article{Park:2001:RAB, author = "Jinpyo Park and Je-Hyung Lee and Soo-Mook Moon", title = "Register Allocation for Banked Register File", journal = j-SIGPLAN, volume = "36", number = "8", pages = "39--47", month = aug, year = "2001", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Sun Dec 14 09:18:29 MST 2003", bibsource = "http://portal.acm.org/; http://redwood.snu.ac.kr/lctes2001/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, annote = "LCTES'01: The Workshop on Languages, Compilers and Tools for Embedded Systems", fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", remark = "Describes a compiler for the CalmRISC8 processor based on {\tt lcc}.", } @InProceedings{Sarkar:2001:RSS, author = "Vivek Sarkar and Mauricio J. Serrano and Barbara B. Simons", booktitle = "ICS'01 Sorrento, Italy: Proceedings of the 15th international conference on Supercomputing", title = "Register-sensitive selection, duplication, and sequencing of instructions", publisher = pub-ACM, address = pub-ACM:adr, pages = "277--288", year = "2001", ISBN = "1-58113-410-x", ISBN-13 = "978-1-58113-410-0", LCCN = "", bibdate = "Tue Apr 19 08:31:46 2005", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, remark = "The authors build a new back-end optimizer for Intel IA-32 based on {\tt lcc}.", } @Article{Zhang:2001:SGI, author = "Yukong Zhang and Young-Jun Kwon and Hyuk Jae Lee", title = "A systematic generation of initial register-reuse chains for dependence minimization", journal = j-SIGPLAN, volume = "36", number = "2", pages = "47--54", month = feb, year = "2001", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Thu May 15 16:24:55 MDT 2003", bibsource = "http://portal.acm.org/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", remark = "The authors extend {\tt lcc} for the ARM7T processor.", } @Article{Kessler:2002:OIC, author = "Christoph Kessler and Andrzej Bednarski", title = "Optimal integrated code generation for clustered {VLIW} architectures", journal = j-SIGPLAN, volume = "37", number = "7", pages = "102--111", month = jul, year = "2002", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Thu May 15 12:23:05 MDT 2003", bibsource = "http://portal.acm.org/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", remark = "The authors use {\tt lcc} as a front end.", } @Article{Ding:2003:CDR, author = "Chen Ding and Yutao Zhong", title = "Compiler-directed run-time monitoring of program data access", journal = j-SIGPLAN, volume = "38", number = "2s", pages = "1--12", month = feb, year = "2003", CODEN = "SINODQ", ISSN = "0362-1340 (print), 1523-2867 (print), 1558-1160 (electronic)", ISSN-L = "0362-1340", bibdate = "Thu May 15 12:23:14 MDT 2003", bibsource = "http://portal.acm.org/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "ACM SIGPLAN Notices", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J706", remark = "The compiler described in this article is based on the {\tt lcc} frontend.", } @Article{Evans:2003:GBC, author = "William S. Evans and Christopher W. Fraser", title = "Grammar-based compression of interpreted code", journal = j-CACM, volume = "46", number = "8", pages = "61--66", month = aug, year = "2003", CODEN = "CACMA2", ISSN = "0001-0782 (print), 1557-7317 (electronic)", ISSN-L = "0001-0782", bibdate = "Wed Sep 3 17:06:38 MDT 2003", bibsource = "http://www.acm.org/pubs/contents/journals/cacm/; http://www.math.utah.edu/pub/tex/bib/lcc.bib", acknowledgement = ack-nhfb, fjournal = "Communications of the ACM", journal-URL = "http://portal.acm.org/browse_dl.cfm?idx=J79", } @Article{Hanson:2004:LNT, author = "David R. Hanson", title = "{lcc.NET}: targeting the {.NET Common Intermediate Language} from {Standard C}", journal = j-SPE, volume = "34", number = "3", pages = "265--286", month = mar, year = "2004", CODEN = "SPEXBL", DOI = "https://doi.org/10.1002/spe.563", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Sat Apr 16 07:26:27 MDT 2005", bibsource = "ftp://ftp.math.utah.edu/pub/tex/bib/spe.bib; http://www.interscience.wiley.com/jpages/0038-0644; http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www3.interscience.wiley.com/journalfinder.html", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", onlinedate = "5 Jan 2004", } @Article{Hanson:2004:RCC, author = "David R. Hanson and Todd A. Proebsting", title = "A research {C\#} compiler", journal = j-SPE, volume = "34", number = "13", pages = "1211--1224", day = "10", month = nov, year = "2004", CODEN = "SPEXBL", DOI = "https://doi.org/10.1002/spe.610", ISSN = "0038-0644 (print), 1097-024X (electronic)", ISSN-L = "0038-0644", bibdate = "Sat Apr 16 07:26:34 MDT 2005", bibsource = "http://www.interscience.wiley.com/jpages/0038-0644; http://www.math.utah.edu/pub/tex/bib/lcc.bib; http://www3.interscience.wiley.com/journalfinder.html", URL = "ftp://ftp.research.microsoft.com/pub/tr/tr-2003-32.pdf; http://research.microsoft.com/research/pubs/view.aspx?msr_tr_id=MSR-TR-2003-32", acknowledgement = ack-nhfb, fjournal = "Software---Practice and Experience", journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X", onlinedate = "12 Jul 2004", } %%% ==================================================================== %%% Cross-referenced entries must come last: @Proceedings{ACM:1995:CRP, editor = "{ACM}", booktitle = "Conference record of {POPL} '95, 22nd {ACM} {SIGPLAN-SIGACT} Symposium on Principles of Programming Languages: papers presented at the Symposium: San Francisco, California, January 22--25, 1995", title = "Conference record of {POPL} '95, 22nd {ACM} {SIGPLAN-SIGACT} Symposium on Principles of Programming Languages: papers presented at the Symposium: San Francisco, California, January 22--25, 1995", publisher = pub-ACM, address = pub-ACM:adr, pages = "vii + 408", year = "1995", ISBN = "0-89791-692-1", ISBN-13 = "978-0-89791-692-9", LCCN = "QA 76.7 A11 1995", bibdate = "Mon May 3 17:47:49 MDT 1999", bibsource = "http://www.math.utah.edu/pub/tex/bib/lcc.bib", note = "ACM order number: 549950.", URL = "http://www.acm.org/pubs/contents/proceedings/plan/199448/index.html", acknowledgement = ack-nhfb, alttitle = "Proceedings, 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages POPL '95", annote = "Sponsored by the Association for Computing Machinery, Special Interest Group on Algorithms and Computation Theory (SIGACT), Special Interest Group on Programming Languages (SIGPLAN).", keywords = "Programming languages (Electronic computers) --- Congresses.", }