Reverse interpretation+mutation analysis = automatic retargeting

Research output: Chapter in Book/Report/Conference proceedingConference contribution

9 Citations (Scopus)

Abstract

There are three popular methods for constructing highly retargetable compilers: (1) the compiler emits abstract machine code which is interpreted at run-time, (2) the compiler emits C code which is subsequently compiled to machine code by the native C compiler, or (3) the compiler's code-generator is generated by a back-end generator from a formal machine description produced by the compiler writer. These methods incur high costs at run-time, compile-time, or compiler-construction time, respectively. In this paper we will describe a novel method which promises to significantly reduce the effort required to retarget a compiler to a new architecture, while at the same time producing fast and effective compilers. The basic idea is to use the native C compiler at compiler construction time to discover architectural features of the new architecture. From this information a formal machine description is produced. Given this machine description, a native code-generator can be generated by a back-end generator such as BEG or burg. A prototype Automatic Architecture Discovery Unit has been implemented. The current version is general enough to produce machine descriptions for the integer instruction sets of common RISC and CISC architectures such as the Sun SPARC, Digital Alpha, MIPS, DEC VAX, and Intel x86. The tool is completely automatic and requires minimal input from the user: principally, the user needs to provide the internet address of the target machine and the command-lines by which the C compiler, assembler, and linker are invoked.

Original languageEnglish (US)
Title of host publicationProceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)
Editors Anon
PublisherACM
Pages57-70
Number of pages14
StatePublished - 1997
Externally publishedYes
EventProceedings of the 1997 ACM SIGPLAM Conference on Programming Language Design and Implementation, PLDI - Las Vegas, NV, USA
Duration: Jun 15 1997Jun 18 1997

Other

OtherProceedings of the 1997 ACM SIGPLAM Conference on Programming Language Design and Implementation, PLDI
CityLas Vegas, NV, USA
Period6/15/976/18/97

Fingerprint

Reduced instruction set computing
Sun
Internet
Costs

ASJC Scopus subject areas

  • Computer Science(all)

Cite this

Collberg, C. S. (1997). Reverse interpretation+mutation analysis = automatic retargeting. In Anon (Ed.), Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI) (pp. 57-70). ACM.

Reverse interpretation+mutation analysis = automatic retargeting. / Collberg, Christian S.

Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ed. / Anon. ACM, 1997. p. 57-70.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Collberg, CS 1997, Reverse interpretation+mutation analysis = automatic retargeting. in Anon (ed.), Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM, pp. 57-70, Proceedings of the 1997 ACM SIGPLAM Conference on Programming Language Design and Implementation, PLDI, Las Vegas, NV, USA, 6/15/97.
Collberg CS. Reverse interpretation+mutation analysis = automatic retargeting. In Anon, editor, Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). ACM. 1997. p. 57-70
Collberg, Christian S. / Reverse interpretation+mutation analysis = automatic retargeting. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). editor / Anon. ACM, 1997. pp. 57-70
@inproceedings{5df9f505bee44b9fb2f23712a4100c9c,
title = "Reverse interpretation+mutation analysis = automatic retargeting",
abstract = "There are three popular methods for constructing highly retargetable compilers: (1) the compiler emits abstract machine code which is interpreted at run-time, (2) the compiler emits C code which is subsequently compiled to machine code by the native C compiler, or (3) the compiler's code-generator is generated by a back-end generator from a formal machine description produced by the compiler writer. These methods incur high costs at run-time, compile-time, or compiler-construction time, respectively. In this paper we will describe a novel method which promises to significantly reduce the effort required to retarget a compiler to a new architecture, while at the same time producing fast and effective compilers. The basic idea is to use the native C compiler at compiler construction time to discover architectural features of the new architecture. From this information a formal machine description is produced. Given this machine description, a native code-generator can be generated by a back-end generator such as BEG or burg. A prototype Automatic Architecture Discovery Unit has been implemented. The current version is general enough to produce machine descriptions for the integer instruction sets of common RISC and CISC architectures such as the Sun SPARC, Digital Alpha, MIPS, DEC VAX, and Intel x86. The tool is completely automatic and requires minimal input from the user: principally, the user needs to provide the internet address of the target machine and the command-lines by which the C compiler, assembler, and linker are invoked.",
author = "Collberg, {Christian S}",
year = "1997",
language = "English (US)",
pages = "57--70",
editor = "Anon",
booktitle = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",
publisher = "ACM",

}

TY - GEN

T1 - Reverse interpretation+mutation analysis = automatic retargeting

AU - Collberg, Christian S

PY - 1997

Y1 - 1997

N2 - There are three popular methods for constructing highly retargetable compilers: (1) the compiler emits abstract machine code which is interpreted at run-time, (2) the compiler emits C code which is subsequently compiled to machine code by the native C compiler, or (3) the compiler's code-generator is generated by a back-end generator from a formal machine description produced by the compiler writer. These methods incur high costs at run-time, compile-time, or compiler-construction time, respectively. In this paper we will describe a novel method which promises to significantly reduce the effort required to retarget a compiler to a new architecture, while at the same time producing fast and effective compilers. The basic idea is to use the native C compiler at compiler construction time to discover architectural features of the new architecture. From this information a formal machine description is produced. Given this machine description, a native code-generator can be generated by a back-end generator such as BEG or burg. A prototype Automatic Architecture Discovery Unit has been implemented. The current version is general enough to produce machine descriptions for the integer instruction sets of common RISC and CISC architectures such as the Sun SPARC, Digital Alpha, MIPS, DEC VAX, and Intel x86. The tool is completely automatic and requires minimal input from the user: principally, the user needs to provide the internet address of the target machine and the command-lines by which the C compiler, assembler, and linker are invoked.

AB - There are three popular methods for constructing highly retargetable compilers: (1) the compiler emits abstract machine code which is interpreted at run-time, (2) the compiler emits C code which is subsequently compiled to machine code by the native C compiler, or (3) the compiler's code-generator is generated by a back-end generator from a formal machine description produced by the compiler writer. These methods incur high costs at run-time, compile-time, or compiler-construction time, respectively. In this paper we will describe a novel method which promises to significantly reduce the effort required to retarget a compiler to a new architecture, while at the same time producing fast and effective compilers. The basic idea is to use the native C compiler at compiler construction time to discover architectural features of the new architecture. From this information a formal machine description is produced. Given this machine description, a native code-generator can be generated by a back-end generator such as BEG or burg. A prototype Automatic Architecture Discovery Unit has been implemented. The current version is general enough to produce machine descriptions for the integer instruction sets of common RISC and CISC architectures such as the Sun SPARC, Digital Alpha, MIPS, DEC VAX, and Intel x86. The tool is completely automatic and requires minimal input from the user: principally, the user needs to provide the internet address of the target machine and the command-lines by which the C compiler, assembler, and linker are invoked.

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

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

M3 - Conference contribution

AN - SCOPUS:0030717770

SP - 57

EP - 70

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

A2 - Anon, null

PB - ACM

ER -