Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
References
All Topics
Languages and Linguistics
Syntax

Compiler generation from relational semantics

Profile image of Mads DamMads Dam

1986, Lecture Notes in Computer Science

Abstract

We consider the problem of automatically deriving correct compilers from relational semantic specifications of programming languages. A relational semantics is an assignment of initial-state final-state relations (defined by means of proof rules) to programs. Compilers are generated 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 replaced 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.

Related papers

A semantics-directed compiler generator
Lawrence Paulson

1982

View PDFchevron_right
Formalizing and verifying semantic type soundness of a simple compiler
Uri Zarfaty

2007

We describe a semantic type soundness result, formalized in the Coq proof assistant, for a compiler from a simple imperative language with heap-allocated data into an idealized assembly language. Types in the high-level language are interpreted as binary relations, built using both second-order quantification and a form of separation structure, over stores and code pointers in the lowlevel machine. Inductive instruction :

View PDFchevron_right
Forth Semantics for Compiler Verification
bill stoddart

2012

Here we are interested in the semantics of Forth from the point of view of using Forth as a target language for a formally verified compiler for Ruth-R, a reversible sequential programming language we are currently developing. We limit out attention to those Forth operations and constructs which will be targetted by the Ruth-R compiler. To facilitate the comparison of meanings of source and target languages, we represent the semantics of Forth code by translation into a form which can be described using the ”prospective value” semantics we use for Ruth-R.

View PDFchevron_right
A constructive approach to compiler correctness
Peter Mosses

Automata, Languages and Programming, 1980

it is suggested that denotetional semantic definitions of programming languages should be based on a small number of abstract data types~ each embodying a fundamental concept of computation. Once these fundamental abstract data types are implemented in a particular target language (e.g. stack-machine code)~ it is a simple matter to construct a correct compi let for any source tanguege from its denotational semantic definition, The approach is illustrated by constructing a compiler equivalent to the one which was proved correct by Thatcher~ Wagner & Wright (1979),

View PDFchevron_right
Towards Provably Correct Code Generation via Horn Logical Continuation Semantics
Gopal Gupta

Lecture Notes in Computer Science, 2005

Provably correct compilation is an important aspect in development of high assurance software systems. In this paper we explore approaches to provably correct code generation based on programming language semantics, particularly Horn logical semantics, and partial evaluation. We show that the definite clause grammar (DCG) notation can be used for specifying both the syntax and semantics of imperative languages. We next show that continuation semantics can also be expressed in the Horn logical framework.

