Compiler techniques for code compaction

@article{Debray2000CompilerTF,
  title={Compiler techniques for code compaction},
  author={Saumya K. Debray and William S. Evans and Robert Muth and Bjorn De Sutter},
  journal={ACM Trans. Program. Lang. Syst.},
  year={2000},
  volume={22},
  pages={378-415}
}
In recent years there has been an increasing trend toward the incorpor ation of computers into a variety of devices where the amount of memory available is limited. This makes it desirable to try to reduce the size of applications where possible. This article explores the use of compiler techniques to accomplish code compaction to yield smaller executables. The main contribution of this article is to show that careful, aggressive, interprocedural optimization, together with procedural… Expand
Code Size Reduction by Compiler Tuning
TLDR
This paper tries to exploit the back end code optimizations present in a production compiler to generate as few assembly instructions as possible and shows that in almost all cases it produces shorter codes than the standard setting -Os does which is designed to optimize for size. Expand
Compression of Compiler Intermediate Representations of Program Code
Code compression reduces the size of a program to be stored on-chip in an embedded system. We introduce an algorithm that a compiler may use to compress its intermediate representation of a program.Expand
Post-compilation optimization for multiple gains with pattern matching
TLDR
A new post-compilation optimization technique which is based on finding repeating instruction patterns in generated code and replacing them with their optimized equivalents and discusses the possible applications of this strategy in design space exploration (DSE) of embedded processors. Expand
Procedural Abstraction for ARM-Architectures
TLDR
In contrast to the traditional aproaches, the authors where able to save twice as much instructions on average with their new graph based approach, which applies procedural abstraction to statically linked binaries. Expand
Profile-guided code compression
TLDR
This paper describes an approach to applying data compression techniques to reduce the size of infrequently executed portions of a program, which increases the amount of code size reduction that can be achieved and limits the runtime overhead due to dynamic decompression. Expand
Exploiting function similarity for code size reduction
TLDR
This paper develops a pragmatic, yet effective code size reduction technique, which exploits structural similarity of functions and avoids code duplication through merging of similar functions and targeted insertion of control flow to resolve small differences. Expand
Sifting out the mud: low level C++ code reuse
TLDR
New techniques to reuse the code of whole procedures at the binary level and a supporting technique for data reuse to achieve additional code size reductions on already highly optimized and compacted binaries, without sacrificing execution speed are introduced. Expand
Sequential decomposition of operations and compilers optimization
TLDR
This report studies different techniques used for sequential decomposition of mappings without using extra variables and introduces a method for the case of boolean bijective mappings via algebraic operations over polynomials in GF(2). Expand
Combining Global Code and Data Compaction
TLDR
The combined code and data compaction is implemented in SQUEEZE, a link-time program compaction system, and evaluated on SPEC2000, MediaBench and C++ programs, resulting in total binary program size reductions of 23.6%-46.6%. Expand
Simple, Effective Code-Size Reduction for Functional Programs
TLDR
To the best of the authors' knowledge, this is the first work on running compressed code for a purely declarative and functional language. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 21 REFERENCES
Enhanced code compression for embedded RISC processors
TLDR
This work focuses on reducing the size of a program's code segment, using pattern-matching techniques to identify and coalesce together repeated instruction sequences, and develops a new form of profile-driven code compression that reduces the speed penalty arising from compression. Expand
Compacting Object Code via Parameterized Procedural Abstraction
TLDR
It is shown that permanent space savings are possible when (1) covering matches with more than one procedure and (2) carefully choosing which inexact match instances are covered by each procedure. Expand
Code compression
TLDR
Measurements that show how code compression can save space and total time in some important real-world scenarios are described. Expand
alto: A Link-Time Optimizer for the DEC Alpha
TLDR
Alto, a link-time optimizer for the DEC Alpha architecture, is described, able to realize significant performance improvements even for programs compiled with a good optimizing compiler with a high level of optimization. Expand
Custom Instruction Sets for Code Compression
TLDR
A C compiler tailored to save space in executables is described, which improves on prior efforts to automatically tailor a compact interpreter and interpretive code for an arbitrary input. Expand
Adaptive Compression of Syntax Trees and Iterative Dynamic Code Optimization: Two Basic Technologies for Mobile Object Systems
  • M. Franz
  • Computer Science
  • Mobile Object Systems
  • 1996
TLDR
By constructing globally optimized code-images from mobile software components, the architecture is able to reconcile dynamic composability with the run-time efficiency of monolithic applications. Expand
A Retargetable C Compiler: Design and Implementation
TLDR
This new text examines the design and implementation of Icc, a production-quality, retargetable compiler, designed at ATT, and encourages a deeper understanding of programming in C, by providing C programmers with a tour of the language from the perspective of compiler authors. Expand
Profile guided code positioning
TLDR
This paper presents the results of the investigation of code positioning techniques using execution profile data as input into the compilation process to reduce the overhead of the instruction memory hierarchy. Expand
Compiler techniques for code compaction
TLDR
In recent years there has been an increasing trend toward the incorporation of computers into a variety of devices where the amount of memory available is limited, which makes it desirable to try new approaches to memory management. Expand
Optimal code motion: theory and practice
An implementation-oriented algorithm for lazy code motion is presented that minimizes the number of computations in programs while suppressing any unnecessary code motion in order to avoidExpand
...
1
2
3
...