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

Abstract The trends in software development are towards larger programs, more complex programs, and more use of programs as "component software. " These trends mean that the features of modern programming languages are becoming more important than ever before. Programming languages need to have features such as strong typing, a module system, polymorphism, automatic storage management, and higher-order functions. In short, modern programming languages are becoming more important than ever before.

. This paper describes a verified compiler for PreScheme, the implementation language for the vlisp run-time system. The compiler and proof were divided into three parts: A transformational front end that translates source text into a core language, a syntax-directed compiler that translates the core language into a combinator-based tree-manipulation language, and a linearizer that translates combinator code into code for an abstract stored-program machine with linear memory for both data and code. This factorization enabled different proof techniques to be used for the different phases of the compiler, and also allowed the generation of good code. Finally, the whole process was made possible by carefully defining the semantics of vlisp PreScheme rather than just adopting Scheme's. We believe that the architecture of the compiler and its correctness proof can easily be applied to compilers for languages other than PreScheme. Table of Contents 1 Introduction : : : : : : : : : : : : : :...

In a series of papers in the early 80's we proposed a paradigm for semanticsbased compiler correctness. In this paradigm, the source and target languages are given denotational semantics in the same -theory, so correctness proofs can be carried out within this theory. In many cases, the proofs have a highly structured form. We show how a simple proof strategy, based on an algorithm for ff-matching, can be used to build a tool that can automate the routine cases of these proofs. 1 Introduction In a series of papers in the early 80's [19, 18, 20, 5] we proposed a paradigm for semantics-based compiler correctness, and over the last several years we have begun putting this paradigm into practice [22, 14]. In this paradigm, the source and target languages are given denotational semantics in the same -theory [11], so that most of the steps of the correctness proof can be done Work supported by the National Science Foundation under grant numbers CCR9014603 and CCR-9304144. within the t...

In this dissertation we present a methodology for the verification of language implementations based on formal semantics. While this is not a new concept, the methodology presented is interesting for several reasons: ffl It is easy to use ffl It can be applied to languages specified by traditional denotational techniques ffl It mirrors traditional language implementation schemes ffl It is powerful enough to generate code for contemporary machine architectures Our approach advocates the use of denotational semantics to verify compiler front ends (machine independent transformations) and operational semantics to verify compiler back ends (machine dependent transformations). To illustrate the methodology, we present and verify an implementation of the language -LISP, a dialect of the Scheme programming language [13]. -LISP is restricted to obey stack discipline which introduces a number of issues we must deal with to ensure that the language is implemented properly (i.e. using only a st...