Partial evaluators can be separated into two classes: offline specializers, which make all of their reduce/residualize decisions before specialization, and online specializers, which make such decisions during specialization. The choice of which method to use is driven by a tradeoff between the efficiency of the specializer and the quality of the residual programs that it produces. Existing research describes some of the inefficiencies of online specializers, and how these are avoided using offline methods, but fails to address the price paid in specialization quality. This paper motivates research in online specialization by describing two fundamental limitations of the offline approach, and explains why the online approach does not encounter the same difficulties.

. This paper identifies and solves a class of problems that arise in binding time analysis and more generally in partial evaluation of programs: the approximation and loss of static information due to dynamic expressions with static subexpressions. Solving this class of problems yields substantial binding time improvements and thus dramatically better results not only in the case of partial evaluation but also for static analyses of programs --- this last point actually is related to a theoretical result obtained by Nielson. Our work can also be interpreted as providing a solution to the problem of conditionally static data, the dual of partially static data. We point out which changes in the control flow of a source program may improve its static data flow. Unfortunately they require one to iterate earlier phases of partial evaluation. We show how these changes are subsumed by transforming the source program into continuation-passing style (CPS). The transformed programs get specializ...

this paper is to propagate static information via residual types. For example, when we specialise a static integer the residual expression is a dummy value, but the residual type tells us which static value it represents: 3 : int ,! ffl : 3 Here `3' is a type with only one element, namely ffl, and which therefore has just the same elements as 4, 5, 6 etc. --- but which carries different static information. All expressions, even `dynamic' ones, carry static information in the form of a residual type. For purely dynamic expressions this is just an ordinary type, for example 3 : int ,! 3 : int

This paper presents semantic specifications and correctness proofs for both on-line and offline partial evaluation of strict first-order functional programs. To do so, our strategy consists of defining a core semantics as a basis for the specification of three non-standard evaluations: instrumented evaluation, on-line and off-line partial evaluation. We then use the technique of logical relations to prove the correctness of both on-line and off-line partial evaluation semantics. The contributions of this work are as follows. 1. We provide a uniform framework to defining and proving correct both on-line and off-line partial evaluation. 2. This work required a formal specification of on-line partial evaluation with polyvariant specialization. We define criteria for its correctness with respect to an instrumented standard semantics. As a byproduct, on-line partial evaluation appears to be based on a fixpoint iteration process, just like binding-time analysis. 3. We show that binding-time...

This document describes the design and implementation of PARTICLE, a fully automatic program specialization system for imperative and low-level languages. PARTICLE performs source-to-source specialization of programs written in the C programming language based on knowledge of program behavior acquired through extensible, high-quality program analysis. PARTICLE supports a unique two-phase specialization strategy that permits careful balancing between the time benefits and space costs of specialization and permits the user to avoid the huge space expansion that has traditionally accompanied program specialization. During the first phase of PARTICLE operation, an input program in the C programming language is analyzed using an extensibly precise form of symbolic evaluation in order to discover opportunities for low-level specialization. The symbolic evaluation manipulates explicit approximations to program values and states and the compile time flow of analysis in the program represents a...

This thesis describes a compiler for the asynchronous real-time programming language ALDiSP. Though the language has a complex semantics not suited for easy compilation, the compiler has to generate code for target platforms that have stringent space limitations, and for target applications that have to satisfy hard real-time requirements. To accomplish this feat, the compiler is based upon an abstract interpreter that simulates all possible evaluation paths of the program. In a reconstruction phase, the program is then totally re-created from the information gained during this simulation. The abstract interpreter is an extension of the formal semantics of ALDiSP.