13 This document provides *usage* information about the LLVM makefile system. While
14 loosely patterned after the BSD makefile system, LLVM has taken a departure from
15 BSD in order to implement additional features needed by LLVM. Although makefile
16 systems, such as ``automake``, were attempted at one point, it has become clear
17 that the features needed by LLVM and the ``Makefile`` norm are too great to use
18 a more limited tool. Consequently, LLVM requires simply GNU Make 3.79, a widely
19 portable makefile processor. LLVM unabashedly makes heavy use of the features of
20 GNU Make so the dependency on GNU Make is firm. If you're not familiar with
21 ``make``, it is recommended that you read the `GNU Makefile Manual
22 <http://www.gnu.org/software/make/manual/make.html>`_.
24 While this document is rightly part of the `LLVM Programmer's
25 Manual <ProgrammersManual.html>`_, it is treated separately here because of the
26 volume of content and because it is often an early source of bewilderment for
32 The LLVM Makefile System is the component of LLVM that is responsible for
33 building the software, testing it, generating distributions, checking those
34 distributions, installing and uninstalling, etc. It consists of a several files
35 throughout the source tree. These files and other general concepts are described
41 The LLVM Makefile System is quite generous. It not only builds its own software,
42 but it can build yours too. Built into the system is knowledge of the
43 ``llvm/projects`` directory. Any directory under ``projects`` that has both a
44 ``configure`` script and a ``Makefile`` is assumed to be a project that uses the
45 LLVM Makefile system. Building software that uses LLVM does not require the
46 LLVM Makefile System nor even placement in the ``llvm/projects``
47 directory. However, doing so will allow your project to get up and running
48 quickly by utilizing the built-in features that are used to compile LLVM. LLVM
49 compiles itself using the same features of the makefile system as used for
52 For complete details on setting up your projects configuration, simply mimic the
53 ``llvm/projects/sample`` project. Or for further details, consult the
54 `Projects <Projects.html>`_ page.
59 To use the makefile system, you simply create a file named ``Makefile`` in your
60 directory and declare values for certain variables. The variables and values
61 that you select determine what the makefile system will do. These variables
62 enable rules and processing in the makefile system that automatically Do The
68 Setting variables alone is not enough. You must include into your Makefile
69 additional files that provide the rules of the LLVM Makefile system. The various
70 files involved are described in the sections that follow.
75 Each directory to participate in the build needs to have a file named
76 ``Makefile``. This is the file first read by ``make``. It has three
79 #. Settable Variables --- Required that must be set first.
80 #. ``include $(LEVEL)/Makefile.common`` --- include the LLVM Makefile system.
81 #. Override Variables --- Override variables set by the LLVM Makefile system.
83 .. _$(LEVEL)/Makefile.common:
88 Every project must have a ``Makefile.common`` file at its top source
89 directory. This file serves three purposes:
91 #. It includes the project's configuration makefile to obtain values determined
92 by the ``configure`` script. This is done by including the
93 `$(LEVEL)/Makefile.config`_ file.
95 #. It specifies any other (static) values that are needed throughout the
96 project. Only values that are used in all or a large proportion of the
97 project's directories should be placed here.
99 #. It includes the standard rules for the LLVM Makefile system,
100 `$(LLVM_SRC_ROOT)/Makefile.rules`_. This file is the *guts* of the LLVM
103 .. _$(LEVEL)/Makefile.config:
108 Every project must have a ``Makefile.config`` at the top of its *build*
109 directory. This file is **generated** by the ``configure`` script from the
110 pattern provided by the ``Makefile.config.in`` file located at the top of the
111 project's *source* directory. The contents of this file depend largely on what
112 configuration items the project uses, however most projects can get what they
113 need by just relying on LLVM's configuration found in
114 ``$(LLVM_OBJ_ROOT)/Makefile.config``.
116 .. _$(LLVM_SRC_ROOT)/Makefile.rules:
121 This file, located at ``$(LLVM_SRC_ROOT)/Makefile.rules`` is the heart of the
122 LLVM Makefile System. It provides all the logic, dependencies, and rules for
123 building the targets supported by the system. What it does largely depends on
124 the values of ``make`` `variables`_ that have been set *before*
125 ``Makefile.rules`` is included.
130 User ``Makefile``\s need not have comments in them unless the construction is
131 unusual or it does not strictly follow the rules and patterns of the LLVM
132 makefile system. Makefile comments are invoked with the pound (``#``) character.
133 The ``#`` character and any text following it, to the end of the line, are
139 This section provides some examples of the different kinds of modules you can
140 build with the LLVM makefile system. In general, each directory you provide will
141 build a single object although that object may be composed of additionally
147 Only a few variable definitions are needed to build a regular library.
148 Normally, the makefile system will build all the software into a single
149 ``libname.o`` (pre-linked) object. This means the library is not searchable and
150 that the distinction between compilation units has been dissolved. Optionally,
151 you can ask for a shared library (.so) or archive library (.a) built. Archive
152 libraries are the default. For example:
154 .. code-block:: makefile
160 says to build a library named ``mylib`` with both a shared library
161 (``mylib.so``) and an archive library (``mylib.a``) version. The contents of all
162 the libraries produced will be the same, they are just constructed differently.
163 Note that you normally do not need to specify the sources involved. The LLVM
164 Makefile system will infer the source files from the contents of the source
167 The ``LOADABLE_MODULE=1`` directive can be used in conjunction with
168 ``SHARED_LIBRARY=1`` to indicate that the resulting shared library should be
169 openable with the ``dlopen`` function and searchable with the ``dlsym`` function
170 (or your operating system's equivalents). While this isn't strictly necessary on
171 Linux and a few other platforms, it is required on systems like HP-UX and
172 Darwin. You should use ``LOADABLE_MODULE`` for any shared library that you
173 intend to be loaded into an tool via the ``-load`` option. See the
174 `WritingAnLLVMPass.html <WritingAnLLVMPass.html#makefile>`_ document for an
175 example of why you might want to do this.
180 In some situations, it is desirable to build a single bitcode module from a
181 variety of sources, instead of an archive, shared library, or bitcode
182 library. Bitcode modules can be specified in addition to any of the other types
183 of libraries by defining the `MODULE_NAME`_ variable. For example:
185 .. code-block:: makefile
191 will build a module named ``mymod.bc`` from the sources in the directory. This
192 module will be an aggregation of all the bitcode modules derived from the
193 sources. The example will also build a bitcode archive containing a bitcode
194 module for each compiled source file. The difference is subtle, but important
195 depending on how the module or library is to be linked.
200 In some situations, you need to create a loadable module. Loadable modules can
201 be loaded into programs like ``opt`` or ``llc`` to specify additional passes to
202 run or targets to support. Loadable modules are also useful for debugging a
203 pass or providing a pass with another package if that pass can't be included in
206 LLVM provides complete support for building such a module. All you need to do is
207 use the ``LOADABLE_MODULE`` variable in your ``Makefile``. For example, to build
208 a loadable module named ``MyMod`` that uses the LLVM libraries ``LLVMSupport.a``
209 and ``LLVMSystem.a``, you would specify:
211 .. code-block:: makefile
215 LINK_COMPONENTS := support system
217 Use of the ``LOADABLE_MODULE`` facility implies several things:
219 #. There will be no "``lib``" prefix on the module. This differentiates it from
220 a standard shared library of the same name.
222 #. The `SHARED_LIBRARY`_ variable is turned on.
224 #. The `LINK_LIBS_IN_SHARED`_ variable is turned on.
226 A loadable module is loaded by LLVM via the facilities of libtool's libltdl
227 library which is part of ``lib/System`` implementation.
232 For building executable programs (tools), you must provide the name of the tool
233 and the names of the libraries you wish to link with the tool. For example:
235 .. code-block:: makefile
239 LINK_COMPONENTS = support system
241 says that we are to build a tool name ``mytool`` and that it requires three
242 libraries: ``mylib``, ``LLVMSupport.a`` and ``LLVMSystem.a``.
244 Note that two different variables are use to indicate which libraries are
245 linked: ``USEDLIBS`` and ``LLVMLIBS``. This distinction is necessary to support
246 projects. ``LLVMLIBS`` refers to the LLVM libraries found in the LLVM object
247 directory. ``USEDLIBS`` refers to the libraries built by your project. In the
248 case of building LLVM tools, ``USEDLIBS`` and ``LLVMLIBS`` can be used
249 interchangeably since the "project" is LLVM itself and ``USEDLIBS`` refers to
250 the same place as ``LLVMLIBS``.
252 Also note that there are two different ways of specifying a library: with a
253 ``.a`` suffix and without. Without the suffix, the entry refers to the re-linked
254 (.o) file which will include *all* symbols of the library. This is
255 useful, for example, to include all passes from a library of passes. If the
256 ``.a`` suffix is used then the library is linked as a searchable library (with
257 the ``-l`` option). In this case, only the symbols that are unresolved *at
258 that point* will be resolved from the library, if they exist. Other
259 (unreferenced) symbols will not be included when the ``.a`` syntax is used. Note
260 that in order to use the ``.a`` suffix, the library in question must have been
261 built with the ``ARCHIVE_LIBRARY`` option set.
266 Many tools will want to use the JIT features of LLVM. To do this, you simply
267 specify that you want an execution 'engine', and the makefiles will
268 automatically link in the appropriate JIT for the host or an interpreter if none
271 .. code-block:: makefile
273 TOOLNAME = my_jit_tool
275 LINK_COMPONENTS = engine
277 Of course, any additional libraries may be listed as other components. To get a
278 full understanding of how this changes the linker command, it is recommended
283 % cd examples/Fibonacci
289 This section describes each of the targets that can be built using the LLVM
290 Makefile system. Any target can be invoked from any directory but not all are
291 applicable to a given directory (e.g. "check", "dist" and "install" will always
292 operate as if invoked from the top level directory).
294 ================= =============== ==================
295 Target Name Implied Targets Target Description
296 ================= =============== ==================
297 ``all`` \ Compile the software recursively. Default target.
298 ``all-local`` \ Compile the software in the local directory only.
299 ``check`` \ Change to the ``test`` directory in a project and run the test suite there.
300 ``check-local`` \ Run a local test suite. Generally this is only defined in the ``Makefile`` of the project's ``test`` directory.
301 ``clean`` \ Remove built objects recursively.
302 ``clean-local`` \ Remove built objects from the local directory only.
303 ``dist`` ``all`` Prepare a source distribution tarball.
304 ``dist-check`` ``all`` Prepare a source distribution tarball and check that it builds.
305 ``dist-clean`` ``clean`` Clean source distribution tarball temporary files.
306 ``install`` ``all`` Copy built objects to installation directory.
307 ``preconditions`` ``all`` Check to make sure configuration and makefiles are up to date.
308 ``printvars`` ``all`` Prints variables defined by the makefile system (for debugging).
309 ``tags`` \ Make C and C++ tags files for emacs and vi.
310 ``uninstall`` \ Remove built objects from installation directory.
311 ================= =============== ==================
318 When you invoke ``make`` with no arguments, you are implicitly instructing it to
319 seek the ``all`` target (goal). This target is used for building the software
320 recursively and will do different things in different directories. For example,
321 in a ``lib`` directory, the ``all`` target will compile source files and
322 generate libraries. But, in a ``tools`` directory, it will link libraries and
323 generate executables.
328 This target is the same as `all`_ but it operates only on the current directory
329 instead of recursively.
334 This target can be invoked from anywhere within a project's directories but
335 always invokes the `check-local`_ target in the project's ``test`` directory, if
336 it exists and has a ``Makefile``. A warning is produced otherwise. If
337 `TESTSUITE`_ is defined on the ``make`` command line, it will be passed down to
338 the invocation of ``make check-local`` in the ``test`` directory. The intended
339 usage for this is to assist in running specific suites of tests. If
340 ``TESTSUITE`` is not set, the implementation of ``check-local`` should run all
341 normal tests. It is up to the project to define what different values for
342 ``TESTSUTE`` will do. See the `Testing Guide <TestingGuide.html>`_ for further
348 This target should be implemented by the ``Makefile`` in the project's ``test``
349 directory. It is invoked by the ``check`` target elsewhere. Each project is
350 free to define the actions of ``check-local`` as appropriate for that
351 project. The LLVM project itself uses dejagnu to run a suite of feature and
352 regresson tests. Other projects may choose to use dejagnu or any other testing
358 This target cleans the build directory, recursively removing all things that the
359 Makefile builds. The cleaning rules have been made guarded so they shouldn't go
360 awry (via ``rm -f $(UNSET_VARIABLE)/*`` which will attempt to erase the entire
366 This target does the same thing as ``clean`` but only for the current (local)
372 This target builds a distribution tarball. It first builds the entire project
373 using the ``all`` target and then tars up the necessary files and compresses
374 it. The generated tarball is sufficient for a casual source distribution, but
375 probably not for a release (see ``dist-check``).
380 This target does the same thing as the ``dist`` target but also checks the
381 distribution tarball. The check is made by unpacking the tarball to a new
382 directory, configuring it, building it, installing it, and then verifying that
383 the installation results are correct (by comparing to the original build). This
384 target can take a long time to run but should be done before a release goes out
385 to make sure that the distributed tarball can actually be built into a working
391 This is a special form of the ``clean`` clean target. It performs a normal
392 ``clean`` but also removes things pertaining to building the distribution.
397 This target finalizes shared objects and executables and copies all libraries,
398 headers, executables and documentation to the directory given with the
399 ``--prefix`` option to ``configure``. When completed, the prefix directory will
400 have everything needed to **use** LLVM.
402 The LLVM makefiles can generate complete **internal** documentation for all the
403 classes by using ``doxygen``. By default, this feature is **not** enabled
404 because it takes a long time and generates a massive amount of data (>100MB). If
405 you want this feature, you must configure LLVM with the --enable-doxygen switch
406 and ensure that a modern version of doxygen (1.3.7 or later) is available in
407 your ``PATH``. You can download doxygen from `here
408 <http://www.stack.nl/~dimitri/doxygen/download.html#latestsrc>`_.
413 This utility target checks to see if the ``Makefile`` in the object directory is
414 older than the ``Makefile`` in the source directory and copies it if so. It also
415 reruns the ``configure`` script if that needs to be done and rebuilds the
416 ``Makefile.config`` file similarly. Users may overload this target to ensure
417 that sanity checks are run *before* any building of targets as all the targets
418 depend on ``preconditions``.
423 This utility target just causes the LLVM makefiles to print out some of the
424 makefile variables so that you can double check how things are set.
429 This utility target will force a reconfigure of LLVM or your project. It simply
430 runs ``$(PROJ_OBJ_ROOT)/config.status --recheck`` to rerun the configuration
431 tests and rebuild the configured files. This isn't generally useful as the
432 makefiles will reconfigure themselves whenever its necessary.
441 This utility target, only available when ``$(PROJ_OBJ_ROOT)`` is not the same as
442 ``$(PROJ_SRC_ROOT)``, will completely clean the ``$(PROJ_OBJ_ROOT)`` directory
443 by removing its content entirely and reconfiguring the directory. This returns
444 the ``$(PROJ_OBJ_ROOT)`` directory to a completely fresh state. All content in
445 the directory except configured files and top-level makefiles will be lost.
450 This target will generate a ``TAGS`` file in the top-level source directory. It
451 is meant for use with emacs, XEmacs, or ViM. The TAGS file provides an index of
452 symbol definitions so that the editor can jump you to the definition
458 This target is the opposite of the ``install`` target. It removes the header,
459 library and executable files from the installation directories. Note that the
460 directories themselves are not removed because it is not guaranteed that LLVM is
461 the only thing installing there (e.g. ``--prefix=/usr``).
468 Variables are used to tell the LLVM Makefile System what to do and to obtain
469 information from it. Variables are also used internally by the LLVM Makefile
470 System. Variable names that contain only the upper case alphabetic letters and
471 underscore are intended for use by the end user. All other variables are
472 internal to the LLVM Makefile System and should not be relied upon nor
473 modified. The sections below describe how to use the LLVM Makefile
479 Variables listed in the table below should be set *before* the inclusion of
480 `$(LEVEL)/Makefile.common`_. These variables provide input to the LLVM make
481 system that tell it what to do for the current directory.
484 If set to any value, causes an archive (.a) library to be built.
487 Specifies a set of source files that are generated from other source
488 files. These sources will be built before any other target processing to
489 ensure they are present.
492 If set to any value, causes a bitcode library (.bc) to be built.
495 Specifies a set of configuration files to be installed.
498 If set to any value, causes the build to include debugging symbols even in
499 optimized objects, libraries and executables. This alters the flags
500 specified to the compilers and linkers. Debugging isn't fun in an optimized
501 build, but it is possible.
504 Specifies a set of directories, usually children of the current directory,
505 that should also be made using the same goal. These directories will be
508 ``DISABLE_AUTO_DEPENDENCIES``
509 If set to any value, causes the makefiles to **not** automatically generate
510 dependencies when running the compiler. Use of this feature is discouraged
511 and it may be removed at a later date.
514 If set to 1, causes the build to generate optimized objects, libraries and
515 executables. This alters the flags specified to the compilers and
516 linkers. Generally debugging won't be a fun experience with an optimized
520 If set to 1, causes the build to generate both optimized and profiled
521 objects, libraries and executables. This alters the flags specified to the
522 compilers and linkers to ensure that profile data can be collected from the
523 tools built. Use the ``gprof`` tool to analyze the output from the profiled
524 tools (``gmon.out``).
526 ``DISABLE_ASSERTIONS``
527 If set to 1, causes the build to disable assertions, even if building a
528 debug or profile build. This will exclude all assertion check code from the
529 build. LLVM will execute faster, but with little help when things go
532 ``EXPERIMENTAL_DIRS``
533 Specify a set of directories that should be built, but if they fail, it
534 should not cause the build to fail. Note that this should only be used
535 temporarily while code is being written.
537 ``EXPORTED_SYMBOL_FILE``
538 Specifies the name of a single file that contains a list of the symbols to
539 be exported by the linker. One symbol per line.
541 ``EXPORTED_SYMBOL_LIST``
542 Specifies a set of symbols to be exported by the linker.
545 Specifies additional files that should be distributed with LLVM. All source
546 files, all built sources, all Makefiles, and most documentation files will
547 be automatically distributed. Use this variable to distribute any files that
548 are not automatically distributed.
551 If set to any value, specifies that when linking executables the makefiles
552 should retain debug symbols in the executable. Normally, symbols are
553 stripped from the executable.
556 Specify the level of nesting from the top level. This variable must be set
557 in each makefile as it is used to find the top level and thus the other
561 Specify the name of the library to be built. (Required For Libraries)
564 When specified for building a tool, the value of this variable will be
565 passed to the ``llvm-config`` tool to generate a link line for the
566 tool. Unlike ``USEDLIBS`` and ``LLVMLIBS``, not all libraries need to be
567 specified. The ``llvm-config`` tool will figure out the library dependencies
568 and add any libraries that are needed. The ``USEDLIBS`` variable can still
569 be used in conjunction with ``LINK_COMPONENTS`` so that additional
570 project-specific libraries can be linked with the LLVM libraries specified
571 by ``LINK_COMPONENTS``.
573 .. _LINK_LIBS_IN_SHARED:
575 ``LINK_LIBS_IN_SHARED``
576 By default, shared library linking will ignore any libraries specified with
577 the `LLVMLIBS`_ or `USEDLIBS`_. This prevents shared libs from including
578 things that will be in the LLVM tool the shared library will be loaded
579 into. However, sometimes it is useful to link certain libraries into your
580 shared library and this option enables that feature.
585 Specifies the set of libraries from the LLVM ``$(ObjDir)`` that will be
586 linked into the tool or library.
589 If set to any value, causes the shared library being built to also be a
590 loadable module. Loadable modules can be opened with the dlopen() function
591 and searched with dlsym (or the operating system's equivalent). Note that
592 setting this variable without also setting ``SHARED_LIBRARY`` will have no
598 Specifies the name of a bitcode module to be created. A bitcode module can
599 be specified in conjunction with other kinds of library builds or by
600 itself. It constructs from the sources a single linked bitcode file.
603 Specifies that the build products of the directory should not be installed
604 but should be built even if the ``install`` target is given. This is handy
605 for directories that build libraries or tools that are only used as part of
606 the build process, such as code generators (e.g. ``tblgen``).
609 Specify a set of directories that may be built, if they exist, but its not
610 an error for them not to exist.
613 Specify a set of directories to build recursively and in parallel if the
614 ``-j`` option was used with ``make``.
619 If set to any value, causes a shared library (``.so``) to be built in
620 addition to any other kinds of libraries. Note that this option will cause
621 all source files to be built twice: once with options for position
622 independent code and once without. Use it only where you really need a
625 ``SOURCES`` (optional)
626 Specifies the list of source files in the current directory to be
627 built. Source files of any type may be specified (programs, documentation,
628 config files, etc.). If not specified, the makefile system will infer the
629 set of source files from the files present in the current directory.
632 Specifies a set of filename suffixes that occur in suffix match rules. Only
633 set this if your local ``Makefile`` specifies additional suffix match
637 Specifies the name of the LLVM code generation target that the current
638 directory builds. Setting this variable enables additional rules to build
639 ``.inc`` files from ``.td`` files.
644 Specifies the directory of tests to run in ``llvm/test``.
647 Specifies the name of the tool that the current directory should build.
650 Implies ``VERBOSE`` and also tells each tool invoked to be verbose. This is
651 handy when you're trying to see the sub-tools invoked by each tool invoked
652 by the makefile. For example, this will pass ``-v`` to the GCC compilers
653 which causes it to print out the command lines it uses to invoke sub-tools
654 (compiler, assembler, linker).
659 Specifies the list of project libraries that will be linked into the tool or
663 Tells the Makefile system to produce detailed output of what it is doing
664 instead of just summary comments. This will generate a LOT of output.
669 Override variables can be used to override the default values provided by the
670 LLVM makefile system. These variables can be set in several ways:
672 * In the environment (e.g. setenv, export) --- not recommended.
673 * On the ``make`` command line --- recommended.
674 * On the ``configure`` command line.
675 * In the Makefile (only *after* the inclusion of `$(LEVEL)/Makefile.common`_).
677 The override variables are given below:
680 Specifies the path to the ``ar`` tool.
683 The directory into which the products of build rules will be placed. This
684 might be the same as `PROJ_SRC_DIR`_ but typically is not.
689 The directory which contains the source files to be built.
692 If set to 1, build examples in ``examples`` and (if building Clang)
693 ``tools/clang/examples`` directories.
695 ``BZIP2`` (configured)
696 The path to the ``bzip2`` tool.
699 The path to the 'C' compiler.
702 Additional flags to be passed to the 'C' compiler.
705 Specifies the path to the C++ compiler.
708 Additional flags to be passed to the C++ compiler.
710 ``DATE`` (configured)
711 Specifies the path to the ``date`` program or any program that can generate
712 the current date and time on its standard output.
715 Specifies the path to the ``dot`` tool or ``false`` if there isn't one.
717 ``ECHO`` (configured)
718 Specifies the path to the ``echo`` tool for printing output.
720 ``EXEEXT`` (configured)
721 Provides the extension to be used on executables built by the makefiles.
722 The value may be empty on platforms that do not use file extensions for
723 executables (e.g. Unix).
725 ``INSTALL`` (configured)
726 Specifies the path to the ``install`` tool.
728 ``LDFLAGS`` (configured)
729 Allows users to specify additional flags to pass to the linker.
731 ``LIBS`` (configured)
732 The list of libraries that should be linked with each tool.
734 ``LIBTOOL`` (configured)
735 Specifies the path to the ``libtool`` tool. This tool is renamed ``mklib``
736 by the ``configure`` script.
738 ``LLVMAS`` (defaulted)
739 Specifies the path to the ``llvm-as`` tool.
742 Specifies the path to the LLVM capable compiler.
745 Specifies the path to the LLVM C++ capable compiler.
747 ``LLVMGCC`` (defaulted)
748 Specifies the path to the LLVM version of the GCC 'C' Compiler.
750 ``LLVMGXX`` (defaulted)
751 Specifies the path to the LLVM version of the GCC C++ Compiler.
753 ``LLVMLD`` (defaulted)
754 Specifies the path to the LLVM bitcode linker tool
756 ``LLVM_OBJ_ROOT`` (configured)
757 Specifies the top directory into which the output of the build is placed.
759 ``LLVM_SRC_ROOT`` (configured)
760 Specifies the top directory in which the sources are found.
762 ``LLVM_TARBALL_NAME`` (configured)
763 Specifies the name of the distribution tarball to create. This is configured
764 from the name of the project and its version number.
766 ``MKDIR`` (defaulted)
767 Specifies the path to the ``mkdir`` tool that creates directories.
770 If set, specifies the list of tools to build.
772 ``PLATFORMSTRIPOPTS``
773 The options to provide to the linker to specify that a stripped (no symbols)
774 executable should be built.
776 ``RANLIB`` (defaulted)
777 Specifies the path to the ``ranlib`` tool.
780 Specifies the path to the ``rm`` tool.
783 Specifies the path to the ``sed`` tool.
785 ``SHLIBEXT`` (configured)
786 Provides the filename extension to use for shared libraries.
788 ``TBLGEN`` (defaulted)
789 Specifies the path to the ``tblgen`` tool.
792 Specifies the path to the ``tar`` tool.
795 Specifies the path to the ``zip`` tool.
800 Variables listed in the table below can be used by the user's Makefile but
801 should not be changed. Changing the value will generally cause the build to go
802 wrong, so don't do it.
805 The directory into which executables will ultimately be installed. This
806 value is derived from the ``--prefix`` option given to ``configure``.
809 The name of the type of build being performed: Debug, Release, or
813 The directory into which bitcode libraries will ultimately be installed.
814 This value is derived from the ``--prefix`` option given to ``configure``.
816 ``ConfigureScriptFLAGS``
817 Additional flags given to the ``configure`` script when reconfiguring.
820 The *current* directory for which a distribution copy is being made.
825 The LLVM Makefile System output command. This provides the ``llvm[n]``
826 prefix and starts with ``@`` so the command itself is not printed by
830 Same as `Echo`_ but without the leading ``@``.
833 The directory into which include files will ultimately be installed. This
834 value is derived from the ``--prefix`` option given to ``configure``.
837 The directory into which native libraries will ultimately be installed.
838 This value is derived from the ``--prefix`` option given to
842 The configuration specific directory into which libraries are placed before
846 Full path of the ``Makefile.config`` file.
849 Full path of the ``Makefile.config.in`` file.
852 The configuration and directory specific directory where build objects
853 (compilation results) are placed.
856 The complete list of sub-directories of the current directory as
857 specified by other variables.
860 The complete list of source files.
863 The directory into which configuration files will ultimately be
864 installed. This value is derived from the ``--prefix`` option given to
868 The configuration specific directory into which executables are placed
869 before they are installed.
872 The top most directory into which the distribution files are copied.
875 Use this as the first thing on your build script lines to enable or disable
876 verbose mode. It expands to either an ``@`` (quiet mode) or nothing (verbose
882 Variables listed below are used by the LLVM Makefile System and considered
883 internal. You should not use these variables under any circumstances.
885 .. code-block:: makefile