Finite-state code generation

Christopher W. Fraser, Todd A Proebsting

Research output: Chapter in Book/Report/Conference proceedingChapter

7 Citations (Scopus)

Abstract

This paper describes GBURG, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses). A stack-based virtual machine - known as the Lean Virtual Machine (LVM) - tuned for fast code generation is also described. GBURG translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/sec on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based.

Original languageEnglish (US)
Title of host publicationProceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)
PublisherACM
Pages270-280
Number of pages11
StatePublished - 1999
Externally publishedYes
EventProceedings of the Annual ACM SIGPLAN '99 Conference on Programming Language Design and Implementation (PLDI), FCRC'99 - Atlanta, GA, USA
Duration: May 1 1999May 4 1999

Other

OtherProceedings of the Annual ACM SIGPLAN '99 Conference on Programming Language Design and Implementation (PLDI), FCRC'99
CityAtlanta, GA, USA
Period5/1/995/4/99

Fingerprint

Pattern matching
Finite automata
Specifications
Code generation
Virtual machine

ASJC Scopus subject areas

  • Computer Science(all)

Cite this

Fraser, C. W., & Proebsting, T. A. (1999). Finite-state code generation. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI) (pp. 270-280). ACM.

Finite-state code generation. / Fraser, Christopher W.; Proebsting, Todd A.

Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, 1999. p. 270-280.

Research output: Chapter in Book/Report/Conference proceedingChapter

Fraser, CW & Proebsting, TA 1999, Finite-state code generation. in Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, pp. 270-280, Proceedings of the Annual ACM SIGPLAN '99 Conference on Programming Language Design and Implementation (PLDI), FCRC'99, Atlanta, GA, USA, 5/1/99.
Fraser CW, Proebsting TA. Finite-state code generation. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM. 1999. p. 270-280
Fraser, Christopher W. ; Proebsting, Todd A. / Finite-state code generation. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, 1999. pp. 270-280
@inbook{e25ef401729742d994b4ef3f0a4d0627,
title = "Finite-state code generation",
abstract = "This paper describes GBURG, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses). A stack-based virtual machine - known as the Lean Virtual Machine (LVM) - tuned for fast code generation is also described. GBURG translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/sec on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based.",
author = "Fraser, {Christopher W.} and Proebsting, {Todd A}",
year = "1999",
language = "English (US)",
pages = "270--280",
booktitle = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",
publisher = "ACM",

}

TY - CHAP

T1 - Finite-state code generation

AU - Fraser, Christopher W.

AU - Proebsting, Todd A

PY - 1999

Y1 - 1999

N2 - This paper describes GBURG, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses). A stack-based virtual machine - known as the Lean Virtual Machine (LVM) - tuned for fast code generation is also described. GBURG translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/sec on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based.

AB - This paper describes GBURG, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses). A stack-based virtual machine - known as the Lean Virtual Machine (LVM) - tuned for fast code generation is also described. GBURG translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/sec on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based.

UR - http://www.scopus.com/inward/record.url?scp=0032674049&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0032674049&partnerID=8YFLogxK

M3 - Chapter

AN - SCOPUS:0032674049

SP - 270

EP - 280

BT - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

PB - ACM

ER -