MELT - a Translated Domain Specific Language Embedded in the GCC Compiler

@inproceedings{Starynkevitch2011MELTA,
  title={MELT - a Translated Domain Specific Language Embedded in the GCC Compiler},
  author={Basile Starynkevitch},
  booktitle={DSL},
  year={2011}
}
The GCC free compiler is a very large software, compiling source in several languages for many targets on various systems. It can be extended by plugins, which may take advantage of its power to provide extra specific functionality (warnings, optimizations, source refactoring or navigation) by processing various GCC internal representations (Gimple, Tree, ...). Writing plugins in C is a complex and time-consuming task, but customizing GCC by using an existing scripting language inside is… 

Figures from this paper

Using MELT to improve or explore your GCC-compiled source code

The major features of MELT are shown and it is illustrated why extending and customizing the GCC compiler using M ELT is useful (for instance, to use GPGPUs thru OPENCL).

A New GCC Plugin-Based Compiler Pass to Add Support for Thread-Level Speculation into OpenMP

A plugin-based compiler pass for GCC is developed that augments the original user code with calls to a TLS library that handles the speculative parallel execution of a given loop, with the help of a new OpenMP speculative clause for variable usage classification.

The CSI Framework for Compiler-Inserted Program Instrumentation

A standard API is defined for CSI and modified LLVM to insert CSI hooks into the compiler's internal representation of the program, which allows many compiler-based tools to be written as simple libraries without modifying the compiler, lowering the bar for the development of dynamic-analysis tools.

The CSI Framework for Compiler-Inserted Program Instrumentation

A standard API is defined for CSI and modified LLVM to insert CSI hooks into the compiler's internal representation of the program, which allows many compiler-based tools to be written as simple libraries without modifying the compiler, lowering the bar for the development of dynamic-analysis tools.

A DSL for Resource Checking Using Finite State Automaton-Driven Symbolic Execution

A tool is developed which parses the automaton and generates Clang Static Analyzer checker that can be used in the symbolic execution engine and an example automaton is presented in the authors' domain-specific language to define automata in terms of syntactic and semantic rules.

OKL: A Unified Language for Parallel Architectures

This work was also published as a Rice University thesis/dissertation: http://hdl.handle.net/1911/88213

Compilation optimisée des modèles UML

Une nouvelle approche dirigee par les modeles pour le developpement des systemes a ressources limitees, qui elimine l’etape of the generation of code en remplacant cette etape par une compilation directe des modeles.

Research on Acceleration Data Recovery System Based on the Process of High-Speed Projectile Entering Water Impact

A two-dimensional acceleration measurement combined device system that adopts the disconnection trigger method to effectively avoid the false trigger phenomenon during testing and the polling storage technology of real-time cache solves the problem of partial data loss caused by power outage in a specific water impact environment.

Cognition Enabled IoT Platform for Industrial IoT Safety, Security and Privacy — The CHARIOT Project

An overview of the above technologies as currently being integrated in the CHARIOT project, including an advanced Privacy and security protection building on state of the art Public Key Infrastructure technologies, is provided.

Analyse de sécurité de logiciels système par typage statique. (Security analysis of system code using static typing)

The goal of this thesis is to use static typing to detect the dangerous uses of pointers that are controlled by userspace, and adds to Safespeak the notion of pointers coming from userspace.

References

SHOWING 1-10 OF 37 REFERENCES

A Middle End Lisp Translator for GCC achievements and issues

A Lisp-like dialect has been designed and implemented (as a translator to C) to fit well into the GCC middle-end, and key language features, and improvements are given.

A Compile-Time Infrastructure for GCC Using Haskell

A plugin infrastructure that exposes two compile-time mechanisms that exposes selected portions of the control flow graph and basic block statements of Low GIMPLE, with additional support infrastructure that allows for data-flow analysis of the resultant structure.

Multi-Stage Construction of a Global Static Analyzer

The aim of this work is to provide global (whole program) static analysis, notably based upon abstract interpretation and knowledge based techniques, within the GCC compiler, targeted for analysis of medium sized C, Fortran or C++ programs.

Checking system rules using system-specific, programmer-written compiler extensions

This paper shows how system implementors can use meta-level compilation (MC) to write simple, system-specific compiler extensions that automatically check their code for rule violations and demonstrates the effectiveness of the MC approach by applying it to four complex, real systems.

A portable compiler-integrated approach to permanent checking

  • Eugen-Nicolae Volanschi
  • Computer Science
    21st IEEE/ACM International Conference on Automated Software Engineering (ASE'06)
  • 2006
Factorizing analyses between checking and compiling improves both the efficiency and the expressiveness of the checks, including tight bounds on the acceptable overhead.

A single intermediate language that supports multiple implementations of exceptions

By encapsulating the architecture-dependent mechanisms and their optimization in an implementation of C-- that can be used by compilers for many source languages, this work clarifies the design space of exception-handling techniques, and it allows a single optimizer to handle a variety of implementation techniques.

The essence of compiling with continuations

The combined effect of the three phases is equivalent to a source-to-source transformation that simulates the compaction phase and fully developed CPS compilers do not need to employ the CPS transformation but can achieve the same results with a simple source-level transformation.

Precise and efficient static array bound checking for large embedded C programs

The design and implementation of a static array-bound checker for a family of embedded programs: the flight control software of recent Mars missions, which is the first distributed implementation of static analysis algorithms.

The SSA Representation Framework: Semantics, Analyses and GCC Implementation

This thesis presents a denotational semantics of the SSA language, allowing formal definitions of static analyses on the Ssa language based on the classical abstract interpretation framework, and presents the implementation of the formally described static analyses in an industrial compiler: the GNU Compiler Collection (GCC).

GRAPHITE Two Years After First Lessons Learned From Real-World Polyhedral Compilation

This paper reports on original questions and innovative solutions that arose during the design and implementation of graphite, pioneered by the graphite branch of the GNU Compiler Collection (GCC).