View PDFchevron_right
Formalizing and Verifying Semantic Type Soundness of a Simple Compiler (Preliminary Report
Uri Zarfaty

2007

We describe a semantic type soundness result, formalized in the Coq proof assistant, for a compiler from a simple imperative language with heap-allocated data into an idealized assembly language. Types in the high-level language are interpreted as binary relations, built using both second-order quantification and a form of separation structure, over stores and code pointers in the low-level machine.

View PDFchevron_right
Towards an algebraic specification of code generation
Herbert Ehler

Science of Computer Programming, 1988

We show how the problem of code generation for a simple language can be treated fully algebraically. The algebraic approach enjoys several advantages which should be demonstrated here. First, it allows a uniform specification both of the abstract syntax and of the semantics of the source and the target language on one side and of the code generation on the other side by means of hierarchical abstract data types. Moreover, theorems about the compiler, such as the preservation of the semantics, can be proved by induction on the term structure of the abstract syntax. Furthermore, existing tools for rapid prototyping with abstract data types can be applied to validate the specification against the intention in an early stage. In addition, this paper shows how such a system can also be used for performing induction proofs of conjectures.

View PDFchevron_right
Proving Correctness of a Compiler Using Step-indexed Logical Relations
Leonardo Gil Rodríguez

Electr. Notes Theor. Comput. Sci., 2015

In this paper we prove the correctness of a compiler for a call-by-name language using step-indexed logical relations and biorthogonality. The source language is an extension of the simply typed lambda-calculus with recursion, and the target language is an extension of the Krivine abstract machine. We formalized the proof in the Coq proof assistant.

View PDFchevron_right
Simple relational correctness proofs for static analyses and program transformations
Nick Benton

Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '04, 2004

We show how some classical static analyses for imperative programs, and the optimizing transformations which they enable, may be expressed and proved correct using elementary logical and denotational techniques. The key ingredients are an interpretation of program properties as relations, rather than predicates, and a realization that although many program analyses are traditionally formulated in very intensional terms, the associated transformations are actually enabled by more liberal extensional properties.

View PDFchevron_right
Specification, Verification and Prototyping of An Optimized Compiler
Jonathan Bowen

Formal Aspects of Computing, 1994

This paper generalizes an algebraic method for the design of a correct compiler to tackle speci fication and veri fication of an optimized compiler. The main optimization issues of concern here include the use of existing contents of registers where possible and the identi fication of common expressions. A register table is introduced in the compiling speci fication predicates to map each register to an expression whose value is held by it. We defi ne di fferent kinds of predicates to specify compilation of programs, expressions and Boolean tests. A set of theorems relating to these predicates, acting as a correct compiling speci fication, are presented and an example proof within the re finement algebra of the programming language is given. Based on these theorems, a prototype compiler in Prolog is produced. Keywords: Program compilation; Code optimization; Formal veri cation; Refinement algebra; Logic programming

View PDFchevron_right

References (22)

  1. J.A. Goguen, J.W. Thatcher, E.G. Wagner: An Initial Algebra Approach to the Speci- fication, Correctness, and Implementation of Abstract Data Types. In: Current Trends in Programming Methodology, Vol. IV, R.T. Yeh (editor), Prentice-Hall 1978.
  2. D. Bj~rner: Formal Development of Interpre- ters and Compilers, DtH ID673, 1977.
  3. J.W. De Bakker, W.P. De Roever: A Calcu- lus for Recursive Program Schemes° In: Automata, Languages, Programming, Nivat (editor), North-Holland, Amsterdam 1972.
  4. H. Ganzinger: Transforming Denotational Semantics into practical Attribute Gram- mars. In: Semantics-Directed Compiler Ge- neration, LNCS 94, N.D. Jones (editor), 1980.
  5. M.J.C. Gordon: The Denotational Descrip- tion of Programming Languages -An Intro- duction, Springer-Verlag 1979.
  6. I.Greif, A.R. Meyer: Specifying the Se- mantics of while Programs: A Tutorial and Critique of a Paper by Hoare and Lauer, ACM Transactions on Programming Languages and Systems, Vol. 3, No. 4, Oct. 1981.
  7. C.A.R. Hoare, P.E. Lauer: Consistent and Complementary Formal Theories of the Se- mantics of Programming Languages, Acta Informatica 3, 1974. [Jensen/Dam 85]
  8. Fo Jensen, M. Dam: Automatisk generering af overs~ttere udfra operationelt seman- tiske definitioner af programmeringssprog, M.Sc. Thesis (in danish), Aalborg Univer- sity Centre, 1985. [Jones/Chris- tiansen 81]
  9. N.D. Jones, H. Christiansen: Control Flow Treatment in a Simple Semantics-Directed Compiler Generator, DAIMI PB-137, sept. 1981.
  10. Jones/Schmidt 80] N.D. Jones, D.A. Schmidt: Compiler Gene- ration from Denotational Semantics. In: Semantics-Directed Compiler Generation, LNCS 94, N.D. Jones (editor), 1980.
  11. R. Kowalski: Predicate Logic as Program- ming Language. In: Information Processing 74, North-Holland 1974.
  12. Milne/Strachey 76] R. Milne, C. Strachey: A Theory of Pro- gramming Language Semantics, Chapman and Hall, 1976.
  13. F.L. Morris: Advice on Structuring Compi- lers and Proving Them Correct, Proc. 2nd ACM Symp. on Principles of Prog. Lan., 1973.
  14. P. Mosses: SIS-Semantics Implementation System, Reference Manual and User's Guide, DAIMI MD-30, 1979.
  15. P. Mosses: A Constructive Approach to Com- piler Correctness. In: Semantics-Directed Compiler Generation, LNCS 94, N.D. Jones (editor), 1980.
  16. H.R. Nielson: Hoare Logic's for Run-time Analysis of Programs, Ph.D. Thesis, Uni- versity of Edinburgh, oct. 1984. [Nielson/ Nielson 85] [Plotkin 81] [ Schmidt 85] [Sethi 83] [Stoy 77]
  17. F. Nielson, H.R. Nielson: Pragmatic Aspects of Two-Level Denotational Meta-Languages, AUC R-85-13°
  18. G.D. Plotkin: A Structural Approach to Operational Semantics, DAIMI FN-19, sept. 1981.
  19. D.A. Schmidt: Detecting Global Variables in Denotational Specifications, ACM Trans- actions on Programming Languages and Sys- tems, Vol. 7, No. 2, april 1985.
  20. R. Sethi: Control-Flow Aspects of Seman- tics-Directed Compiling, ACM Transactions on Programming Languages and Systems, Vol. 5, No. 4, oct. 1983.
  21. J.E. Stoy: Denotational Semantics: The Scott-Strachey Approach to Programming Lan- guage Theory, MIT Press, 1977.
  22. M. Wand: Deriving Target Code as a Repre- sentation of Continuation Semantics, ACM Transactions on Programming Languages and Systems, Voi. 4, No. 3, july 1982.

