ESOP 86: European Symposium on Programming Saarbrücken, Federal Republic of Germany March 17–19, 1986 Proceedings

380 Pages·1986·10.242 MB·English

by  Mads Dam, Frank Jensen (auth.), Bernard Robinet, Reinhard Wilhelm (eds.)

Lecture Notes ni
Computer Science
Edited .G yb Goos dna .J Hartmanis
213
ESOP 86
naeporuE muisopmyS no gnimmargorP
,nekciLrbraaS laredeF of Republic ynamreG
hcraM 17-19, 6891
sgnideecorP
detidE yb .B teniboR dna .R mlehliW
I I
galreV-regnirpS
nilreB Heidelberg New York oykoT
Editorial Board
.D Barstow .W Brauer .P Brinch Hansen .D Gries .D Luckham
C. Moler A. Pnueli G. SeegmLiller .J Stoer .N Wirth
srotidE
dranreB Robinet
IBM de Paris, Scientifique Centre
,63 euneva dnomyaR F-75116 Paris Poincar6,
drahnieR mlehliW
lhutsrheL Informatik fLir ,1I RF 10.2-1nformatik, t.~tisrevinU des sednatraaS
0066-D nekciLrbraaS
(1985): Classifications Subject CR D.1.1, D,1.3, D.3, F.3.2
ISBN 1-24461-045-3 galreV-regnirpS York New Heidelberg Berlin oykoT
ISBN 1-24461-783-0 galreV-regnirpS Berlin Heidelberg York New oykoT
This work is subject to copyright. All rights are reserved, whether the whole or parto f the material
is concerned, specifically those of translation, reprinting, re~use of illustrations, broadcasting,
reproduction by photocopying machine or similar means, and storage in data banks. Under
§ 54 of the German Copyright Law where copies are made for other than private use, a fee is
payable to "Verwertungsgesellschafl Wort", Munich.
© by Springer-Verlag Berlin Heidelberg 1986
Printed in Germany
Printing and binding: Beltz Offsetdruck, Hemsbach/Bergstr.
2145/3140-543210
FOREWORD
Several European computer science associations have joined in an effort to establish
a high quality conference series on programming and programming languages. This -es
ries, the European Symposium on Programming, is a successor to the Colloque
sur la Programmation and the GI-workshops on Programmlerupraehen und Pro-
grammentwieklung (Programming languages and program development). The first
such conference, ESOP ,68 was held at the Universit~t des Saartandes, Saarbri~cken,
from March 17-19, I986. The program committee received about 001 submitted papers
from 19 countries, 28 articles were selected for the conference. The committee faced the
difficult task to give ESOP a flavour which would distinguish it from conferences like
ICALP, STACS and CAAP. All committee members decided that ESOP should contain
papers about "theory based practice" resp. "theoretical papers of practical relevance".
Therefore quite a number of high quality papers were rejected because it was felt that
their practical relevance was not convincingly argued. On the other side, the committee
regret at the small number of submissions on programming methodology. The emphasis
of the ESOP 86 programme si on logic and functional programming languages and their
implementation, on semantics~ parallelism~ compilation and term rewriting systems.
The chairmen of ESOP 86 would like to thank all the people who have participated
in the effort to establish ESOP, to make ESOP 86 a success, and to provide the organi-
zational basis for ESOP .68
.B Robinet (Paris) R. Wilhelm (SaarbrScken)
Conference Ctmirmem
Bernard Robinet (Paris) and Reinhard Wilhelm (Saarbriicken)
Program Committee:
J.Arsac (Paris), G.Ausiello (Roma), D.Bjorner (Lyngby), H.Ganzinger (Dortmund),
C.Girault (Paris), K.Indermark (Aachen), C.H.A.Koster (Nijmegen), R.Mitner (Edin-
burgh), V.Montanari (Pisa), M.Nivat (Paris), M.Paul (Miinchen), B.Robinet (Paris),
M.Sintzoff (Louvain), R.Wilhelm (Saarbri~cken)
TABLE OF CONTENTS
COMPILATION
M. Dam, .F Jensen
COMPILER GENERATION FROM RELATIONAL SEMANTICS .................... I
F, nosleiN
CORRECTNESS OF CODE GENERATION FROM A TWO-LEVEL META-LANGUAGE ......... 30
OPTIMIZED LANGUAGE IMPLEMENTATION
K.-U. ~uertnegleF W.-M. Lippe
A GENERAL APPROACH TO THE OPTIMIZATION OF FUNCTION CALLS .............. 41
U. Kastens, .M Schmidt
LIFETIME ANALYSIS FOR PROCEDURE PARAMETERS . . . . . . . . . . . . . . . . . . . . . . 53
Armbruster D.
A POLYNOMIAL DETERMINATION OF THE MOST RECENT PROPERTY IN PASCAL-LIKE
PROGRAMS
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *
FUNCTIONAL PROGRAMMING LANGUAGE IMPLEMENTATION
H. ,resalG .S Hayes
ANOTHER IMPLEMENTATION TECHNIQUE FOR APPLICATIVE LANGUAGES ........... 70
P. tolleB
GRAAL:A FUNCTIONAL PROGRAMMING SYSTEM WITH UNCURRYFIED COMBINATORS AND
ITS REDUCTION MACHINE .................................... 82
C.L. Hankin, G.L. Burn, S.L. Peyton Jones
A SAFE APPROACH TO PARALLEL COMBINATOR REDUCTION . . . . . . . . . . . . . . . . . . 99
FUNCTIONAL PROGRAMMING LANGUAGES
C. B5hm
REDUCING RECURSION TO ITERATION BY ALGEBRAIC EXTENSION . . . . . . . . . . . . . . 111
.D Bert, R. Echahed
DESIGN AND IMPLEMENTATION OF A GENERIC, LOGIC AND FUNCTIONAL PROGRAMMING
LANGUAGE 119
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
SEMANTICS
H.R. Nietson, F. Nielson
PRAGMATIC ASPECTS OF TWO-LEVEL DENOTATIONAL META-LANGUAGES . . . . . . . . . . 133
.M Naftalin
AN EXPERIMENT IN PRACTICAL SEMANTICS . . . . . . . . . . . . . . . . . . . . . . . . . . 144
.E J.A. Dahlhaus, Makowsky
THE CHOICE OF PROGRAMMING PRIMITIVES FOR SETL-LIKE PROGRAMMING LANGUAGES . . 160
* Paper not received in time
SEMANTICS AND ABSTRACT DATA TYPES
.G ,tonreB M. ,tiodiB .C Choppy
ALGEBRAIC SEMANTICS OF EXCEPTION HANDLING ...................... 173
J. He, C.A.R. Hoare, J.W. Sanders
DATA REFINEMENT REFINED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
E.W. kratS
PROVING ENTAILMENT BETWEEN CONCEPTUAL STATE SPECIFICATIONS ........... 791
PARALLELISM
.R jteloirT .P ~reirtuaeF .F niogirI
AUTOMATIC PARALLELIZATION OF FORTRAN PROGRAMS IN THE PRESENCE OF
PROCEDURE-CALLS ...................................... 012
P. Jouvelot
PARALLELIZATION BY SEMANTIC DETECTION OF REDUCTIONS . . . . . . . . . . . . . . . . 223
.N.J Kok
DENOTATIONAL SEMANTICS OF NETS WITH NONDETERMINISM ................ 732
TOOLS
.A nenimlaS
SPECIFICATION OF A TOOL FOR VIEWING PROGRAM TEXT .................. 052
LOGIC PROGRAMMING
P. Boizumault
A CLASSICAL IMPLEMENTATION FOR PROLOG-II . . . . . . . . . . . . . . . . . . . . . . . . 262
.P MeUo, .A ilataN
PROGRAMS AS COLLECTIONS OF COMMUNICATING PROLOG UNITS .............. 274
B. Schwinn, G. Barth
AN AND-PARALLEL EXECUTION MODEL OF LOGIC PROGRAMS . . . . . . . . . . . . . . . . 289
LOGIC PROGRAMMING
.J ,akanaT M. atihsihsiK
COMPILING EXTENDED CONCURRENT PROLOG
-SINGLE QUEUE COMPILATION- . ............................... 103
.C Codognet, .P ,tengodoC .G hliF
A VERY INTELLIGENT BACKTRACKING METHOD FOR LOGIC PROGRAMS ........... 513
H. Scnderga~rd
AN APPLICATION OF ABSTRACT INTERPRETATION OF LOGIC PROGRAMS:
327
OCCUR CHECK REDUCTION ..................................
TERM REWRITING
A. Geser, .H HuBmann
EXPERIENCES WITH THE RAP SYSTEM - A SPECIFICATION INTERPRETER COMBINING
339
TERM REWRITING AND RESOLUTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.S Kaplan
REWRITING WITH A NONDETERMINISTtC CHOICE OPERATOR:
351
FROM ALGEBRA TO PROOFS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
COMPILER GENERATION FROM P~LATIONAL SEMANTICS
Mads Dam I
Frank Jensen 2
ABSTRACT
We consider the problem of automatically deriving correct compilers
from relational semantic specifications of programming languages. A re-
lational semantics is an assignment of initial-state final-state rela-
tions (defined by means of proof rules) to programs. Compilers are ge-
nerated in three steps. First, the language definition is transformed
into a stack semantics in which the sto~age of semantic values is made
explicit. Next, stack rules are assembled into a socalled language
scheme containing exactly one rule for each language construct. We
consider languages for which non-deterministic branches may be re-
placed by deterministic ones. Finally, rules are expanded for the
purpose of recursion detection, thus obtaining schemes which may be
used for code generation in a syntax-directed compiler.
I. Introduction
In this paper we consider relational semantic specifica-
tions of programming languages and the problem of deriving
correct compilers from such specifications in an automatic
way. In relational semantics meaning is given to programs as
relations between initial and final states.
The term "relational semantics" seems to have originated
with the relational theories of Hoare and Lauer in [Hoare/
Lauer 73]. Their semantics, however, have a much less opera-
tional flavour than the one considered here, in that they
e.g. use invariant properties for the semantics of loops. Our
relational semantics is much closer to the deductive systems
proposed by Greif and Meyer ([Greif/Meyer 81]) as an alterna-
tive to the semantics of Hoare and Lauer. Also Plotkin pro-
posed the use of relational semantics in his work on struc-
tural operational semantics ([Plotkin 81]), and in fact our
understanding of relational semantics has been heavily in-
fluenced by his work.
IAuthors' address: University of Edinburgh, Dept. of Computer Science,
James Clerk Maxwell Building, The King's Buildings, Mayfield Road,
Edinburgh, EH9 3JZ, U.K.
2Authors' address: Aalborg University Centre, Institute of Electronic
Systems, Strandvejen 19, ,4 DK-9000 Aalborg, Denmark
The basic constituent of a relational semantics is a de-
ductive system (in the style of [Plotkin 81]) consisting of
a finite number of axioms and rules of inference, from which
formulae denoting valid state transitions may be proved.
Formulae in such systems are expressions y[p]y', where ¥ and
y' are expressions denoting initial and final (or terminal)
states respectively, and p is a construct in the programming
language under consideration. Axioms and rules of inference
are constructed from such formulae together with predicates
on states. We shall neither allow quantification nor circular
definition of states, and it is from this restriction the
operational nature of the relational semantics originates.
Relational semantics in the present setting has been used
for several example languages in e.g. [Greif/Meyer 81] and
.H[ Nielson 84]. It seems that most of the language specifi-
cation ideas of Plotkin ([Plotkin 8i]) are more or less di-
rectly transferable to the domain of relational semantics
(at least for languages not involving parallellism).
The traditional approach to semantics-directed compiler
generation has been to provide a universal compiler, as in
e.g. [Mosses 79], [Jones/Schmidt 80], [Jones/Christiansen 81],
[Mosses 80] and [Sethi 83] for variants of denotational seman-
tics ([Stoy 77] and [Gordon 79]). This approach is also appli-
cable in our case, noting that a relational semantics is es-
sentially just a collection of first-order sentences in Horn
form ([Kowalski 74]). Thus a compiler for Prolog may be con-
sidered a universal compiler for relational semantics. This
approach, however, has the major drawback that implementation
considerations are moved from the domain of language speci-
fications to the (considerably more general) domain of (pure)
Prolog programs.
On the other hand works on (non-automated) semantics-di-
rected compiler development usually takes a transformational
approach ([Milne/Strachey 76], [Ganzinger 80] and [Wand 82]),
that is, compilers are developed through a series of transfor-
mations on denotational language definitions involving quite
complex correctness proofs. In this paper we apply a similar,
but automated, transformational approach for relational se-
mantics.
We shall be concerned mainly with ~'ordinary" (determinis-
tic) programming languages and the control flow aspects of
their implementation.
Three major problems concerning compiler generation are
identified. First, the problem of deriving a machine state
uniform to all types of program fragments, such that all non-
elementary computations can be viewed as a sequential compo-
sition of other computations, as defined by the proof rules.
This problem is solved by the generation of a stack semantics.
Next, the problem of collecting rules defining the meaning
of identical language constructs, and, if possible, replacing
non-deterministic branches by deterministic ones. To this
end the stack semantics is transformed into a "language
scheme", much like a recursive program scheme (cf.o [De
Bakker/De Roever 72]).
Finally, the problem of detecting recursion in language
schemes, such that language scheme rules may be used as sche-
mes for use in code generation. This, however, requires that
"definition by syntactical equivalence" is used only to a li-
mited extent.
The approach taken throughout the paper is basically opera-
tional - systems are given operational semantics, which are
then proven congruent using mainly (numerical) induction.
In section 2 relational semantics is more precisely defined
- we shall, due to the subject of this paper, be rather
thorough on this point. In sections 3-8 the various trans-
formations on semantics are presented and proved to be cor-
rect. As most proofs are entirely routine, they have just
been very briefly outlined. Finally, in section ,9 some direc-
tions for future work are briefly discussed.
.2 Relational semantics
The relational semantic metalanguage used in this paper
is much like the operational semantics of Plotkin ([Plotkin 81])
with the major difference that all transitions are directly
from initial to terminal states.
A language definition will consist of three parts: A defi-
nition of the language syntax, a definition of the semantic
data types used (e.g. stores, environments), and a finite
set of rules, comprising a formal calculus, from which va-
lid state transitions may be deduced.
Programs are considered as abstract trees A(Pl,...,pn),
n~o, where pl,...tPn are programs and A is an operation sym-
bol. To each operation symbol is associated an arity and a
sort in the sense of e.g. [ADJ 78], reflecting the fact that
programs may be composed of phrases of different semantic
significance (e.g. commands, expressions). The set of sorts
(which we assume to be finite) is denoted by S, the set of
operation symbols by H and the set of programs by P. The set
Z is indexed by S~xS (arity and sort), and the set P is indexed
by S.
As we are concerned mainly with control flow aspects of
compiler generation, we regard states and operations on sta-
!
tes as primitive. We shall simply associate sets s D and s D
to each sort s6S, namely the initial and terminal states of
the sort s, letting D = U (DsUD~).
s£S
E.g. for expressions without sideeffects, the initial state
might be a mapping of identifiers to values, and the terminal
state a value alone. Furthermore, for the purpose of typing,
a unique set of (meta-~ variable symbols is associated to each
program sort and state set. Throughout the paper symbols
~'~I"'" are used as program and ~'~1'''" as state variables.
Expressions over programs and states are constructed using
variables together with elements of sets ~,~ and ~ of opera-
tion symbols to which an arity and a sort is associated much
as for programs above. Operation symbols ~6~ and ~6¢ denotes
functions ~: pn Dm p and ~: pn Dm D respectively and an
P P P P
operation symbol ~6H denotes a predicate ~: pn ~p m D ~pT, where
T = {tt,ff} is the set of thruthvalues. Here ~ denotes the
P
partial function space constructor and n X and n-ary cartesian
product XslX...XXsn for sorts Sl,...,Sn6S. Thus, if Vl,...,~n
and al,...,o m are program and state variables of appropriate
sorts and ~6Y is a corresponding operation symbol, then
~(Vl .... ,~n) (o1,...,Om) is an expression of the sort deter-
mined by ~. Notice that, as operation symbols A6X may be viewed