Code selection through object code optimization
ACM Transactions on Programming Languages and Systems (TOPLAS) - Lecture notes in computer science Vol. 174
Superoptimizer: a look at the smallest program
ASPLOS II Proceedings of the second international conference on Architectual support for programming languages and operating systems
Optimal code generation for expression trees: an application BURS theory
POPL '88 Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
BEG: a generator for efficient back ends
PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
A language for writing code generators
PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
Code generation using tree matching and dynamic programming
ACM Transactions on Programming Languages and Systems (TOPLAS)
BURG: fast optimal instruction selection and tree parsing
ACM SIGPLAN Notices
Eliminating branches using a superoptimizer and the GNU C compiler
PLDI '92 Proceedings of the ACM SIGPLAN 1992 conference on Programming language design and implementation
Engineering a simple, efficient code-generator generator
ACM Letters on Programming Languages and Systems (LOPLAS)
The advantages of machine-dependent global optimization
Proceedings of the international conference on Programming languages and system architectures
Simple and effective link-time optimization of Modula-3 programs
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Fast, effective dynamic compilation
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Generating machine specific optimizing compilers
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Automatic checking of instruction specifications
ICSE '97 Proceedings of the 19th international conference on Software engineering
Specifying representations of machine instructions
ACM Transactions on Programming Languages and Systems (TOPLAS)
Reverse interpretation + mutation analysis = automatic retargeting
Proceedings of the ACM SIGPLAN 1997 conference on Programming language design and implementation
A single intermediate language that supports multiple implementations of exceptions
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Automatic Derivation of Code Generators from Machine Descriptions
ACM Transactions on Programming Languages and Systems (TOPLAS)
The Design and Application of a Retargetable Peephole Optimizer
ACM Transactions on Programming Languages and Systems (TOPLAS)
The problem of programming communication with changing machines: a proposed solution
Communications of the ACM
Communications of the ACM
Hacker's Delight
A Discipline of Programming
A Retargetable C Compiler: Design and Implementation
A Retargetable C Compiler: Design and Implementation
Machine Descriptions to Build Tools for Embedded Systems
LCTES '98 Proceedings of the ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Embedded Systems
The Design of a Resourceable and Retargetable Binary Translator
WCRE '99 Proceedings of the Sixth Working Conference on Reverse Engineering
Automatic Detection and Diagnosis of Faults in Generated Code for Procedure Calls
IEEE Transactions on Software Engineering
A generalized algorithm for graph-coloring register allocation
Proceedings of the ACM SIGPLAN 2004 conference on Programming language design and implementation
C Compiler Retargeting Based on Instruction Semantics Models
Proceedings of the conference on Design, Automation and Test in Europe - Volume 2
Formal certification of a compiler back-end or: programming a compiler with a proof assistant
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Denali: A practical algorithm for generating optimal code
ACM Transactions on Programming Languages and Systems (TOPLAS)
The New Jersey machine-code toolkit
TCON'95 Proceedings of the USENIX 1995 Technical Conference Proceedings
Automatically generating the back end of a compiler using declarative machine descriptions
Automatically generating the back end of a compiler using declarative machine descriptions
Converting intermediate code to assembly code using declarative machine descriptions
CC'06 Proceedings of the 15th international conference on Compiler Construction
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
RockSalt: better, faster, stronger SFI for the x86
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Scalable formal machine models
CPP'12 Proceedings of the Second international conference on Certified Programs and Proofs
Hi-index | 0.00 |
Despite years of work on retargetable compilers, creating a good, reliable back end for an optimizing compiler still entails a lot of hard work. Moreover, a critical component of the back end---the instruction selector---must be written by a person who is expert in both the compiler's intermediate code and the target machine's instruction set. By generating the instruction selector from declarative machine descriptions we have (a) made it unnecessary for one person to be both a compiler expert and a machine expert, and (b) made creating an optimizing back end easier than ever before. Our achievement rests on two new results. First, finding a mapping from intermediate code to machine code is an undecidable problem. Second, using heuristic search, we can find mappings for machines of practical interest in at most a few minutes of CPU time. Our most significant new idea is that heuristic search should be controlled by algebraic laws. Laws are used not only to show when a sequence of instructions implements part of an intermediate code, but also to limit the search: we drop a sequence of instructions not when it gets too long or when it computes too complicated a result, but when too much reasoning will be required to show that the result computed might be useful.