Transient Variable Caching in Java’s Stack-Based Intermediate Representation

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...

Full description

Bibliographic Details
Main Author: Paul Týma
Format: Article
Language:English
Published: Hindawi Limited 1999-01-01
Series:Scientific Programming
Online Access:http://dx.doi.org/10.1155/1999/501879
id doaj-6748d35565ca4fd1a63c74beb28e51dd
record_format Article
spelling doaj-6748d35565ca4fd1a63c74beb28e51dd2021-07-02T07:41:52ZengHindawi LimitedScientific Programming1058-92441875-919X1999-01-017215716610.1155/1999/501879Transient Variable Caching in Java’s Stack-Based Intermediate RepresentationPaul Týma0Syracuse University, 26250 Euclid Ave. #503, Euclid, OH 44132, USAJava’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.http://dx.doi.org/10.1155/1999/501879
collection DOAJ
language English
format Article
sources DOAJ
author Paul Týma
spellingShingle Paul Týma
Transient Variable Caching in Java’s Stack-Based Intermediate Representation
Scientific Programming
author_facet Paul Týma
author_sort Paul Týma
title Transient Variable Caching in Java’s Stack-Based Intermediate Representation
title_short Transient Variable Caching in Java’s Stack-Based Intermediate Representation
title_full Transient Variable Caching in Java’s Stack-Based Intermediate Representation
title_fullStr Transient Variable Caching in Java’s Stack-Based Intermediate Representation
title_full_unstemmed Transient Variable Caching in Java’s Stack-Based Intermediate Representation
title_sort transient variable caching in java’s stack-based intermediate representation
publisher Hindawi Limited
series Scientific Programming
issn 1058-9244
1875-919X
publishDate 1999-01-01
description 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.
url http://dx.doi.org/10.1155/1999/501879
work_keys_str_mv AT paultyma transientvariablecachinginjavasstackbasedintermediaterepresentation
_version_ 1721335701801271296