We show how some classical static analyses for imperative programs, and the optimizing transformations which they enable, may be expressed and proved correct using elementary logical and denotational techniques. The key ingredients are an interpretation of program properties as relations, rather than predicates, and a realization that although many program analyses are traditionally formulated in very intensional terms, the associated transformations are actually enabled by more liberal extensional properties.

We show a type-based method for useless variable elimination, i.e., transformation that eliminates variables whose values contribute nothing to the final outcome of a computation, and prove its correctness. The algorithm is a surprisingly simple extension of the usual type reconstruction algorithm. Our method seems more attractive than Wand and Siveroni's 0CFA-based method in many respects. First, it is efficient: it runs in time almost linear in the size of an input expression for a simply-typed -calculus, while the 0CFA-based method may require a cubic time. Second, our transformation can be shown to be optimal among those that preserve well-typedness, both for the simply-typed language and for an ML-style polymorphically-typed language. On the other hand, the 0CFA-based method is not optimal for the polymophically-typed language. ANY OTHER IDENTIFYING INFORMATION OF THIS REPORT Summary has been submitted for publication. Up-to-date version of this report will be available through ...

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

Abstract not found

The application of automatic transformation processes during the formal development and optimization of programs can introduce encumbrances in the generated code that programmers usually (or presumably) do not write. An example is the introduction of redundant arguments in the functions defined in the program. Redundancy of a parameter means that replacing it by any expression does not change the result. In this work, we provide a method for the analysis and elimination of redundant arguments in term rewriting systems as a model for the programs that can be written in more sophisticated languages.

In this paper we present two type inference systems for detecting useless-code in higher-order typed functional programs. Type inference can be performed in an efficient and complete way, by reducing it to the solution of a system of constraints. We also give a useless-code elimination algorithm which is based on a combined use of these type inference systems. The main application of the technique is the optimization of programs extracted from proofs in logical frameworks, but it could be used as well in the elimination of useless-code determined by program transformations. Capsule Review Dead code is a subterm M of a term t = C[M] which does not matter to computation, that is, which may be replaced by any other term of the same type without altering the observational behaviour of the program: C[M] =obs C[N] for any N with the type of M. Dead-code may be replaced by dummy variable, or even completely removed, in order to optimize a program. The interest in dead-code by the authors started as a by-product of a proof system which generated programs meeting a specification out of proofs that the specification is satisfiable.

In this paper, we study program transformations called uselesscode elimination and program slicing in the context of the #-calculus.

Abstract not found

Interpretation Abstract Interpretation is a formal-semantics-based methodology for deriving provably correct program analyses. The main idea, formalised by Cousot and Cousot [CC77], is that a program can be given different interpretations by modifying the domain of values that it manipulates. The concrete interpretation, defined by the standard semantics, gives exact information about the behaviour of a program. When the initial set of values is replaced by elements that denote a particular property (abstract values) and the derivation (evaluation) rules are modified accordingly, the abstract interpretation - now defined by a non-standard semantics - calculates information that approximates the behaviour of the concrete interpretation regarding this particular property. An abstract interpretation generates abstract traces. Properties defined on concrete traces need small changes to work with their abstract counterparts. Abstraction reduces the size and the detail of information in th...

Computer systems play an important role in the modern information society. However, the low quality of software and its low level of abstraction, inhibit the necessary confidence of final users and system developers in software engineering. Correctness of computer programs by a mathematical theory of computation is the fundamental concern of the theory of programming and of its application in large-scale software engineering. Formal methods provide software engineering with the suitable scientific and technological framework to become a real engineering, as predictable as civil or electrical engineering are. Indeed, the use of declarative rule-based programming languages during all program development stages ensures that correct and certified formal methodologies are followed during the whole software production process.