Results 11  20
of
30
The Design of a Simulator Tool
 THE FORMAL DESCRIPTION TECHNIQUE LOTOS
, 1989
"... The LOTOS simulator Hippo was developed in the ESPRIT/SEDOS project. In this chapter we elaborate on its design process. We give an overview of the functional requirements on a LOTOS simulator for the analysis of dynamic behaviour. Following that we describe how the implementation of Hippo is derive ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
The LOTOS simulator Hippo was developed in the ESPRIT/SEDOS project. In this chapter we elaborate on its design process. We give an overview of the functional requirements on a LOTOS simulator for the analysis of dynamic behaviour. Following that we describe how the implementation of Hippo is derived by stepwise transformation of the LOTOS inference rules.
SemanticsDirected Code Generation
, 1985
"... The intermediate representations (IR) used by most compilers have an operational semantics. The nodes in the graph (or tree, or quadcode sequence) have an interpretation as the operation codes of some abstract machine. A denotational semantics, in which each node in the IR graph has a static meanin ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
The intermediate representations (IR) used by most compilers have an operational semantics. The nodes in the graph (or tree, or quadcode sequence) have an interpretation as the operation codes of some abstract machine. A denotational semantics, in which each node in the IR graph has a static meaning, can lead to a clean interface between the front and back ends of the compiler. Furthermore, it is possible to concisely specify a code generator to translate the denotational representation into machine code. Combined with recent work allowing the denotational specification of front ends to translate the input language into the IR, a complete compiler with a welldefined semantics may be generated. Using this technique, compilers have been written for (most of) Pascal and C which, although they compile slowly, produce fairly good machine code. July 25,  1  1 1. Introduction The intermediate representations (IR) used by most compilers have an operational semantics. The nodes in the gra...
Compiler Generation by Partial Evaluation
 Master’s thesis, DIKU
