Eliminating dead code on recursive data

Abstract

This paper describes a general and powerful method for dead code analysis and elimination in the presence of recursive data constructions. We represent partially dead recursive data using liveness patterns based on general regular tree grammars extended with the notion of live and dead, and we formulate the analysis as computing liveness patterns at all program points based on program semantics. This analysis yields a most precise liveness pattern for the data at each program point, which i s signi cantly more precise than results from previous methods. The analysis algorithm takes cubic time in terms of the size of the program in the worst case but is very e cient in practice, as shown by our prototype implementation. The analysis results are used to identify and eliminate dead code. The general framework for representing and analyzing properties of recursive data structures using general regular tree grammars applies to other analyses as well.

Detecting oxbow code in Erlang codebases with the highest degree of certainty

“…Code analysis and code quality improvement have long been dynamic research areas within software engineering research. Efforts have targeted from unused variables [33] or dead-code elimination in recursive data [18] to parallel programs [16].…”

Removing redundant arguments automatically

“…. , e k ) is "strictly" necessary to obtain the value of e. The counterpart of this notion has been studied in a number of different analysis techniques such as dead code analysis (Liu and Stoller 2002), unneededness analysis (Hughes 1988), absence analysis (Cousot and Cousot 1994), filtering analysis (Leuschel and Sørensen 1996), or useless analysis (Wand and Siveroni 1999). Also, similar techniques to detect and remove parts of a program which are computationally irrelevant have been investigated in the past: program specialization (Alpuente et al 1997;Alpuente et al 1998;Alpuente et al 1999;Leuschel and Martens 1995;Pettorossi and Proietti 1994;Pettorossi and Proietti 1996a), slicing (Gouranton 1998;Schoenig and Ducasse 1996;Reps and Turnidge 1996;Szilagyi et al 2002;Tip 1995;Weiser 1984), compile-time garbage collection (Jones and Métayer 1989;Park and Goldberg 1992;Knoop et al 1994), and dead code removal (Berardi et al 2000;Kobayashi 2000;Liu and Stoller 2002).…”

“…All these works address the problem of safe elimination of dead variables but heavily handle data structures. A notable exception is Liu and Stoller (2002), where Liu and Stoller discuss how to safely eliminate dead code in the presence of recursive data structures by applying a methodology based on regular tree grammars. Unfortunately, the method in Liu and Stoller (2002) does not apply to achieve the optimization pursued in our running example applast.…”

“…A number of researchers have noticed that certain processes of optimization, transformation, specialization and reuse of code often introduce anomalies in the generated code that programmers usually (or ideally) do not write (Aho et al 1986;Hughes 1988;Leuschel and Sørensen 1996;Liu and Stoller 2002). Examples are redundant arguments in the functions defined by the program, as well as useless program rules.…”

Towards automatic construction of staged compilers

“…However, none of these analyses have been context sensitive, an aspect we have found crucial to our application. Dead-assignment elimination through partially-dead data structures has been studied by Liu and Stoller and by Reps [22,27]. Both these works support recursive liveness patterns, a capability missing in SCF.…”