Functional Programming Languages and Computer Architecture

New machine architectures and new programming languages are always appearing, and thus the need for new compilers continues unabated. Even experimental languages and machines need compilers. Compiler writers developing new and/or experimental compilers face competing pressures when designing their large-scale structure. On the one hand, a more modular structure will make it easier to maintain, modify or reuse pieces of the compiler. A more modular compiler is more likely to be correct, and reusable compiler components lead to consistent semantics among the compilers using them. On the other hand, a highly modular structure may lead to inefficiencies in implementation. Suppose one uses an intermediate representation and divides up the compiler into two parts, one which compiles the source to the intermediate representation and another which translates a program in the intermediate representation to the target machine language. Doing so may make the compiler easier to understand, and furthermore, a well-chosen intermediate representation may prove a suitable target for other source languages, or a suitable source for translating to other machines. On the other hand, the need to create and then traverse this intermediate representation may slow a compiler significantly. If the two parts are described in a high-level declarative formalism, descriptional composition can be used to combine the two parts automatically so as to avoid creating and traversing the intermediate structure. This dissertation presents a declarative compiler description language, APS, and a new method for descriptional composition. The language, based on a variant of attribute grammars, contains a number of features that aid compiler writers in factoring descriptions so that each concept can be expressed separately. Both a compiler for Oberon2 and a front-end for APS itself have been written in APS. The back-end of the Oberon2 compiler consists of a translation to a form of the ``GCC tree'''' intermediate representation. Another module gives the translation from this form to source-level C text. A prototype compiler has been developed for APS that supports descriptional composition. The descriptionally composed version of the Oberon2 back-end with the translation to C text is no larger than the sum of the sizes of the modules from which it is composed, yet it runs almost twice as fast. The Oberon2 compiler is the first successful use of descriptional composition for a realistically complex system, and demonstrates the effectiveness of combining the new APS description language and the new algorithm for descriptional composition presented in this dissertation.

/pdf/descriptional-composition-of-compiler-components-5241ndw3ja.pdf

Descriptional Composition of Compiler Components

We propose a simple order-theoretic generalization, possibly non-monotone, of set-theoretic inductive definitions. This generalization covers inductive, co-inductive and bi-inductive definitions and is preserved by abstraction. This allows structural operational semantics to describe simultaneously the finite terminating and infinite diverging behaviors of programs. This is illustrated on grammars and the structural bifinitary small big-step trace relational operational semantics of the call-by-value @l-calculus (for which co-induction is shown to be inadequate).

/pdf/bi-inductive-structural-semantics-4eru4f63lm.pdf

Bi-inductive structural semantics

We present an algebraic method for modeling microprocessors at different levels of abstraction, and for expressing the relationships between each level. We consider microprocessors at levels of abstraction determined by time and details of construction. The algebraic models isolate features of the scientific structure of microprocessor computation, providing: (i) a basis for modular decomposition of the description of microprocessors, including correctness criteria; and (ii) equational specification and verification techniques for the design of microprocessors relevant to a range of specification languages and theorem provers. Our specifications are iterated maps that decompose the modeling of the computer into easily understood, equationally specified stages, represented by algebras. We illustrate our algebraic tools with an example of a simple computer.

Algebraic models of microprocessors architecture and organisation

In this thesis we study the use of semantics-based formal methods in the specification and proof of correctness of compilers and debuggers. We use a Structural Operational Semantics as the basis for the specification of compilers and propose a notion of correctness based on an observational equivalence relation. We define program evaluation and a notion of evaluation step based on a Structural Operational Semantics and use these definitions as the basis for the specification of debuggers. Debugger correctness is then defined by an equivalence relation between a specification and an implementation of the debugger based on the bisimulation concept. The main results of this thesis are: a definition of a variant of Structural Operational Semantics, called Relational Semantics, which is the underlying formalism of this thesis; the definition of a notion of Observational Equivalence between Relational Semantics Specifications; a formulation of the problem of compiler correctness using Observational Equivalence; an evaluation model for programming languages and a definition of an evaluation step; an abstract definition of Interpreter-debuggers; a specification notation for the formal specification of debuggers, called DSL; a notion of equivalence between debuggers using bisimulation; a study on Compiler-debuggers and the problems involved in their definition. These results form a theory for the formal specification and proofs of correctness of compilers and debuggers. Our starting point is that the use of this theory helps in building better compilers and debuggers. It is our goal to provide theoretical foundations and tools to show that our methods are achievable.

Correctness proofs of compilers and debuggers : an approach based on structural operational semantics

Natural Semantics is a logical formalism used to specify semantic aspects of a language by sets of logical rules (called a Typol program) where a query is proved using Prolog. In a previous paper, we have shown how to replace, under certain hypotheses, the Prolog engine by a functional evaluator; this is possible because unification is no longer required and can be replaced by pattern matching. Starting from this previous work, we now add incremental facilities to our evaluator. That is to say, after some modification of a term whose semantic value has already been evaluated, we do not need to re-evaluate everything from scratch as it is the case with a Prolog engine.

Incremental Evaluation of Natural Semantics Specification

Typol is a language to implement natural semantics inside the Centaur programming environment. We explain why natural semantics can be considered as a generalization of the attribute grammars formalism. This relationship suggests introducing in the Typol setting some concepts from the attribute grammars framework. With these concepts, we can provide specialized evaluators to some classes of Typol programs, instead of the general Prolog machine currently used to execute such programs. More precisely, we prove that under acceptable conditions, the unification process is no longer required and can be replaced by a simple pattern-matching mechanism. From this proof method, we deduce a functional implementation of Typol programs. We also propose a language construct called CondMatch, that makes it easier to automatically translate a Typol program into a Lisp function.

https://hal.inria.fr/inria-00075340/document

Functional evaluation of natural semantics specifications

We show how to prove formulas of the form ∀ x∃ yΦ(x, y) in the initial model of an equational variety by using purely algebraic simplifications. This allows to tackle theorems whose proofs requires complicated noetherian induction. We also give a disproof theorem, which is not only useful to prove that a conjecture is false but is also used to shorten the proof search of a theorem. We show applications of the method to fragments of arithmetic.

Mechanizable inductive proofs for a class of ∀ ∃ formulas

Typol is a language to implement Natural Semantics inside the Centaur Programming Environment. We explain why Natural Semantics can be considered as a generalization of the Attribute Grammars formalism. This relationship suggests introducing in the Typol setting some concepts from the Attribute Grammars framework. With these concepts, we can provide specialized evaluators to some classes of Typol programs, instead of the general Prolog machine currently used to execute such programs. More precisely, we prove that under acceptable conditions, the unification process is no longer required and can be replaced by a simple pattern-matching mechanism. This makes it possible to give a functional implementation of Typol programs.

Functional evaluation of strongly noncircular typol specifications

Mechanizable Inductive Proofs for a Class of Forall Exists Formulas

Popular Tasks used by Researchers

How can I help with your research?

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

We encountered an error while loading the panel. Please try refreshing the page.

Something went wrong

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

Anyone with the link can view this chat. You can switch it back to private anytime.

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Jacques Chazarain

Author Tools

Chat about Author