, 1991
"... In this report describes techniques required to generate efficient compilers for realistic languages by partial evaluation and to what extent these techniques can be automated. It also describes a large application where a realistic compiler was generated for a strongly typed lazy functional languag ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
In this report describes techniques required to generate efficient compilers for realistic languages by partial evaluation and to what extent these techniques can be automated. It also describes a large application where a realistic compiler was generated for a strongly typed lazy functional language. Compiler generation is often emphasized as being the most important application of partial evaluation, but most of the larger practical applications have been outside this field. Especially, no one has generated compilers for languages other than small example languages. It is well known how compilers can be generated from interpreters by partial evaluation. So we show how to obtain interpreters (in strict functional languages) from formal language descriptions. One way is to specialize a metainterpreter with respect to language definitions to generate interpreters. This metainterpreter approach has the advantage that one may define new and better definition languages without having to write new partial evaluators. We have studied what kind of binding time improvements of interpreters are needed to obtain compilers which are both efficient and generate good target code. Furthermore, we look at how to modify interpreters to generate optimizing compilers (in the
Towards Machinechecked Compiler Correctness for Higherorder Pure Functional Languages
 CSL '94, European Association for Computer Science Logic, Springer LNCS
, 1994
"... . In this paper we show that the critical part of a correctness proof for implementations of higherorder functional languages is amenable to machineassisted proof. An extended version of the lambdacalculus is considered, and the congruence between its direct and continuation semantics is proved. ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
. In this paper we show that the critical part of a correctness proof for implementations of higherorder functional languages is amenable to machineassisted proof. An extended version of the lambdacalculus is considered, and the congruence between its direct and continuation semantics is proved. The proof has been constructed with the help of a generic theorem prover  Isabelle. The major part of the problem lies in establishing the existence of predicates which describe the congruence. This has been solved using Milne's inclusive predicate strategy [5]. The most important intermediate results and the main theorem as derived by Isabelle are quoted in the paper. Keywords: Compiler Correctness, Theorem Prover, Congruence Proof, Denotational Semantics, Lambda Calculus 1 Introduction Much of the work done previously in compiler correctness concerns restricted subsets of imperative languages. Some studies involve machinechecked correctnesse.g. Cohn [1], [2]. A lot of research h...
Abstract Interpretation using Attribute Grammars
 Volume 461 of LNCS
, 1990
"... This paper deals with the correctness proofs of attribute grammars using methods from abstract interpretation. The technique will be described by defining a livevariable analysis for a small flowchart language and proving it correct with respect to a continuation style semantics. The proof techni ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
This paper deals with the correctness proofs of attribute grammars using methods from abstract interpretation. The technique will be described by defining a livevariable analysis for a small flowchart language and proving it correct with respect to a continuation style semantics. The proof technique is based on fixpoint induction and introduces an extended class of attribute grammars as to express a standard semantics. 1
DML  A Metalanguage and System for the Generation of Practical and Efficient Compilers from Denotational Specifications
 In International Conference on Computer Languages
, 1992
"... 1 DML, the Denotational Meta Language, is a specification language and a compiler generation tool for producing practical and efficient compilers from Denotational Semantics specifications. This means that code emitted from generated compilers should be product quality, and that generated compilers ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
1 DML, the Denotational Meta Language, is a specification language and a compiler generation tool for producing practical and efficient compilers from Denotational Semantics specifications. This means that code emitted from generated compilers should be product quality, and that generated compilers should have reasonable compilation speed, and interface well with standard frontends and backends. To achieve this goal, the DML system contains two main contributions compared to previous work in this area: (1) a general algorithm for producing efficient quadruple code from continuation semantics of Algollike languages, and (2) enhancements in the DML specification language with BNF rules for abstract syntax declarations and "semantic brackets" [ ... ] with inline concrete syntax and pattern matching for readable and concise semantic equations. Generated quadruple code is fed into a standard optimizing backend to obtain high quality target code. The DML system generates efficient com...
Abstract Interpretation and Attribute Grammars
, 1991
"... The objective of this thesis is to explore the connections between abstract interpretation and attribute grammars as frameworks in program analysis. Abstract interpretation is a semanticsbased program analysis method. A large class of data flow analysis problems can be expressed as nonstandard sem ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
The objective of this thesis is to explore the connections between abstract interpretation and attribute grammars as frameworks in program analysis. Abstract interpretation is a semanticsbased program analysis method. A large class of data flow analysis problems can be expressed as nonstandard semantics where the “meaning” contains information about the runtime behaviour of programs. In an abstract interpretation the analysis is proved correct by relating it to the usual semantics for the language. Attribute grammars provide a method and notation to specify code generation and program analysis directly from the syntax of the programming language. They are especially used for describing compilation of programming languages and very efficient evaluators have been developed for subclasses of attribute grammars. By relating abstract interpretation and attribute grammars we obtain a closer connection between the specification and implementation of abstract interpretations which at the same time facilitates the correctness proofs of interpretations. Implementation and specification of abstract interpretations using circular attribute grammars is realised with an evaluator system for a class of domain theoretic attribute grammars. In this system thecircularity of attribute grammars is resolved by fixpoint iteration. The use of finite lattices in abstract interpretations requires automatic generation of specialised fixpoint iterators. This is done using a technique called lazy fixpoint iteration which is presented in the thesis. Methods from abstract interpretation can also be used in correctness proofs of attribute grammars. This proof technique introduces a new class of attribute grammars based on domain theory. This method is illustrated with examples.
Modeldriven engineering from modular monadic semantics: Implementation techniques targeting hardware and software
 in Proceedings of the IFIP Working Conference on Domain Specific Languages (DSL09
, 2009
"... Abstract. Recent research has shown how the formal modeling of concurrent systems can benefit from monadic structuring. With this approach, a formal system model is really a program in a domain specific language defined by a monad for sharedstate concurrency. Can these models be compiled into effic ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Recent research has shown how the formal modeling of concurrent systems can benefit from monadic structuring. With this approach, a formal system model is really a program in a domain specific language defined by a monad for sharedstate concurrency. Can these models be compiled into efficient implementations? This paper addresses this question and presents an overview of techniques for compiling monadic concurrency models directly into reasonably efficient software and hardware implementations. The implementation techniques described in this article form the basis of a semanticsdirected approach to modeldriven engineering. 1
Generating an Efficient Compiler for a Data Parallel Language from a Denotational Specification
 In Lecture Notes in Computer Science
, 1994
"... . There are very few examples of the generation of efficient compilers from denotational specifications. Usually such compilers generate code which is orders of magnitude slower than from handwritten ones. However, as has been demonstrated by our DML (Denotational Meta Language) compiler generation ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
. There are very few examples of the generation of efficient compilers from denotational specifications. Usually such compilers generate code which is orders of magnitude slower than from handwritten ones. However, as has been demonstrated by our DML (Denotational Meta Language) compiler generation system, through appropriate singlethreading analysis it is possible to obtain code of comparable quality to handwritten compilers. Another problem with denotational specifications is, because of their denotational nature, the need to introduce complicated power domains to model nondeterminism and parallelism. In this work we have used a more practical twolevel approach: use denotational specifications to model the meaning of the source language in terms of an abstract machine of lowlevel operations, including dataparallel operations. Then use operational semantics for the specification of this abstract machine. This paper reports experience from building a prototype compiler for a sma...