Related papers

Formal compiler construction in a logical framework
Jason Hickey

Higher-Order and Symbolic Computation, 2006

The task of designing and implementing a compiler can be a difficult and error-prone process. In this paper, we present a new approach based on the use of higher-order abstract syntax and term rewriting in a logical framework. All program transformations, from parsing to code generation, are cleanly isolated and specified as term rewrites. This has several advantages. The correctness of the compiler depends solely on a small set of rewrite rules that are written in the language of formal mathematics. In addition, the logical framework guarantees the preservation of scoping, and it automates many frequently-occurring tasks including substitution and rewriting strategies. As we show, compiler development in a logical framework can be easier than in a general-purpose language like ML, in part because of automation, and also because the framework provides extensive support for examination, validation, and debugging of the compiler transformations. The paper is organized around a case study, using the MetaPRL logical framework to compile an ML-like language to Intel x86 assembly. We also present a scoped formalization of x86 assembly in which all registers are immutable.

View PDFchevron_right
Formal Compiler Implementation in a Logical Framework
Adam Granicz

2003

The task of designing and implementing a compiler can be a difficult and error-prone process. In this paper, we present a new approach based on the use of higher-order abstract syntax and term rewriting in a logical framework. All program transformations, from parsing to code generation, are cleanly isolated and specified as term rewrites. This has several advantages. The correctness of the compiler depends solely on a small set of rewrite rules that are written in the language of formal mathematics. In addition, the logical framework guarantees the preservation of scoping, and it automates many frequently-occurring tasks including substitution and rewriting strategies. As we show, compiler development in a logical framework can be easier than in a general-purpose language like ML, in part because of automation, and also because the framework provides extensive support for examination, validation, and debugging of the compiler transformations. The paper is organized around a case st...

View PDFchevron_right
Deriving Compilers from Monadic Semantics
Samuel Kamin

The monadic style of language specification [6, 16, 15, 26] has the advantages of modularity and extensibility: it is simple to add or change features in an interpreter to reflect modifications in the source language. It has proven difficult to extend the method to compilation, because there is considerable interaction between different features. We demonstrate that by introducing machine-like stores (code and data) into the monadic semantics (to achieve pass separation [12]) and then partially evaluating the resulting semantic expressions, we can achieve many of the same advantages for a compiler as for an interpreter. A number of language constructs and features are compiled: expressions, while loops, CBV and CBN evaluation of -expressions, dynamic scoping, and various imperative features. The treatment of recursive procedures is outlined as well. The resulting method allows compilers to be constructed in a mix-and-match fashion just as in a monad-structured interpreter. K...

View PDFchevron_right
Compiler implementation in a formal logical framework
Adam Granicz

Proceedings of the 2003 workshop on Mechanized reasoning about languages with variable binding - MERLIN '03, 2003

The task of designing and implementing a compiler can be a difficult and error-prone process. In this paper, we present a new approach based on the use of higher-order abstract syntax and term rewriting in a logical framework. All program transformations, from parsing to code generation, are cleanly isolated and specified as term rewrites. This has several advantages. The correctness of the compiler depends solely on a small set of rewrite rules that are written in the language of formal mathematics. In addition, the logical framework guarantees the preservation of scoping, and it automates many frequently-occurring tasks including substitution and rewriting strategies. As we show, compiler development in a logical framework can be easier than in a general-purpose language like ML, in part because of automation, and also because the framework provides extensive support for examination, validation, and debugging of the compiler transformations. The paper is organized around a case study, using the MetaPRL logical framework to compile an ML-like language to Intel x86 assembly. We also present a scoped formalization of x86 assembly in which all registers are immutable.

View PDFchevron_right
π: Towards a Simple Formal Semantic Framework for Compiler Construction
Christiano Braga

2018

This paper proposes π, a formal semantic framework for compiler construction together with program validation. π is comprised by π Lib, a set of programming languages constructs inspired by Peter Mosses' Component-Based Semantics and π Automata, an automata-based formalism to describe the operational semantics of programming languages, that generalizes Gordon Plotkin's Interpreting Automata.

View PDFchevron_right

Related topics

  • Computer Science
  • Syntax
  • Semantics (Computer Science)
  • Code Generation
  • Abstract Syntax Tree
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved