Language and machine-independent global optimization on intermediate code
Computer Languages
Stack computers: the new wave
Java intermediate bytecodes: ACM SIGPLAN workshop on intermediate representations (IR'95)
IR '95 Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations
Stack caching for interpreters
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Java bytecode to native code translation: the caffeine prototype and preliminary results
Proceedings of the 29th annual ACM/IEEE international symposium on Microarchitecture
The Generation of Optimal Code for Stack Machines
Journal of the ACM (JACM)
Optimal Code Generation for Expression Trees
Journal of the ACM (JACM)
Using Peephole Optimization on Intermediate Code
ACM Transactions on Programming Languages and Systems (TOPLAS)
A practical tool kit for making portable compilers
Communications of the ACM
Optimizing FORTRAN Programs
Java Virtual Machine Specification
Java Virtual Machine Specification
On the evaluation of expressions using accumulators, stacks and store-to-store instructions
ACM SIGARCH Computer Architecture News
More on the use of stacks in the evaluation of expressions
ACM SIGARCH Computer Architecture News
Compilers: Principles, Techniques, and Tools (2nd Edition)
Compilers: Principles, Techniques, and Tools (2nd Edition)
Hi-index | 0.00 |
Java’s stack-based intermediate representation (IR) is typically coerced to execute on register-based architectures. Unoptimized compiled code dutifully replicates transient variable usage designated by the programmer and common optimization practices tend to introduce further usage (i.e., CSE, Loop-invariant Code Motion, etc.). On register based machines, often transient variables are cached within registers (when available) saving the expense of actually accessing memory. Unfortunately, in stack-based environments because of the need to push and pop the transient values, further performance improvement is possible. This paper presents Transient Variable Caching (TVC), a technique for eliminating transient variable overhead whenever possible. This optimization would find a likely home in optimizers attached to the back of popular Java compilers. Side effects of the algorithm include significant instruction reordering and introduction of many stack-manipulation operations. This combination has proven to greatly impede the ability to decompile stack-based IR code sequences. The code that results from the transform is faster, smaller, and greatly impedes decompilation.