%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.12",
%%%     date            = "18 March 2014",
%%%     time            = "08:08:20 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        = "33726 1276 5662 59626",
%%%     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.12, the year coverage looked
%%%                        like this:
%%%
%%%                             1991 (   2)    1996 (   4)    2001 (   7)
%%%                             1992 (   4)    1997 (   1)    2002 (   1)
%%%                             1993 (   2)    1998 (   1)    2003 (   2)
%%%                             1994 (   1)    1999 (   3)    2004 (   2)
%%%                             1995 (   6)    2000 (   0)
%%%
%%%                             Article:         27
%%%                             Book:             1
%%%                             InProceedings:    4
%%%                             Misc:             3
%%%                             Proceedings:      1
%%%
%%%                             Total entries:   36
%%%
%%%                        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{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 =    "ftp://ftp.math.utah.edu/pub/tex/bib/litprog.bib;
                 http://www.math.utah.edu/pub/tex/bib/lcc.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",
  acknowledgement = ack-nhfb,
}

@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/ HREF="mailto:nci@pldi98.pdf">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 =          "http://dx.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 =          "http://dx.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.",
}