Peephole Optimizer Research Articles

Automatic generation of peephole optimizations

This paper describes a system that automatically generates peephole optimizations. A general peephole optimizer driven by a machine description produces optimizations at compile-compile time for a fast, pattern-directed, compile-time optimizer. They form part of a compiler that simplifies retargeting by substituting peephole optimization for case analysis.

Peephole optimization of asynchronous macromodule networks

Most high-level synthesis tools for asynchronous circuits take descriptions in concurrent hardware description languages and generate networks of macromodules or handshake components. In this paper, we propose a peephole optimizer for these networks. Our peephole optimizer first deduces an equivalent blackbox behavior for the network using Dill's trace-theoretic parallel composition operator. It then applies a new procedure called burst-mode reduction to obtain burst-mode machines from the deduced behavior. In a significant number of examples, our optimizer achieves gate-count improvements by a factor of five, and speed (cycle-time) improvements by a factor of two. Burst-mode reduction can be applied to any macromodule network that is delay insensitive as well as deterministic. A significant number of asynchronous circuits, especially those generated by asynchronous high-level synthesis tools, fall into this class, thus making our procedure widely applicable.

Integrating intermediate code optimization with retargetable code generation

A simple and efficient peephole optimizer, integrated with a retargetable code generator is presented. The method is based on user defined translation rules which are both applied to the intermediate code optimization and to the target code generation, achieving a high integration of the two compilation phases. The approach is based on a simple stack oriented intermediate code which is extensible i.e., during the optimization it can be oriented to the target architecture by replacing sequences of instructions with a single user defined new operation. This approach simplifies the code generation phase.

Quick compilers using peephole optimization

AbstractAbstract machine modelling is a popular technique for developing portable compilers. A compiler can be quickly realized by translating the abstract machine operations to target machine operations. The problem with these compilers is that they trade execution efficiency for portability. Typically, the code emitted by these compilers runs two to three times slower than the code generated by compilers that employ sophisticated code generators. This paper describes a C compiler that uses abstract machine modelling to achieve portability. The emitted target machine code is improved by a simple, classical rule‐directed peephole optimizer. Our experiments with this compiler on four machines show that a small number of very general handwritten patterns (under 40) yields code that is comparable to the code from compilers that use more sophisticated code generators. As an added bonus, compilation time on some machines is reduced by 10 to 20 per cent.

An expert system for a retargetable peephole optimizer

Peephole optimization is the process of improving object code produced by a compiler. The optimizer replaces one or several computer instructions with an instruction which is faster or shorter. Retargetable peephole optimizers work on different machines with minor changes. Previous work has automated the process of developing retargetable peephole optimizers given descriptions of machine instructions. Techniques presented here use an expert system for the task of learning which instructions may be optimized using the descriptions of the computer instructions. The expert system simplifies the task of combining and searching instructions. This project was successful in demonstrating that an expert system may be used for a retargetable peephole optimizer. The expert system may be retargeted to another computer by changing the descriptions of the instructions and the descriptions of the addressing modes. The expert system can also handle pairs of branch instructions and special addressing modes with side effects. The amount of work required for a programmer to build and maintain a retargetable peephole optimizer is reduced using an expert system.

Automatic generation of fast optimizing code generators

This paper describes a system that accepts compact specifications of an intermediate code and target machine and produces program code for an integrated code generator and peephole optimizer. A compiler for most of C uses this packa.ge. It emits code comparable to PCCI’S, but it runs over five times faster on preliminary benchmarks. This compiler also runs over twice as fast as a version of pcc2 with a hand-coded, VAX-specific code generator. The code generators are produced as follows. A programmer describes a naive code generator by means of a non-procedural specification. The programmer also prepares a machine description for a retargetable peephole optimizer [2]. These two systems are used together to compile a testbed, and the compiler records each peephole optimization as it is made. This record and the specification of the naive code generator are compiled into a fast, integrated code generator and optimizer. This production code generator then takes the place of the slower “training” version. The production code generator and optimizer are integrated to the point that the code to be generated is communicated from one to the other by encoding it in the program counter, which obviates most inter-phase communication costs. Interpretive peephole optimizers have been driven by traces from retargetable peephole optimizers [3] and integrated with interpretive code generators [4], but the current work is distinguished by the production of a hard-coded, optimizing code generator. Historically, retargetable code generators (i.e., those not largely rewritten for each new machine)

Integrating code generation and optimization

This paper describes a compiler with a code generator and machine-directed peephole optimizer that are tightly integrated. Both functions are performed by a single rule-based rewriting system that matches and replaces patterns. This organization helps make the compiler simple, fast, and retargetable. It also corrects certain phase-ordering problems.

Register allocation and exhaustive peephole optimization

AbstractEmerging peephole optimizers can relieve code generators of much case analysis, but delaying code generation decisions requires register allocation algorithms that accept object code instead of the more usual intermediate code. This paper describes two programs that implement such algorithms for a retargetable optimizing compiler. In a machine‐independent fashion, they allocate and assign registers, eliminate common subexpressions (including often‐missed machine‐specific ones), identify dead variables, and define windows for the companion peephole optimizer. Their techniques for handling machine‐specific data should generalize to other optimizations as well.

Automatic generation of peephole optimizations

This paper describes a system that automatically generates peephole optimizations. A general peephole optimizer driven by a machine description produces optimizations at compile-compile time for a fast, pattern-directed, compile-time optimizer. They form part of a compiler that simplifies retargeting by substituting peephole optimization for case analysis.

Peep

Peep is an architectural description driven peephole optimizer, that is being adapted for use in the Portable Standard Lisp compiler. Tables of optimizable instructions are generated prior to the creation of the compiler from the architectural description of the target machine. Peep then performs global flow analysis on the target machine code and optimizes instructions as defined in the table. This global flow analysis allows optimization across basic blocks of instructions, and the use of tables created at compiler-generation time minimizes the overhead of discovering optimizable instructions.

Using Peephole Optimization on Intermediate Code

Many portable compilers generate an intermediate code that is subsequently translated into the target machine's assembly language. In this paper a stack-machine-based intermediate code suitable for algebraic languages (e.g., PASCAL, C, FORTRAN) and most byte-addressed mini- and microcomputers is described. A table-driven peephole optimizer that improves this intermediate code is then discussed in detail and compared with other local optimization methods. Measurements show an improvement of about 15 percent, depending on the precise metric used. © 1982, ACM. All rights reserved.

Construction of a peephole optimizer

AbstractThe design and construction of a peephole optimizer is described. The optimizer consists of a database of patterns, a translator that translates the patterns into an implementation language, and a pattern‐matcher skeleton into which the generated pattern code is inserted. it is argued that this three‐part split is a good way to approach the construction of certain kinds of programs.

Corrigendum: ``The Design and Application of a Retargetable Peephole Optimizer''

Corrigendum: ``The Design and Application of a Retargetable Peephole Optimizer''

The Design and Application of a Retargetable Peephole Optimizer

Peephole optimizers improve object code by replacing certain sequences of instructions with better sequences. This paper describes PO, a peephole optimizer that uses a symbolic machine description to simulate pairs of adjacent instructions, replacing them, where possible, with an equivalent single instruction. As a result of this organization, PO is machine independent and can be described formally and concisely: when PO is finished, no instruction, and no pair of adjacent instructions, can be replaced with a cheaper single instruction that has the same effect. This thoroughness allows PO to relieve code generators of much case analysis; for example, they might produce only load/add-register sequences and rely on PO to, where possible, discard them in favor or add-memory, add-immediate, or increment instructions. Experiments indicate that naive code generators can give good code if used with PO.