mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-31 10:34:17 +00:00
Remove all references to plugins from the LLVMC docs.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@130090 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Mikhail Glushenkov
parent
685501836b
commit
834b93b51d
@ -18,17 +18,16 @@ Introduction
|
||||
============
|
||||
|
||||
LLVMC is a generic compiler driver, designed to be customizable and
|
||||
extensible. It plays the same role for LLVM as the ``gcc`` program
|
||||
does for GCC - LLVMC's job is essentially to transform a set of input
|
||||
files into a set of targets depending on configuration rules and user
|
||||
options. What makes LLVMC different is that these transformation rules
|
||||
are completely customizable - in fact, LLVMC knows nothing about the
|
||||
specifics of transformation (even the command-line options are mostly
|
||||
not hard-coded) and regards the transformation structure as an
|
||||
abstract graph. The structure of this graph is completely determined
|
||||
by plugins, which can be either statically or dynamically linked. This
|
||||
makes it possible to easily adapt LLVMC for other purposes - for
|
||||
example, as a build tool for game resources.
|
||||
extensible. It plays the same role for LLVM as the ``gcc`` program does for
|
||||
GCC - LLVMC's job is essentially to transform a set of input files into a set of
|
||||
targets depending on configuration rules and user options. What makes LLVMC
|
||||
different is that these transformation rules are completely customizable - in
|
||||
fact, LLVMC knows nothing about the specifics of transformation (even the
|
||||
command-line options are mostly not hard-coded) and regards the transformation
|
||||
structure as an abstract graph. The structure of this graph is described in
|
||||
high-level TableGen code, from which an efficient C++ representation is
|
||||
automatically derived. This makes it possible to adapt LLVMC for other
|
||||
purposes - for example, as a build tool for game resources.
|
||||
|
||||
Because LLVMC employs TableGen_ as its configuration language, you
|
||||
need to be familiar with it to customize LLVMC.
|
||||
@ -36,8 +35,8 @@ need to be familiar with it to customize LLVMC.
|
||||
.. _TableGen: http://llvm.org/docs/TableGenFundamentals.html
|
||||
|
||||
|
||||
Compiling with LLVMC
|
||||
====================
|
||||
Compiling with ``llvmc``
|
||||
========================
|
||||
|
||||
LLVMC tries hard to be as compatible with ``gcc`` as possible,
|
||||
although there are some small differences. Most of the time, however,
|
||||
@ -78,17 +77,13 @@ possible to choose the ``clang`` compiler with the ``-clang`` option.
|
||||
Predefined options
|
||||
==================
|
||||
|
||||
LLVMC has some built-in options that can't be overridden in the
|
||||
configuration libraries:
|
||||
LLVMC has some built-in options that can't be overridden in the TableGen code:
|
||||
|
||||
* ``-o FILE`` - Output file name.
|
||||
|
||||
* ``-x LANGUAGE`` - Specify the language of the following input files
|
||||
until the next -x option.
|
||||
|
||||
* ``-load PLUGIN_NAME`` - Load the specified plugin DLL. Example:
|
||||
``-load $LLVM_DIR/Release/lib/LLVMCSimple.so``.
|
||||
|
||||
* ``-v`` - Enable verbose mode, i.e. print out all executed commands.
|
||||
|
||||
* ``--save-temps`` - Write temporary files to the current directory and do not
|
||||
@ -103,124 +98,90 @@ configuration libraries:
|
||||
precedence.
|
||||
|
||||
* ``--check-graph`` - Check the compilation for common errors like mismatched
|
||||
output/input language names, multiple default edges and cycles. Because of
|
||||
plugins, these checks can't be performed at compile-time. Exit with code zero
|
||||
if no errors were found, and return the number of found errors
|
||||
otherwise. Hidden option, useful for debugging LLVMC plugins.
|
||||
output/input language names, multiple default edges and cycles. Exit with code
|
||||
zero if no errors were found, and return the number of found errors
|
||||
otherwise. Hidden option, useful for debugging.
|
||||
|
||||
* ``--view-graph`` - Show a graphical representation of the compilation graph
|
||||
and exit. Requires that you have ``dot`` and ``gv`` programs installed. Hidden
|
||||
option, useful for debugging LLVMC plugins.
|
||||
option, useful for debugging.
|
||||
|
||||
* ``--write-graph`` - Write a ``compilation-graph.dot`` file in the current
|
||||
directory with the compilation graph description in Graphviz format (identical
|
||||
to the file used by the ``--view-graph`` option). The ``-o`` option can be
|
||||
used to set the output file name. Hidden option, useful for debugging LLVMC
|
||||
plugins.
|
||||
used to set the output file name. Hidden option, useful for debugging.
|
||||
|
||||
* ``--help``, ``--help-hidden``, ``--version`` - These options have
|
||||
their standard meaning.
|
||||
|
||||
Compiling LLVMC plugins
|
||||
=======================
|
||||
Compiling LLVMC-based drivers
|
||||
=============================
|
||||
|
||||
It's easiest to start working on your own LLVMC plugin by copying the
|
||||
skeleton project which lives under ``$LLVMC_DIR/plugins/Simple``::
|
||||
It's easiest to start working on your own LLVMC driver by copying the skeleton
|
||||
project which lives under ``$LLVMC_DIR/examples/Skeleton``::
|
||||
|
||||
$ cd $LLVMC_DIR/plugins
|
||||
$ cp -r Simple MyPlugin
|
||||
$ cd MyPlugin
|
||||
$ cd $LLVMC_DIR/examples
|
||||
$ cp -r Skeleton MyDriver
|
||||
$ cd MyDriver
|
||||
$ ls
|
||||
Makefile PluginMain.cpp Simple.td
|
||||
AutoGenerated.td Hooks.cpp Main.cpp Makefile
|
||||
|
||||
As you can see, our basic plugin consists of only two files (not
|
||||
counting the build script). ``Simple.td`` contains TableGen
|
||||
description of the compilation graph; its format is documented in the
|
||||
following sections. ``PluginMain.cpp`` is just a helper file used to
|
||||
compile the auto-generated C++ code produced from TableGen source. It
|
||||
can also contain hook definitions (see `below`__).
|
||||
As you can see, our basic driver consists of only three files (not counting the
|
||||
build script). ``AutoGenerated.td`` contains TableGen description of the
|
||||
compilation graph; its format is documented in the following
|
||||
sections. ``Hooks.cpp`` is an empty file that should be used for hook
|
||||
definitions (see `below`__). ``Main.cpp`` is just a helper used to compile the
|
||||
auto-generated C++ code produced from TableGen source.
|
||||
|
||||
__ hooks_
|
||||
|
||||
The first thing that you should do is to change the ``LLVMC_PLUGIN``
|
||||
variable in the ``Makefile`` to avoid conflicts (since this variable
|
||||
is used to name the resulting library)::
|
||||
The first thing that you should do is to change the ``LLVMC_BASED_DRIVER``
|
||||
variable in the ``Makefile``::
|
||||
|
||||
LLVMC_PLUGIN=MyPlugin
|
||||
LLVMC_BASED_DRIVER=MyDriver
|
||||
|
||||
It is also a good idea to rename ``Simple.td`` to something less
|
||||
generic::
|
||||
It can also be a good idea to put your TableGen code into a file with a less
|
||||
generic name::
|
||||
|
||||
$ mv Simple.td MyPlugin.td
|
||||
$ touch MyDriver.td
|
||||
$ vim AutoGenerated.td
|
||||
[...]
|
||||
include "MyDriver.td"
|
||||
|
||||
To build your plugin as a dynamic library, just ``cd`` to its source
|
||||
directory and run ``make``. The resulting file will be called
|
||||
``plugin_llvmc_$(LLVMC_PLUGIN).$(DLL_EXTENSION)`` (in our case,
|
||||
``plugin_llvmc_MyPlugin.so``). This library can be then loaded in with the
|
||||
``-load`` option. Example::
|
||||
If you have more than one TableGen source file, they all should be included from
|
||||
``AutoGenerated.td``, since this file is used by the build system to generate
|
||||
C++ code.
|
||||
|
||||
$ cd $LLVMC_DIR/plugins/Simple
|
||||
$ make
|
||||
$ llvmc -load $LLVM_DIR/Release/lib/plugin_llvmc_Simple.so
|
||||
|
||||
Compiling standalone LLVMC-based drivers
|
||||
========================================
|
||||
|
||||
By default, the ``llvmc`` executable consists of a driver core plus several
|
||||
statically linked plugins (``Base`` and ``Clang`` at the moment). You can
|
||||
produce a standalone LLVMC-based driver executable by linking the core with your
|
||||
own plugins. The recommended way to do this is by starting with the provided
|
||||
``Skeleton`` example (``$LLVMC_DIR/example/Skeleton``)::
|
||||
|
||||
$ cd $LLVMC_DIR/example/
|
||||
$ cp -r Skeleton mydriver
|
||||
$ cd mydriver
|
||||
$ vim Makefile
|
||||
[...]
|
||||
$ make
|
||||
To build your driver, just ``cd`` to its source directory and run ``make``. The
|
||||
resulting executable will be put into ``$LLVM_OBJ_DIR/$(BuildMode)/bin``.
|
||||
|
||||
If you're compiling LLVM with different source and object directories, then you
|
||||
must perform the following additional steps before running ``make``::
|
||||
|
||||
# LLVMC_SRC_DIR = $LLVM_SRC_DIR/tools/llvmc/
|
||||
# LLVMC_OBJ_DIR = $LLVM_OBJ_DIR/tools/llvmc/
|
||||
$ cp $LLVMC_SRC_DIR/example/mydriver/Makefile \
|
||||
$LLVMC_OBJ_DIR/example/mydriver/
|
||||
$ cd $LLVMC_OBJ_DIR/example/mydriver
|
||||
$ mkdir $LLVMC_OBJ_DIR/examples/MyDriver/
|
||||
$ cp $LLVMC_SRC_DIR/examples/MyDriver/Makefile \
|
||||
$LLVMC_OBJ_DIR/examples/MyDriver/
|
||||
$ cd $LLVMC_OBJ_DIR/examples/MyDriver
|
||||
$ make
|
||||
|
||||
Another way to do the same thing is by using the following command::
|
||||
|
||||
$ cd $LLVMC_DIR
|
||||
$ make LLVMC_BUILTIN_PLUGINS=MyPlugin LLVMC_BASED_DRIVER_NAME=mydriver
|
||||
|
||||
This works with both srcdir == objdir and srcdir != objdir, but assumes that the
|
||||
plugin source directory was placed under ``$LLVMC_DIR/plugins``.
|
||||
|
||||
Sometimes, you will want a 'bare-bones' version of LLVMC that has no
|
||||
built-in plugins. It can be compiled with the following command::
|
||||
|
||||
$ cd $LLVMC_DIR
|
||||
$ make LLVMC_BUILTIN_PLUGINS=""
|
||||
|
||||
|
||||
Customizing LLVMC: the compilation graph
|
||||
========================================
|
||||
|
||||
Each TableGen configuration file should include the common
|
||||
definitions::
|
||||
Each TableGen configuration file should include the common definitions::
|
||||
|
||||
include "llvm/CompilerDriver/Common.td"
|
||||
|
||||
Internally, LLVMC stores information about possible source
|
||||
transformations in form of a graph. Nodes in this graph represent
|
||||
tools, and edges between two nodes represent a transformation path. A
|
||||
special "root" node is used to mark entry points for the
|
||||
transformations. LLVMC also assigns a weight to each edge (more on
|
||||
this later) to choose between several alternative edges.
|
||||
Internally, LLVMC stores information about possible source transformations in
|
||||
form of a graph. Nodes in this graph represent tools, and edges between two
|
||||
nodes represent a transformation path. A special "root" node is used to mark
|
||||
entry points for the transformations. LLVMC also assigns a weight to each edge
|
||||
(more on this later) to choose between several alternative edges.
|
||||
|
||||
The definition of the compilation graph (see file
|
||||
``plugins/Base/Base.td`` for an example) is just a list of edges::
|
||||
The definition of the compilation graph (see file ``llvmc/src/Base.td`` for an
|
||||
example) is just a list of edges::
|
||||
|
||||
def CompilationGraph : CompilationGraph<[
|
||||
Edge<"root", "llvm_gcc_c">,
|
||||
@ -245,43 +206,37 @@ The definition of the compilation graph (see file
|
||||
|
||||
]>;
|
||||
|
||||
As you can see, the edges can be either default or optional, where
|
||||
optional edges are differentiated by an additional ``case`` expression
|
||||
used to calculate the weight of this edge. Notice also that we refer
|
||||
to tools via their names (as strings). This makes it possible to add
|
||||
edges to an existing compilation graph in plugins without having to
|
||||
know about all tool definitions used in the graph.
|
||||
As you can see, the edges can be either default or optional, where optional
|
||||
edges are differentiated by an additional ``case`` expression used to calculate
|
||||
the weight of this edge. Notice also that we refer to tools via their names (as
|
||||
strings). This makes it possible to add edges to an existing compilation graph
|
||||
without having to know about all tool definitions used in the graph.
|
||||
|
||||
The default edges are assigned a weight of 1, and optional edges get a
|
||||
weight of 0 + 2*N where N is the number of tests that evaluated to
|
||||
true in the ``case`` expression. It is also possible to provide an
|
||||
integer parameter to ``inc_weight`` and ``dec_weight`` - in this case,
|
||||
the weight is increased (or decreased) by the provided value instead
|
||||
of the default 2. It is also possible to change the default weight of
|
||||
an optional edge by using the ``default`` clause of the ``case``
|
||||
The default edges are assigned a weight of 1, and optional edges get a weight of
|
||||
0 + 2*N where N is the number of tests that evaluated to true in the ``case``
|
||||
expression. It is also possible to provide an integer parameter to
|
||||
``inc_weight`` and ``dec_weight`` - in this case, the weight is increased (or
|
||||
decreased) by the provided value instead of the default 2. Default weight of an
|
||||
optional edge can be changed by using the ``default`` clause of the ``case``
|
||||
construct.
|
||||
|
||||
When passing an input file through the graph, LLVMC picks the edge
|
||||
with the maximum weight. To avoid ambiguity, there should be only one
|
||||
default edge between two nodes (with the exception of the root node,
|
||||
which gets a special treatment - there you are allowed to specify one
|
||||
default edge *per language*).
|
||||
When passing an input file through the graph, LLVMC picks the edge with the
|
||||
maximum weight. To avoid ambiguity, there should be only one default edge
|
||||
between two nodes (with the exception of the root node, which gets a special
|
||||
treatment - there you are allowed to specify one default edge *per language*).
|
||||
|
||||
When multiple plugins are loaded, their compilation graphs are merged
|
||||
together. Since multiple edges that have the same end nodes are not
|
||||
allowed (i.e. the graph is not a multigraph), an edge defined in
|
||||
several plugins will be replaced by the definition from the plugin
|
||||
that was loaded last. Plugin load order can be controlled by using the
|
||||
plugin priority feature described above.
|
||||
When multiple compilation graphs are defined, they are merged together. Multiple
|
||||
edges with the same end nodes are not allowed (i.e. the graph is not a
|
||||
multigraph), and will lead to a compile-time error.
|
||||
|
||||
To get a visual representation of the compilation graph (useful for
|
||||
debugging), run ``llvmc --view-graph``. You will need ``dot`` and
|
||||
``gsview`` installed for this to work properly.
|
||||
To get a visual representation of the compilation graph (useful for debugging),
|
||||
run ``llvmc --view-graph``. You will need ``dot`` and ``gsview`` installed for
|
||||
this to work properly.
|
||||
|
||||
Describing options
|
||||
==================
|
||||
|
||||
Command-line options that the plugin supports are defined by using an
|
||||
Command-line options supported by the driver are defined by using an
|
||||
``OptionList``::
|
||||
|
||||
def Options : OptionList<[
|
||||
@ -290,11 +245,10 @@ Command-line options that the plugin supports are defined by using an
|
||||
...
|
||||
]>;
|
||||
|
||||
As you can see, the option list is just a list of DAGs, where each DAG
|
||||
is an option description consisting of the option name and some
|
||||
properties. A plugin can define more than one option list (they are
|
||||
all merged together in the end), which can be handy if one wants to
|
||||
separate option groups syntactically.
|
||||
As you can see, the option list is just a list of DAGs, where each DAG is an
|
||||
option description consisting of the option name and some properties. More than
|
||||
one option list can be defined (they are all merged together in the end), which
|
||||
can be handy if one wants to separate option groups syntactically.
|
||||
|
||||
* Possible option types:
|
||||
|
||||
@ -380,42 +334,17 @@ separate option groups syntactically.
|
||||
Usage examples: ``(switch_option "foo", (init true))``; ``(prefix_option
|
||||
"bar", (init "baz"))``.
|
||||
|
||||
- ``extern`` - this option is defined in some other plugin, see `below`__.
|
||||
|
||||
__ extern_
|
||||
|
||||
.. _extern:
|
||||
|
||||
External options
|
||||
----------------
|
||||
|
||||
Sometimes, when linking several plugins together, one plugin needs to
|
||||
access options defined in some other plugin. Because of the way
|
||||
options are implemented, such options must be marked as
|
||||
``extern``. This is what the ``extern`` option property is
|
||||
for. Example::
|
||||
|
||||
...
|
||||
(switch_option "E", (extern))
|
||||
...
|
||||
|
||||
If an external option has additional attributes besides 'extern', they are
|
||||
ignored. See also the section on plugin `priorities`__.
|
||||
|
||||
__ priorities_
|
||||
|
||||
.. _case:
|
||||
|
||||
Conditional evaluation
|
||||
======================
|
||||
|
||||
The 'case' construct is the main means by which programmability is
|
||||
achieved in LLVMC. It can be used to calculate edge weights, program
|
||||
actions and modify the shell commands to be executed. The 'case'
|
||||
expression is designed after the similarly-named construct in
|
||||
functional languages and takes the form ``(case (test_1), statement_1,
|
||||
(test_2), statement_2, ... (test_N), statement_N)``. The statements
|
||||
are evaluated only if the corresponding tests evaluate to true.
|
||||
The 'case' construct is the main means by which programmability is achieved in
|
||||
LLVMC. It can be used to calculate edge weights, program actions and modify the
|
||||
shell commands to be executed. The 'case' expression is designed after the
|
||||
similarly-named construct in functional languages and takes the form ``(case
|
||||
(test_1), statement_1, (test_2), statement_2, ... (test_N), statement_N)``. The
|
||||
statements are evaluated only if the corresponding tests evaluate to true.
|
||||
|
||||
Examples::
|
||||
|
||||
@ -439,20 +368,19 @@ Examples::
|
||||
(switch_on "B"), "cmdline2",
|
||||
(default), "cmdline3")
|
||||
|
||||
Note the slight difference in 'case' expression handling in contexts
|
||||
of edge weights and command line specification - in the second example
|
||||
the value of the ``"B"`` switch is never checked when switch ``"A"`` is
|
||||
enabled, and the whole expression always evaluates to ``"cmdline1"`` in
|
||||
that case.
|
||||
Note the slight difference in 'case' expression handling in contexts of edge
|
||||
weights and command line specification - in the second example the value of the
|
||||
``"B"`` switch is never checked when switch ``"A"`` is enabled, and the whole
|
||||
expression always evaluates to ``"cmdline1"`` in that case.
|
||||
|
||||
Case expressions can also be nested, i.e. the following is legal::
|
||||
|
||||
(case (switch_on "E"), (case (switch_on "o"), ..., (default), ...)
|
||||
(default), ...)
|
||||
|
||||
You should, however, try to avoid doing that because it hurts
|
||||
readability. It is usually better to split tool descriptions and/or
|
||||
use TableGen inheritance instead.
|
||||
You should, however, try to avoid doing that because it hurts readability. It is
|
||||
usually better to split tool descriptions and/or use TableGen inheritance
|
||||
instead.
|
||||
|
||||
* Possible tests are:
|
||||
|
||||
@ -526,72 +454,75 @@ use TableGen inheritance instead.
|
||||
Example: ``(not (or (test1), (test2), ... (testN)))``.
|
||||
|
||||
|
||||
|
||||
Writing a tool description
|
||||
==========================
|
||||
|
||||
As was said earlier, nodes in the compilation graph represent tools,
|
||||
which are described separately. A tool definition looks like this
|
||||
(taken from the ``include/llvm/CompilerDriver/Tools.td`` file)::
|
||||
As was said earlier, nodes in the compilation graph represent tools, which are
|
||||
described separately. A tool definition looks like this (taken from the
|
||||
``llvmc/src/Base.td`` file)::
|
||||
|
||||
def llvm_gcc_cpp : Tool<[
|
||||
(in_language "c++"),
|
||||
(out_language "llvm-assembler"),
|
||||
(output_suffix "bc"),
|
||||
(cmd_line "llvm-g++ -c $INFILE -o $OUTFILE -emit-llvm"),
|
||||
(command "llvm-g++ -c -emit-llvm"),
|
||||
(sink)
|
||||
]>;
|
||||
|
||||
This defines a new tool called ``llvm_gcc_cpp``, which is an alias for
|
||||
``llvm-g++``. As you can see, a tool definition is just a list of
|
||||
properties; most of them should be self-explanatory. The ``sink``
|
||||
property means that this tool should be passed all command-line
|
||||
options that aren't mentioned in the option list.
|
||||
``llvm-g++``. As you can see, a tool definition is just a list of properties;
|
||||
most of them should be self-explanatory. The ``sink`` property means that this
|
||||
tool should be passed all command-line options that aren't mentioned in the
|
||||
option list.
|
||||
|
||||
The complete list of all currently implemented tool properties follows.
|
||||
|
||||
* Possible tool properties:
|
||||
|
||||
- ``in_language`` - input language name. Can be given multiple arguments, in
|
||||
case the tool supports multiple input languages.
|
||||
case the tool supports multiple input languages. Used for typechecking and
|
||||
mapping file extensions to tools.
|
||||
|
||||
- ``out_language`` - output language name. Multiple output languages are
|
||||
allowed.
|
||||
allowed. Used for typechecking the compilation graph.
|
||||
|
||||
- ``output_suffix`` - output file suffix. Can also be changed
|
||||
dynamically, see documentation on actions.
|
||||
|
||||
- ``cmd_line`` - the actual command used to run the tool. You can
|
||||
use ``$INFILE`` and ``$OUTFILE`` variables, output redirection
|
||||
with ``>``, hook invocations (``$CALL``), environment variables
|
||||
(via ``$ENV``) and the ``case`` construct.
|
||||
|
||||
- ``join`` - this tool is a "join node" in the graph, i.e. it gets a
|
||||
list of input files and joins them together. Used for linkers.
|
||||
|
||||
- ``sink`` - all command-line options that are not handled by other
|
||||
tools are passed to this tool.
|
||||
|
||||
- ``actions`` - A single big ``case`` expression that specifies how
|
||||
this tool reacts on command-line options (described in more detail
|
||||
`below`__).
|
||||
- ``output_suffix`` - output file suffix. Can also be changed dynamically, see
|
||||
documentation on `actions`__.
|
||||
|
||||
__ actions_
|
||||
|
||||
- ``command`` - the actual command used to run the tool. You can use output
|
||||
redirection with ``>``, hook invocations (``$CALL``), environment variables
|
||||
(via ``$ENV``) and the ``case`` construct.
|
||||
|
||||
- ``join`` - this tool is a "join node" in the graph, i.e. it gets a list of
|
||||
input files and joins them together. Used for linkers.
|
||||
|
||||
- ``sink`` - all command-line options that are not handled by other tools are
|
||||
passed to this tool.
|
||||
|
||||
- ``actions`` - A single big ``case`` expression that specifies how this tool
|
||||
reacts on command-line options (described in more detail `below`__).
|
||||
|
||||
__ actions_
|
||||
|
||||
- ``out_file_option``, ``in_file_option`` - Options appended to the
|
||||
``command`` string to designate output and input files. Default values are
|
||||
``"-o"`` and ``""``, respectively.
|
||||
|
||||
.. _actions:
|
||||
|
||||
Actions
|
||||
-------
|
||||
|
||||
A tool often needs to react to command-line options, and this is
|
||||
precisely what the ``actions`` property is for. The next example
|
||||
illustrates this feature::
|
||||
A tool often needs to react to command-line options, and this is precisely what
|
||||
the ``actions`` property is for. The next example illustrates this feature::
|
||||
|
||||
def llvm_gcc_linker : Tool<[
|
||||
(in_language "object-code"),
|
||||
(out_language "executable"),
|
||||
(output_suffix "out"),
|
||||
(cmd_line "llvm-gcc $INFILE -o $OUTFILE"),
|
||||
(command "llvm-gcc"),
|
||||
(join),
|
||||
(actions (case (not_empty "L"), (forward "L"),
|
||||
(not_empty "l"), (forward "l"),
|
||||
@ -599,18 +530,17 @@ illustrates this feature::
|
||||
[(append_cmd "-dummy1"), (append_cmd "-dummy2")])
|
||||
]>;
|
||||
|
||||
The ``actions`` tool property is implemented on top of the omnipresent
|
||||
``case`` expression. It associates one or more different *actions*
|
||||
with given conditions - in the example, the actions are ``forward``,
|
||||
which forwards a given option unchanged, and ``append_cmd``, which
|
||||
appends a given string to the tool execution command. Multiple actions
|
||||
can be associated with a single condition by using a list of actions
|
||||
(used in the example to append some dummy options). The same ``case``
|
||||
construct can also be used in the ``cmd_line`` property to modify the
|
||||
tool command line.
|
||||
The ``actions`` tool property is implemented on top of the omnipresent ``case``
|
||||
expression. It associates one or more different *actions* with given
|
||||
conditions - in the example, the actions are ``forward``, which forwards a given
|
||||
option unchanged, and ``append_cmd``, which appends a given string to the tool
|
||||
execution command. Multiple actions can be associated with a single condition by
|
||||
using a list of actions (used in the example to append some dummy options). The
|
||||
same ``case`` construct can also be used in the ``cmd_line`` property to modify
|
||||
the tool command line.
|
||||
|
||||
The "join" property used in the example means that this tool behaves
|
||||
like a linker.
|
||||
The "join" property used in the example means that this tool behaves like a
|
||||
linker.
|
||||
|
||||
The list of all possible actions follows.
|
||||
|
||||
@ -656,10 +586,10 @@ The list of all possible actions follows.
|
||||
Language map
|
||||
============
|
||||
|
||||
If you are adding support for a new language to LLVMC, you'll need to
|
||||
modify the language map, which defines mappings from file extensions
|
||||
to language names. It is used to choose the proper toolchain(s) for a
|
||||
given input file set. Language map definition looks like this::
|
||||
If you are adding support for a new language to LLVMC, you'll need to modify the
|
||||
language map, which defines mappings from file extensions to language names. It
|
||||
is used to choose the proper toolchain(s) for a given input file set. Language
|
||||
map definition looks like this::
|
||||
|
||||
def LanguageMap : LanguageMap<
|
||||
[LangToSuffixes<"c++", ["cc", "cp", "cxx", "cpp", "CPP", "c++", "C"]>,
|
||||
@ -673,9 +603,7 @@ For example, without those definitions the following command wouldn't work::
|
||||
llvmc: Unknown suffix: cpp
|
||||
|
||||
The language map entries are needed only for the tools that are linked from the
|
||||
root node. Since a tool can't have multiple output languages, for inner nodes of
|
||||
the graph the input and output languages should match. This is enforced at
|
||||
compile-time.
|
||||
root node. A tool can have multiple output languages.
|
||||
|
||||
Option preprocessor
|
||||
===================
|
||||
@ -686,7 +614,7 @@ implemented as switches, we might want to output a warning if the user invokes
|
||||
the driver with both of these options enabled.
|
||||
|
||||
The ``OptionPreprocessor`` feature is reserved specially for these
|
||||
occasions. Example (adapted from the built-in Base plugin)::
|
||||
occasions. Example (adapted from ``llvm/src/Base.td.in``)::
|
||||
|
||||
|
||||
def Preprocess : OptionPreprocessor<
|
||||
@ -705,7 +633,7 @@ that they are not forwarded to the compiler. If no optimization options are
|
||||
specified, ``-O2`` is enabled.
|
||||
|
||||
``OptionPreprocessor`` is basically a single big ``case`` expression, which is
|
||||
evaluated only once right after the plugin is loaded. The only allowed actions
|
||||
evaluated only once right after the driver is started. The only allowed actions
|
||||
in ``OptionPreprocessor`` are ``error``, ``warning``, and two special actions:
|
||||
``unset_option`` and ``set_option``. As their names suggest, they can be used to
|
||||
set or unset a given option. To set an option with ``set_option``, use the
|
||||
@ -726,30 +654,28 @@ More advanced topics
|
||||
Hooks and environment variables
|
||||
-------------------------------
|
||||
|
||||
Normally, LLVMC executes programs from the system ``PATH``. Sometimes,
|
||||
this is not sufficient: for example, we may want to specify tool paths
|
||||
or names in the configuration file. This can be easily achieved via
|
||||
the hooks mechanism. To write your own hooks, just add their
|
||||
definitions to the ``PluginMain.cpp`` or drop a ``.cpp`` file into the
|
||||
your plugin directory. Hooks should live in the ``hooks`` namespace
|
||||
and have the signature ``std::string hooks::MyHookName ([const char*
|
||||
Arg0 [ const char* Arg2 [, ...]]])``. They can be used from the
|
||||
``cmd_line`` tool property::
|
||||
Normally, LLVMC searches for programs in the system ``PATH``. Sometimes, this is
|
||||
not sufficient: for example, we may want to specify tool paths or names in the
|
||||
configuration file. This can be achieved via the hooks mechanism. To write your
|
||||
own hooks, add their definitions to the ``Hooks.cpp`` or drop a ``.cpp`` file
|
||||
into your driver directory. Hooks should live in the ``hooks`` namespace and
|
||||
have the signature ``std::string hooks::MyHookName ([const char* Arg0 [ const
|
||||
char* Arg2 [, ...]]])``. They can be used from the ``command`` tool property::
|
||||
|
||||
(cmd_line "$CALL(MyHook)/path/to/file -o $CALL(AnotherHook)")
|
||||
(command "$CALL(MyHook)/path/to/file -o $CALL(AnotherHook)")
|
||||
|
||||
To pass arguments to hooks, use the following syntax::
|
||||
|
||||
(cmd_line "$CALL(MyHook, 'Arg1', 'Arg2', 'Arg # 3')/path/to/file -o1 -o2")
|
||||
(command "$CALL(MyHook, 'Arg1', 'Arg2', 'Arg # 3')/path/to/file -o1 -o2")
|
||||
|
||||
It is also possible to use environment variables in the same manner::
|
||||
|
||||
(cmd_line "$ENV(VAR1)/path/to/file -o $ENV(VAR2)")
|
||||
(command "$ENV(VAR1)/path/to/file -o $ENV(VAR2)")
|
||||
|
||||
To change the command line string based on user-provided options use
|
||||
the ``case`` expression (documented `above`__)::
|
||||
|
||||
(cmd_line
|
||||
(command
|
||||
(case
|
||||
(switch_on "E"),
|
||||
"llvm-g++ -E -x c $INFILE -o $OUTFILE",
|
||||
@ -758,42 +684,21 @@ the ``case`` expression (documented `above`__)::
|
||||
|
||||
__ case_
|
||||
|
||||
.. _priorities:
|
||||
|
||||
How plugins are loaded
|
||||
----------------------
|
||||
|
||||
It is possible for LLVMC plugins to depend on each other. For example,
|
||||
one can create edges between nodes defined in some other plugin. To
|
||||
make this work, however, that plugin should be loaded first. To
|
||||
achieve this, the concept of plugin priority was introduced. By
|
||||
default, every plugin has priority zero; to specify the priority
|
||||
explicitly, put the following line in your plugin's TableGen file::
|
||||
|
||||
def Priority : PluginPriority<$PRIORITY_VALUE>;
|
||||
# Where PRIORITY_VALUE is some integer > 0
|
||||
|
||||
Plugins are loaded in order of their (increasing) priority, starting
|
||||
with 0. Therefore, the plugin with the highest priority value will be
|
||||
loaded last.
|
||||
|
||||
Debugging
|
||||
---------
|
||||
|
||||
When writing LLVMC plugins, it can be useful to get a visual view of
|
||||
the resulting compilation graph. This can be achieved via the command
|
||||
line option ``--view-graph``. This command assumes that Graphviz_ and
|
||||
Ghostview_ are installed. There is also a ``--write-graph`` option that
|
||||
creates a Graphviz source file (``compilation-graph.dot``) in the
|
||||
current directory.
|
||||
When writing LLVMC-based drivers, it can be useful to get a visual view of the
|
||||
resulting compilation graph. This can be achieved via the command line option
|
||||
``--view-graph`` (which assumes that Graphviz_ and Ghostview_ are
|
||||
installed). There is also a ``--write-graph`` option that creates a Graphviz
|
||||
source file (``compilation-graph.dot``) in the current directory.
|
||||
|
||||
Another useful ``llvmc`` option is ``--check-graph``. It checks the
|
||||
compilation graph for common errors like mismatched output/input
|
||||
language names, multiple default edges and cycles. These checks can't
|
||||
be performed at compile-time because the plugins can load code
|
||||
dynamically. When invoked with ``--check-graph``, ``llvmc`` doesn't
|
||||
perform any compilation tasks and returns the number of encountered
|
||||
errors as its status code.
|
||||
Another useful ``llvmc`` option is ``--check-graph``. It checks the compilation
|
||||
graph for common errors like mismatched output/input language names, multiple
|
||||
default edges and cycles. When invoked with ``--check-graph``, ``llvmc`` doesn't
|
||||
perform any compilation tasks and returns the number of encountered errors as
|
||||
its status code. In the future, these checks will be performed at compile-time
|
||||
and this option will disappear.
|
||||
|
||||
.. _Graphviz: http://www.graphviz.org/
|
||||
.. _Ghostview: http://pages.cs.wisc.edu/~ghost/
|
||||
@ -821,7 +726,7 @@ accessible only in the C++ code (i.e. hooks). Use the following code::
|
||||
|
||||
In general, you're encouraged not to make the behaviour dependent on the
|
||||
executable file name, and use command-line switches instead. See for example how
|
||||
the ``Base`` plugin behaves when it needs to choose the correct linker options
|
||||
the ``llvmc`` program behaves when it needs to choose the correct linker options
|
||||
(think ``g++`` vs. ``gcc``).
|
||||
|
||||
.. raw:: html
|
||||
|
||||
@ -17,59 +17,54 @@ Tutorial - Using LLVMC
|
||||
Introduction
|
||||
============
|
||||
|
||||
LLVMC is a generic compiler driver, which plays the same role for LLVM
|
||||
as the ``gcc`` program does for GCC - the difference being that LLVMC
|
||||
is designed to be more adaptable and easier to customize. Most of
|
||||
LLVMC functionality is implemented via plugins, which can be loaded
|
||||
dynamically or compiled in. This tutorial describes the basic usage
|
||||
and configuration of LLVMC.
|
||||
LLVMC is a generic compiler driver, which plays the same role for LLVM as the
|
||||
``gcc`` program does for GCC - the difference being that LLVMC is designed to be
|
||||
more adaptable and easier to customize. Most of LLVMC functionality is
|
||||
implemented via high-level TableGen code, from which a corresponding C++ source
|
||||
file is automatically generated. This tutorial describes the basic usage and
|
||||
configuration of LLVMC.
|
||||
|
||||
|
||||
Compiling with LLVMC
|
||||
====================
|
||||
Using the ``llvmc`` program
|
||||
===========================
|
||||
|
||||
In general, LLVMC tries to be command-line compatible with ``gcc`` as
|
||||
much as possible, so most of the familiar options work::
|
||||
In general, ``llvmc`` tries to be command-line compatible with ``gcc`` as much
|
||||
as possible, so most of the familiar options work::
|
||||
|
||||
$ llvmc -O3 -Wall hello.cpp
|
||||
$ ./a.out
|
||||
hello
|
||||
|
||||
This will invoke ``llvm-g++`` under the hood (you can see which
|
||||
commands are executed by using the ``-v`` option). For further help on
|
||||
command-line LLVMC usage, refer to the ``llvmc --help`` output.
|
||||
This will invoke ``llvm-g++`` under the hood (you can see which commands are
|
||||
executed by using the ``-v`` option). For further help on command-line LLVMC
|
||||
usage, refer to the ``llvmc --help`` output.
|
||||
|
||||
|
||||
Using LLVMC to generate toolchain drivers
|
||||
=========================================
|
||||
|
||||
LLVMC plugins are written mostly using TableGen_, so you need to
|
||||
be familiar with it to get anything done.
|
||||
LLVMC-based drivers are written mostly using TableGen_, so you need to be
|
||||
familiar with it to get anything done.
|
||||
|
||||
.. _TableGen: http://llvm.org/docs/TableGenFundamentals.html
|
||||
|
||||
Start by compiling ``example/Simple``, which is a primitive wrapper for
|
||||
``gcc``::
|
||||
|
||||
$ cd $LLVM_DIR/tools/llvmc
|
||||
$ cp -r example/Simple plugins/Simple
|
||||
|
||||
# NB: A less verbose way to compile standalone LLVMC-based drivers is
|
||||
# described in the reference manual.
|
||||
|
||||
$ make LLVMC_BASED_DRIVER_NAME=mygcc LLVMC_BUILTIN_PLUGINS=Simple
|
||||
$ cd $LLVM_OBJ_DIR/tools/examples/Simple
|
||||
$ make
|
||||
$ cat > hello.c
|
||||
[...]
|
||||
$ mygcc hello.c
|
||||
#include <stdio.h>
|
||||
int main() { printf("Hello\n"); }
|
||||
$ $LLVM_BIN_DIR/Simple -v hello.c
|
||||
gcc hello.c -o hello.out
|
||||
$ ./hello.out
|
||||
Hello
|
||||
|
||||
Here we link our plugin with the LLVMC core statically to form an executable
|
||||
file called ``mygcc``. It is also possible to build our plugin as a dynamic
|
||||
library to be loaded by the ``llvmc`` executable (or any other LLVMC-based
|
||||
standalone driver); this is described in the reference manual.
|
||||
|
||||
Contents of the file ``Simple.td`` look like this::
|
||||
We have thus produced a simple driver called, appropriately, ``Simple``, from
|
||||
the input TableGen file ``Simple.td``. The ``llvmc`` program itself is generated
|
||||
using a similar process (see ``llvmc/src``). Contents of the file ``Simple.td``
|
||||
look like this::
|
||||
|
||||
// Include common definitions
|
||||
include "llvm/CompilerDriver/Common.td"
|
||||
@ -79,37 +74,40 @@ Contents of the file ``Simple.td`` look like this::
|
||||
[(in_language "c"),
|
||||
(out_language "executable"),
|
||||
(output_suffix "out"),
|
||||
(cmd_line "gcc $INFILE -o $OUTFILE"),
|
||||
(sink)
|
||||
(command "gcc"),
|
||||
(sink),
|
||||
|
||||
// -o is what is used by default, out_file_option here is included for
|
||||
// instructive purposes.
|
||||
(out_file_option "-o")
|
||||
]>;
|
||||
|
||||
// Language map
|
||||
def LanguageMap : LanguageMap<[LangToSuffixes<"c", ["c"]>]>;
|
||||
def LanguageMap : LanguageMap<[(lang_to_suffixes "c", "c")]>;
|
||||
|
||||
// Compilation graph
|
||||
def CompilationGraph : CompilationGraph<[Edge<"root", "gcc">]>;
|
||||
def CompilationGraph : CompilationGraph<[(edge "root", "gcc")]>;
|
||||
|
||||
As you can see, this file consists of three parts: tool descriptions,
|
||||
language map, and the compilation graph definition.
|
||||
As you can see, this file consists of three parts: tool descriptions, language
|
||||
map, and the compilation graph definition.
|
||||
|
||||
At the heart of LLVMC is the idea of a compilation graph: vertices in
|
||||
this graph are tools, and edges represent a transformation path
|
||||
between two tools (for example, assembly source produced by the
|
||||
compiler can be transformed into executable code by an assembler). The
|
||||
compilation graph is basically a list of edges; a special node named
|
||||
``root`` is used to mark graph entry points.
|
||||
At the heart of LLVMC is the idea of a compilation graph: vertices in this graph
|
||||
are tools, and edges represent a transformation path between two tools (for
|
||||
example, assembly source produced by the compiler can be transformed into
|
||||
executable code by an assembler). The compilation graph is basically a list of
|
||||
edges; a special node named ``root`` is used to mark graph entry points.
|
||||
|
||||
Tool descriptions are represented as property lists: most properties
|
||||
in the example above should be self-explanatory; the ``sink`` property
|
||||
means that all options lacking an explicit description should be
|
||||
forwarded to this tool.
|
||||
Tool descriptions are represented as property lists: most properties in the
|
||||
example above should be self-explanatory; the ``sink`` property means that all
|
||||
options lacking an explicit description should be forwarded to this tool.
|
||||
|
||||
The ``LanguageMap`` associates a language name with a list of suffixes
|
||||
and is used for deciding which toolchain corresponds to a given input
|
||||
file.
|
||||
The ``LanguageMap`` associates a language name with a list of suffixes and is
|
||||
used for deciding which toolchain corresponds to a given input file.
|
||||
|
||||
To learn more about LLVMC customization, refer to the reference
|
||||
manual and plugin source code in the ``plugins`` directory.
|
||||
To learn more about writing your own drivers with LLVMC, refer to the reference
|
||||
manual and examples in the ``examples`` directory. Of a particular interest is
|
||||
the ``Skeleton`` example, which can serve as a template for your LLVMC-based
|
||||
drivers.
|
||||
|
||||
.. raw:: html
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user