This paper presents a step forward in the use of partial evaluation for interpreting and compiling programs, as well as for automatically generating a compiler from denotational definitions of programming languages. We determine the static and dynamic semantics of a programming language, reduce the expressions representing the static semantics, and generate object code by instantiating the expressions representing the dynamic semantics. By processing the static semantics of the language, programs get compiled. By processing the static semantics of the partial evaluator, compilers are generated. The correctness of a compiler is guaranteed by the correctness of both the executable specification and our partial evaluator. The results reported in this paper improve on previous work in the domain of compiler generation [16, 30], and solves several open problems in the domain of partial evaluation [15]. In essence: ffl Our compilation goes beyond a mere syntax-tosemantics mapping since the ...

Tag elimination is a program transformation for removing unnecessary tagging and untagging operations from automatically...

Abstract not found

Abstract. We study the evolution of partial evaluators over the past fifteen years from a particular perspective: The attempt to prevent structural bounds in the original programs from imposing limits on the structure of residual programs. It will often be the case that a language allows unbounded numbers or sizes of particular features, but each program (being finite) will only have a finite number or size of these features. If the residual programs cannot overcome the bounds given in the original program, that can be seen as a weakness in the partial evaluator, as it potentially limits the effectiveness of residual programs. We show how historical developments in partial evaluators have removed inherited limits, and suggest how this principle can be used as a guideline for further development. 1

Two key steps in the compilation of strict functional languages are the conversion of higher-order functions to data structures (clo- sures) and the transformation to tail-recursive style. We show how to perform both steps at once by applying first-order offline partial evaluation to a suitable interpreter. The resulting code is easy to transliterate to low-level C or native code. We have implemented the compilation to C; it yields a performance comparable to that of other modern Scheme-to-C compilers. In addition, we have integrated various optimizations such as constant propagation, higherorder removal, and arity raising simply by modifying the underlying interpreter. Purely first-order methods suffice to achieve the transformations. Our approach is an instance of semantics-directed compiler generation.

We study systems where deterministic computations take place in environments which may behave nondeterministically. We give a simple formalization by unions of abstract reduction systems, on which various semantics can be based in a straightforward manner. We then prove that under a simple condition on the reduction systems, the following holds: reduction strategies which are cofinal for the deterministic reduction system will implement the semantics for the combined system, provided the environment behaves in a "fair" manner, and certain program transformations, such as folding and unfolding, will preserve the semantics. An application is evaluation strategies and program transformations for concurrent languages. Keywords: formal semantics, program transformations, nondeterminism, reduction systems, recursive program schemes. Submitted to CAAP'96. This work was done under the support of the ESPRIT BRA project CONFER, project no. 6454. 1 Introduction Computer programs can often be ...

BRICS Report Series RS-98-1 ISSN 0909-0878 January 1998 Copyright c fl 1998, BRICS, Department of Computer Science University of Aarhus. All rights reserved.

iii Acknowledgment My graduate study and life, of which this dissertation is one of the outcomes, benefitted greatly from the time, energy, and enthusiasm of many people.

Despite practical successes with the Futamura projections, it has been an open question whether target programs produced by specializing interpreters can always be as e#cient as those produced by a translator. We show that, given a Jones-optimal program specializer with static expression reduction, there exists for every translator an interpreter which, when specialized, can produce target programs that are at least as fast as those produced by the translator. This is not the case if the specializer is not Jones-optimal. We also examine Ershov's generating extensions, give a parameterized notion of Jones optimality, and show that there is a class of specializers that can always produce residual programs that match the size and time complexity of programs generated by an arbitrary generating extension. This is the class of generation universal specializers. We study these questions on an abstract level, independently of any particular specialization method.

In partial evaluation, a polyvariant function is specialized to different specialized versions, depending on the calling context. Usually, polyvariance is limited to named, top-level functions. We lift this restriction in a partial evaluator for a higher-order functional languages to obtain first-class polyvariant functions. These functions are partially static and specialize to a memoization table. Arity raising splits a partially static parameter of a function into its dynamic components. Co-arity raising is the dual to arity raising. It splits a partially static result of a function into its dynamic components. A specializer that performs co-arity raising can transform a function returning one result into a function that returns any number of results, including zero. This technique enables polyvariant functions to return partially static results. We demonstrate the use of these techniques in combination by specializing a typed interpreter for a simply-typed applied lambda calculus s...