This is the mail archive of the mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Ann: MELT 1.0 plugin for GCC 4.7 & 4.8

Dear All,

It is my pleasure and honour to announce the MELT 1.0 plugin for GCC 4.7
& 4.8, a GPLv3+ licensed free software and FSF copyrighted plugin for
the GCC compiler

MELT is a Lispy like domain specific language to extend GCC. See ; you'll be able to extend or customize the GCC
compiler in MELT easier than you would code C++ plugin, thanks to the
high-level features of MELT: pattern matching, functional, reflexive,
object-oriented programming styles with meta-programming facilities.
MELT is translated to C++ code (by a translator itself coded in MELT). 
You can mix C++ code inside MELT.

MELT can also be used to explore the GCC (mostly middle-end) internal
representations notably Gimple-s and Tree-s. With MELT you can for
example, with a few arguments to gcc, find all calls to malloc with a
constant size greater than 100 (and you need to do that *inside* the
compiler, because that size could be constant folded and using sizeof

Please download the MELT 1.0 plugin source bzipped tarball from
a file of md5sum fe07c9204e31c3a61931181737903d7e; it is extracted from
MELT branch svn 204149 on october 29th 2013. 

MELT 1.0 is a major release bringing many improvements over previous
releases of MELT. Detailed news follow:

NEWS for 1.0 MELT plugin for GCC 4.7 & 4.8 [and future 4.9?]
[[october 29th, 2013]]

This is a major release (with perhaps some small incompatibilities
with previous MELT plugin releases). A lot of new features are
appearing. Much more ability to mix arbitrary C/C++ & MELT code in any
way, and lots of new features both inside the MELT language and the
MELT plugin, even for newbies. Some modes are now available and could
be useful even without understanding much of the MELT domain specific

MELT 1.0 is usable with GCC 4.7 and 4.8 but not usable with GCC 4.6 or
earlier, because it requires a GCC compiler written in C++ and because
it is generating C++ code.

   End-user improvements

 * Several MELT modes are usable without real knowledge of the MELT
   domain specific language, notably -fplugin-arg-melt-mode=findgimple
   (to find all gimples matching some given gimple pattern in all
   functions whose declaration matches a given tree pattern) and
   -fplugin-arg-melt-mode=justcountipa (to count gimples and basic
   blocks at the Inter-Procedural Analysis stage).

   Several examples of MELT modes are given in

   It is notably possible to 

     + find all calls to malloc with a constant size greater than 100
       that size could have been given thru sizeof and/or some
       constant expressions...

     + find all calls to printf with a format string containing the
       word current and more than 6 arguments inside functions whose
       name start with foo

     + etc....

   These exploring modes have to work inside the compiler. A textual
   approach won't work. So these exploring modes should interest a
   large number of GCC users.

 * When verbose, all the successful modes are displayed.

   Language improvements

 * It is possible to define macros with defmacro (taking four
  arguments: the s-expression to be macro-expanded, the environment,
  the macro-expander function, the module context). Such macros can be
  used in the same MELT module defining them, but should expand to a 
  source AST which you would be able to read...

 * It is possible to define locally bound macros with the :macro
 in let bindings.

 * at_macro_expansion macro can be used to define functions (and
  instances, etc...) used only at macro-expansion time of further
  defmacro-defined macros.

 * Macros defined by defmacro and definition given inside
 are evaluated in a separate environment so don't see the ordinary
 currently defined in the MELT source.

 * The comma operator, only usefine inside anti-quotations (thru
  backquote) is expanded to a sequence of sub-expressions if the
  anti-quotation gives a sequence, i.e. a tuple or a list. So no
  comma-at operator is needed.

 * quotes, anti-quotes (with backquote), and comma operators are
 possible even on arbitrary s-expressions. But quotations and
 antiquotations of s-exprs have their location slightly less precise
 (only file name and line number, but not column number, are

   Runtime improvements

  * The debug macro accepts debug manipulator which alters the way
   the next argument is debug-printed, e.g. 
       (DEBUG "here smaller debug of x=" DEBUG_LESS x)

  * The variadic ERROR_AT WARNING_AT and INFORM_AT functions are
  for diagnostics. They take a format string with occurrences of $1 ...
  expanded into variadic arguments. For example
       (ERRROR_AT somelocation "this is an error with number $1 and tree
                  somenumber sometree)
  The location can be null, or be given by some boxed gimple or boxed

  * The ASSERT_MSG macro can have more arguments, which are shown
  when the assertion fails.

  * MELT registered passes have a unique number (for GCC 4.9).

  * The runtime is named since it is C++ code. 

  * MELT generated frames are classy because they are C++ classes.

 As usual, many bug fixes... A ticket system is now available on for bug reports.


Respectful regards.
email: basile<at>starynkevitch<dot>net mobile: +33 6 8501 2359
8, rue de la Faiencerie, 92340 Bourg La Reine, France
*** opinions {are only mine, sont seulement les miennes} ***

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]