GCC MELT
starynkevitch.net/Basile/gcc-melt
These [old] web pages are mostly available on starynkevitch.net/Basile/gcc-melt/ which is the prefered URL.

Overview

GCC MELT is a high-level domain specific language for extending or customizing the Gnu Compiler Collection (i.e. gcc, g++, gfortran, gnat, gccgo, gobjc, ...). It is implemented as a GCC plugin (for GNU/Linux systems, with GCC 4.7, 4.8 or later) in a free software (under GPLv3+ license and FSF copyright).
GCC MELT targets advanced GCC users developing, compiling, improving, evaluating, maintaining, or designing important software (coded in C, C++, Fortran, Ada, Go, Objective C or any language supported by a recent straight- or cross- GCC compiler). For such power users, spending a few days or weeks to customize or extend their compiler for their specific needs is worthwhile, and GCC MELT should lower the required effort, because coding in MELT a GCC extension is much easier than manually developping a GCC plugin in C or C++ (these are efficient languages, but not well fit to easily work on compiler's internal representations).

GCC MELT (since MELT 1.0) can also be used to explore the internal representations of the GCC compiler when it is working on your files, see here. For example, you could find all calls to malloc with a constant size greater than 48 bytes, or all assignments to some next fields of struct-ure whose name contains point (and such searches are not possible with textual tools like grep; they have to be made at the Gimple level inside the compiler).

GCC MELT (that is, your daily GCC [cross-] compiler augmented with the MELT [meta-] plugin and your own extensions) could be the foundational block of some Industry Specific Software Development Kit for e.g. embedded, GUI, or low-level software. Please contact us for more information.

GCC MELT uses existing GCC plugin hooks to work on GCC internal middle-end representations, notably GCC Generic Trees and GCC Gimples, and the control flow graph. These powerful internal representations are common to all source languages accepted by GCC, so your extension coded in MELT will be able to handle any source code compiled by GCC.

Probably, GCC MELT won't be very useful to casual GCC users working on tiny programming projects, unless they simply use some existing GCC extensions already developed with GCC MELT.

Why customize or extend GCC?

The GCC compiler can be customized or extended (with plugins or MELT extensions) for:

• specific warnings, e.g. for typing your variadic functions (like json_pack in Jansson library, or g_object_set in GTK toolkit), or checking some properties at every call of some given function;
• specific coding rules validation (e.g. requiring that pthread_mutex_lock and pthread_mutex_unlock are balanced in the same function, or that every fopen gets its resulted tested);
• metrics on the GCC internal representations;
• help on code refactoring or source code navigation;
• adding new (application- specific) builtins or attributes to the compiler;
• (application- or corporation-) specific optimizations (e.g. fprintf(stdout,format,...) → printf(format,...), etc.);
• etc....

From the GCC user's point of view, a customization of GCC is easier to use than external tools. He/She needs only to add extra compilation flags (.e.g. CFLAGS += -fplugin=melt -fplugin-arg-melt-extra=extension -fplugin-arg-melt-mode=mode in a Makefile), but don't need to change workflow habits.

How MELT helps to extend GCC?

MELT is a domain-specific language specifically designed to ease the extension (or customization) of GCC because of the following features:

• strong connection with existing GCC internals using available plugin machinery: new GCC passes, attributes, builtins, ... can be implemented in MELT
• simple, orthogonal, Lisp-like syntax
• efficient garbage collection (compatible with GCC implementation), using state of the art generational copying GC techniques.
• dynamically typed first-class values (including lists, tuples, closures, objects in a rich single-inheritance meta-class based system with dynamic message dispatching, homogenous hash-tables, boxed integers and boxed GCC data -Gimples, Trees, ..., etc)
• handle natively any arbitrary GCC data stuff (e.g. tree-s, gimple-s, edge-s, loop-s in a statically typed manner
• anonymous functions (and named ones) and a rich object system enabling functional, object, reflective programming style
• very powerful pattern-matching, notably on GCC internal stuff like tree-s and gimple-s etc.
• dynamic run-time evaluation and read-eval-print-loop
• dynamically translated to C or C++ code (compiled and dynamically loaded at runtime thru dlopen)
• ability to mix your small chunks of C code with your main code in MELT
• bootstrapped implementation: The MELT → C translator is implemented in MELT

The above powerful features of MELT lower the cost of customizing GCC, hence enabling you to leverage on GCC powerful abilities with GCC MELT. However, even using MELT you need to understand some of GCC internals.

The emitted C or C++ code is carefully generated to fit into what your GCC plugin interface expects (GCC switched from C to C++ in its 4.7 version, and GCC MELT is careful to generate a code acceptable by your version of GCC).

A practical way to understand more on main GCC internal representations is to have a relevant (small) source code (e.g. in C, C++, Fortran, or Ada, etc), then compile it with the -fdump-tree-all.

For instance (assuming you have some example.cc in some playground directory) compile with g++ -fdump-tree-all -O -c example.cc. This produce hundreds of dump files, such as perhaps example.cc.073t.phiopt1 which might contain (like dump files suffixed .phiopt*) a dump of Gimple/SSA (Static Single Assignment) statements, that you can browse using an editor or pager (e.g. less example.cc.073t.phiopt1 or gedit example.cc.073t.phiopt1).

---

Download and install GCC MELT

Documentation

Contribute to GCC MELT (and related tools)

See also archive of the old inactive GCC MELT google-group.

---

The old page on GCC MELT is available here.