1 ==================================== 2 Getting Started with the LLVM System 3 ==================================== 4 5 .. contents:: 6 :local: 7 8 Overview 9 ======== 10 11 Welcome to LLVM! In order to get started, you first need to know some basic 12 information. 13 14 First, LLVM comes in three pieces. The first piece is the LLVM suite. This 15 contains all of the tools, libraries, and header files needed to use LLVM. It 16 contains an assembler, disassembler, bitcode analyzer and bitcode optimizer. It 17 also contains basic regression tests that can be used to test the LLVM tools and 18 the Clang front end. 19 20 The second piece is the `Clang <http://clang.llvm.org/>`_ front end. This 21 component compiles C, C++, Objective C, and Objective C++ code into LLVM 22 bitcode. Once compiled into LLVM bitcode, a program can be manipulated with the 23 LLVM tools from the LLVM suite. 24 25 There is a third, optional piece called Test Suite. It is a suite of programs 26 with a testing harness that can be used to further test LLVM's functionality 27 and performance. 28 29 Getting Started Quickly (A Summary) 30 =================================== 31 32 The LLVM Getting Started documentation may be out of date. So, the `Clang 33 Getting Started <http://clang.llvm.org/get_started.html>`_ page might also be a 34 good place to start. 35 36 Here's the short story for getting up and running quickly with LLVM: 37 38 #. Read the documentation. 39 #. Read the documentation. 40 #. Remember that you were warned twice about reading the documentation. 41 #. Checkout LLVM: 42 43 * ``cd where-you-want-llvm-to-live`` 44 * ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm`` 45 46 #. Checkout Clang: 47 48 * ``cd where-you-want-llvm-to-live`` 49 * ``cd llvm/tools`` 50 * ``svn co http://llvm.org/svn/llvm-project/cfe/trunk clang`` 51 52 #. Checkout Compiler-RT: 53 54 * ``cd where-you-want-llvm-to-live`` 55 * ``cd llvm/projects`` 56 * ``svn co http://llvm.org/svn/llvm-project/compiler-rt/trunk compiler-rt`` 57 58 #. Get the Test Suite Source Code **[Optional]** 59 60 * ``cd where-you-want-llvm-to-live`` 61 * ``cd llvm/projects`` 62 * ``svn co http://llvm.org/svn/llvm-project/test-suite/trunk test-suite`` 63 64 #. Configure and build LLVM and Clang: 65 66 * ``cd where-you-want-to-build-llvm`` 67 * ``mkdir build`` (for building without polluting the source dir) 68 * ``cd build`` 69 * ``../llvm/configure [options]`` 70 Some common options: 71 72 * ``--prefix=directory`` --- Specify for *directory* the full pathname of 73 where you want the LLVM tools and libraries to be installed (default 74 ``/usr/local``). 75 76 * ``--enable-optimized`` --- Compile with optimizations enabled (default 77 is NO). 78 79 * ``--enable-assertions`` --- Compile with assertion checks enabled 80 (default is YES). 81 82 * ``make [-j]`` --- The ``-j`` specifies the number of jobs (commands) to run 83 simultaneously. This builds both LLVM and Clang for Debug+Asserts mode. 84 The ``--enable-optimized`` configure option is used to specify a Release 85 build. 86 87 * ``make check-all`` --- This run the regression tests to ensure everything 88 is in working order. 89 90 * It is also possible to use `CMake <CMake.html>`_ instead of the makefiles. 91 With CMake it is possible to generate project files for several IDEs: 92 Xcode, Eclipse CDT4, CodeBlocks, Qt-Creator (use the CodeBlocks 93 generator), KDevelop3. 94 95 * If you get an "internal compiler error (ICE)" or test failures, see 96 `below`. 97 98 Consult the `Getting Started with LLVM`_ section for detailed information on 99 configuring and compiling LLVM. See `Setting Up Your Environment`_ for tips 100 that simplify working with the Clang front end and LLVM tools. Go to `Program 101 Layout`_ to learn about the layout of the source code tree. 102 103 Requirements 104 ============ 105 106 Before you begin to use the LLVM system, review the requirements given below. 107 This may save you some trouble by knowing ahead of time what hardware and 108 software you will need. 109 110 Hardware 111 -------- 112 113 LLVM is known to work on the following host platforms: 114 115 ================== ===================== ============= 116 OS Arch Compilers 117 ================== ===================== ============= 118 AuroraUX x86\ :sup:`1` GCC 119 Linux x86\ :sup:`1` GCC, Clang 120 Linux amd64 GCC, Clang 121 Linux ARM\ :sup:`4` GCC, Clang 122 Linux PowerPC GCC, Clang 123 Solaris V9 (Ultrasparc) GCC 124 FreeBSD x86\ :sup:`1` GCC, Clang 125 FreeBSD amd64 GCC, Clang 126 MacOS X\ :sup:`2` PowerPC GCC 127 MacOS X x86 GCC, Clang 128 Cygwin/Win32 x86\ :sup:`1, 3` GCC 129 Windows x86\ :sup:`1` Visual Studio 130 Windows x64 x86-64 Visual Studio 131 ================== ===================== ============= 132 133 .. note:: 134 135 #. Code generation supported for Pentium processors and up 136 #. Code generation supported for 32-bit ABI only 137 #. To use LLVM modules on Win32-based system, you may configure LLVM 138 with ``--enable-shared``. 139 #. MCJIT not working well pre-v7, old JIT engine not supported any more. 140 141 Note that you will need about 1-3 GB of space for a full LLVM build in Debug 142 mode, depending on the system (it is so large because of all the debugging 143 information and the fact that the libraries are statically linked into multiple 144 tools). If you do not need many of the tools and you are space-conscious, you 145 can pass ``ONLY_TOOLS="tools you need"`` to make. The Release build requires 146 considerably less space. 147 148 The LLVM suite *may* compile on other platforms, but it is not guaranteed to do 149 so. If compilation is successful, the LLVM utilities should be able to 150 assemble, disassemble, analyze, and optimize LLVM bitcode. Code generation 151 should work as well, although the generated native code may not work on your 152 platform. 153 154 Software 155 -------- 156 157 Compiling LLVM requires that you have several software packages installed. The 158 table below lists those required packages. The Package column is the usual name 159 for the software package that LLVM depends on. The Version column provides 160 "known to work" versions of the package. The Notes column describes how LLVM 161 uses the package and provides other details. 162 163 =========================================================== ============ ========================================== 164 Package Version Notes 165 =========================================================== ============ ========================================== 166 `GNU Make <http://savannah.gnu.org/projects/make>`_ 3.79, 3.79.1 Makefile/build processor 167 `GCC <http://gcc.gnu.org/>`_ >=4.7.0 C/C++ compiler\ :sup:`1` 168 `python <http://www.python.org/>`_ >=2.5 Automated test suite\ :sup:`2` 169 `GNU M4 <http://savannah.gnu.org/projects/m4>`_ 1.4 Macro processor for configuration\ :sup:`3` 170 `GNU Autoconf <http://www.gnu.org/software/autoconf/>`_ 2.60 Configuration script builder\ :sup:`3` 171 `GNU Automake <http://www.gnu.org/software/automake/>`_ 1.9.6 aclocal macro generator\ :sup:`3` 172 `libtool <http://savannah.gnu.org/projects/libtool>`_ 1.5.22 Shared library manager\ :sup:`3` 173 `zlib <http://zlib.net>`_ >=1.2.3.4 Compression library\ :sup:`4` 174 =========================================================== ============ ========================================== 175 176 .. note:: 177 178 #. Only the C and C++ languages are needed so there's no need to build the 179 other languages for LLVM's purposes. See `below` for specific version 180 info. 181 #. Only needed if you want to run the automated test suite in the 182 ``llvm/test`` directory. 183 #. If you want to make changes to the configure scripts, you will need GNU 184 autoconf (2.60), and consequently, GNU M4 (version 1.4 or higher). You 185 will also need automake (1.9.6). We only use aclocal from that package. 186 #. Optional, adds compression / uncompression capabilities to selected LLVM 187 tools. 188 189 Additionally, your compilation host is expected to have the usual plethora of 190 Unix utilities. Specifically: 191 192 * **ar** --- archive library builder 193 * **bzip2** --- bzip2 command for distribution generation 194 * **bunzip2** --- bunzip2 command for distribution checking 195 * **chmod** --- change permissions on a file 196 * **cat** --- output concatenation utility 197 * **cp** --- copy files 198 * **date** --- print the current date/time 199 * **echo** --- print to standard output 200 * **egrep** --- extended regular expression search utility 201 * **find** --- find files/dirs in a file system 202 * **grep** --- regular expression search utility 203 * **gzip** --- gzip command for distribution generation 204 * **gunzip** --- gunzip command for distribution checking 205 * **install** --- install directories/files 206 * **mkdir** --- create a directory 207 * **mv** --- move (rename) files 208 * **ranlib** --- symbol table builder for archive libraries 209 * **rm** --- remove (delete) files and directories 210 * **sed** --- stream editor for transforming output 211 * **sh** --- Bourne shell for make build scripts 212 * **tar** --- tape archive for distribution generation 213 * **test** --- test things in file system 214 * **unzip** --- unzip command for distribution checking 215 * **zip** --- zip command for distribution generation 216 217 .. _below: 218 .. _check here: 219 220 Host C++ Toolchain, both Compiler and Standard Library 221 ------------------------------------------------------ 222 223 LLVM is very demanding of the host C++ compiler, and as such tends to expose 224 bugs in the compiler. We are also planning to follow improvements and 225 developments in the C++ language and library reasonably closely. As such, we 226 require a modern host C++ toolchain, both compiler and standard library, in 227 order to build LLVM. 228 229 For the most popular host toolchains we check for specific minimum versions in 230 our build systems: 231 232 * Clang 3.1 233 * GCC 4.7 234 * Visual Studio 2012 235 236 Anything older than these toolchains *may* work, but will require forcing the 237 build system with a special option and is not really a supported host platform. 238 Also note that older versions of these compilers have often crashed or 239 miscompiled LLVM. 240 241 For less widely used host toolchains such as ICC or xlC, be aware that a very 242 recent version may be required to support all of the C++ features used in LLVM. 243 244 We track certain versions of software that are *known* to fail when used as 245 part of the host toolchain. These even include linkers at times. 246 247 **GCC 4.6.3 on ARM**: Miscompiles ``llvm-readobj`` at ``-O3``. A test failure 248 in ``test/Object/readobj-shared-object.test`` is one symptom of the problem. 249 250 **GNU ld 2.16.X**. Some 2.16.X versions of the ld linker will produce very long 251 warning messages complaining that some "``.gnu.linkonce.t.*``" symbol was 252 defined in a discarded section. You can safely ignore these messages as they are 253 erroneous and the linkage is correct. These messages disappear using ld 2.17. 254 255 **GNU binutils 2.17**: Binutils 2.17 contains `a bug 256 <http://sourceware.org/bugzilla/show_bug.cgi?id=3111>`__ which causes huge link 257 times (minutes instead of seconds) when building LLVM. We recommend upgrading 258 to a newer version (2.17.50.0.4 or later). 259 260 **GNU Binutils 2.19.1 Gold**: This version of Gold contained `a bug 261 <http://sourceware.org/bugzilla/show_bug.cgi?id=9836>`__ which causes 262 intermittent failures when building LLVM with position independent code. The 263 symptom is an error about cyclic dependencies. We recommend upgrading to a 264 newer version of Gold. 265 266 **Clang 3.0 with libstdc++ 4.7.x**: a few Linux distributions (Ubuntu 12.10, 267 Fedora 17) have both Clang 3.0 and libstdc++ 4.7 in their repositories. Clang 268 3.0 does not implement a few builtins that are used in this library. We 269 recommend using the system GCC to compile LLVM and Clang in this case. 270 271 **Clang 3.0 on Mageia 2**. There's a packaging issue: Clang can not find at 272 least some (``cxxabi.h``) libstdc++ headers. 273 274 **Clang in C++11 mode and libstdc++ 4.7.2**. This version of libstdc++ 275 contained `a bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53841>`__ which 276 causes Clang to refuse to compile condition_variable header file. At the time 277 of writing, this breaks LLD build. 278 279 Getting a Modern Host C++ Toolchain 280 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 281 282 This section mostly applies to Linux and older BSDs. On Mac OS X, you should 283 have a sufficiently modern Xcode, or you will likely need to upgrade until you 284 do. On Windows, just use Visual Studio 2012 as the host compiler, it is 285 explicitly supported and widely available. FreeBSD 10.0 and newer have a modern 286 Clang as the system compiler. 287 288 However, some Linux distributions and some other or older BSDs sometimes have 289 extremely old versions of GCC. These steps attempt to help you upgrade you 290 compiler even on such a system. However, if at all possible, we encourage you 291 to use a recent version of a distribution with a modern system compiler that 292 meets these requirements. Note that it is tempting to to install a prior 293 version of Clang and libc++ to be the host compiler, however libc++ was not 294 well tested or set up to build on Linux until relatively recently. As 295 a consequence, this guide suggests just using libstdc++ and a modern GCC as the 296 initial host in a bootstrap, and then using Clang (and potentially libc++). 297 298 The first step is to get a recent GCC toolchain installed. The most common 299 distribution on which users have struggled with the version requirements is 300 Ubuntu Precise, 12.04 LTS. For this distribution, one easy option is to install 301 the `toolchain testing PPA`_ and use it to install a modern GCC. There is 302 a really nice discussions of this on the `ask ubuntu stack exchange`_. However, 303 not all users can use PPAs and there are many other distributions, so it may be 304 necessary (or just useful, if you're here you *are* doing compiler development 305 after all) to build and install GCC from source. It is also quite easy to do 306 these days. 307 308 .. _toolchain testing PPA: 309 https://launchpad.net/~ubuntu-toolchain-r/+archive/test 310 .. _ask ubuntu stack exchange: 311 http://askubuntu.com/questions/271388/how-to-install-gcc-4-8-in-ubuntu-12-04-from-the-terminal 312 313 Easy steps for installing GCC 4.8.2: 314 315 .. code-block:: console 316 317 % wget ftp://ftp.gnu.org/gnu/gcc/gcc-4.8.2/gcc-4.8.2.tar.bz2 318 % tar -xvjf gcc-4.8.2.tar.bz2 319 % cd gcc-4.8.2 320 % ./contrib/download_prerequisites 321 % cd .. 322 % mkdir gcc-4.8.2-build 323 % cd gcc-4.8.2-build 324 % $PWD/../gcc-4.8.2/configure --prefix=$HOME/toolchains --enable-languages=c,c++ 325 % make -j$(nproc) 326 % make install 327 328 For more details, check out the excellent `GCC wiki entry`_, where I got most 329 of this information from. 330 331 .. _GCC wiki entry: 332 http://gcc.gnu.org/wiki/InstallingGCC 333 334 Once you have a GCC toolchain, use it as your host compiler. Things should 335 generally "just work". You may need to pass a special linker flag, 336 ``-Wl,-rpath,$HOME/toolchains/lib`` or some variant thereof to get things to 337 find the libstdc++ DSO in this toolchain. 338 339 When you build Clang, you will need to give *it* access to modern C++11 340 standard library in order to use it as your new host in part of a bootstrap. 341 There are two easy ways to do this, either build (and install) libc++ along 342 with Clang and then use it with the ``-stdlib=libc++`` compile and link flag, 343 or install Clang into the same prefix (``$HOME/toolchains`` above) as GCC. 344 Clang will look within its own prefix for libstdc++ and use it if found. You 345 can also add an explicit prefix for Clang to look in for a GCC toolchain with 346 the ``--gcc-toolchain=/opt/my/gcc/prefix`` flag, passing it to both compile and 347 link commands when using your just-built-Clang to bootstrap. 348 349 .. _Getting Started with LLVM: 350 351 Getting Started with LLVM 352 ========================= 353 354 The remainder of this guide is meant to get you up and running with LLVM and to 355 give you some basic information about the LLVM environment. 356 357 The later sections of this guide describe the `general layout`_ of the LLVM 358 source tree, a `simple example`_ using the LLVM tool chain, and `links`_ to find 359 more information about LLVM or to get help via e-mail. 360 361 Terminology and Notation 362 ------------------------ 363 364 Throughout this manual, the following names are used to denote paths specific to 365 the local system and working environment. *These are not environment variables 366 you need to set but just strings used in the rest of this document below*. In 367 any of the examples below, simply replace each of these names with the 368 appropriate pathname on your local system. All these paths are absolute: 369 370 ``SRC_ROOT`` 371 372 This is the top level directory of the LLVM source tree. 373 374 ``OBJ_ROOT`` 375 376 This is the top level directory of the LLVM object tree (i.e. the tree where 377 object files and compiled programs will be placed. It can be the same as 378 SRC_ROOT). 379 380 .. _Setting Up Your Environment: 381 382 Setting Up Your Environment 383 --------------------------- 384 385 In order to compile and use LLVM, you may need to set some environment 386 variables. 387 388 ``LLVM_LIB_SEARCH_PATH=/path/to/your/bitcode/libs`` 389 390 [Optional] This environment variable helps LLVM linking tools find the 391 locations of your bitcode libraries. It is provided only as a convenience 392 since you can specify the paths using the -L options of the tools and the 393 C/C++ front-end will automatically use the bitcode files installed in its 394 ``lib`` directory. 395 396 Unpacking the LLVM Archives 397 --------------------------- 398 399 If you have the LLVM distribution, you will need to unpack it before you can 400 begin to compile it. LLVM is distributed as a set of two files: the LLVM suite 401 and the LLVM GCC front end compiled for your platform. There is an additional 402 test suite that is optional. Each file is a TAR archive that is compressed with 403 the gzip program. 404 405 The files are as follows, with *x.y* marking the version number: 406 407 ``llvm-x.y.tar.gz`` 408 409 Source release for the LLVM libraries and tools. 410 411 ``llvm-test-x.y.tar.gz`` 412 413 Source release for the LLVM test-suite. 414 415 .. _checkout: 416 417 Checkout LLVM from Subversion 418 ----------------------------- 419 420 If you have access to our Subversion repository, you can get a fresh copy of the 421 entire source code. All you need to do is check it out from Subversion as 422 follows: 423 424 * ``cd where-you-want-llvm-to-live`` 425 * Read-Only: ``svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm`` 426 * Read-Write:``svn co https://user@llvm.org/svn/llvm-project/llvm/trunk llvm`` 427 428 This will create an '``llvm``' directory in the current directory and fully 429 populate it with the LLVM source code, Makefiles, test directories, and local 430 copies of documentation files. 431 432 If you want to get a specific release (as opposed to the most recent revision), 433 you can checkout it from the '``tags``' directory (instead of '``trunk``'). The 434 following releases are located in the following subdirectories of the '``tags``' 435 directory: 436 437 * Release 3.4: **RELEASE_34/final** 438 * Release 3.3: **RELEASE_33/final** 439 * Release 3.2: **RELEASE_32/final** 440 * Release 3.1: **RELEASE_31/final** 441 * Release 3.0: **RELEASE_30/final** 442 * Release 2.9: **RELEASE_29/final** 443 * Release 2.8: **RELEASE_28** 444 * Release 2.7: **RELEASE_27** 445 * Release 2.6: **RELEASE_26** 446 * Release 2.5: **RELEASE_25** 447 * Release 2.4: **RELEASE_24** 448 * Release 2.3: **RELEASE_23** 449 * Release 2.2: **RELEASE_22** 450 * Release 2.1: **RELEASE_21** 451 * Release 2.0: **RELEASE_20** 452 * Release 1.9: **RELEASE_19** 453 * Release 1.8: **RELEASE_18** 454 * Release 1.7: **RELEASE_17** 455 * Release 1.6: **RELEASE_16** 456 * Release 1.5: **RELEASE_15** 457 * Release 1.4: **RELEASE_14** 458 * Release 1.3: **RELEASE_13** 459 * Release 1.2: **RELEASE_12** 460 * Release 1.1: **RELEASE_11** 461 * Release 1.0: **RELEASE_1** 462 463 If you would like to get the LLVM test suite (a separate package as of 1.4), you 464 get it from the Subversion repository: 465 466 .. code-block:: console 467 468 % cd llvm/projects 469 % svn co http://llvm.org/svn/llvm-project/test-suite/trunk test-suite 470 471 By placing it in the ``llvm/projects``, it will be automatically configured by 472 the LLVM configure script as well as automatically updated when you run ``svn 473 update``. 474 475 Git Mirror 476 ---------- 477 478 Git mirrors are available for a number of LLVM subprojects. These mirrors sync 479 automatically with each Subversion commit and contain all necessary git-svn 480 marks (so, you can recreate git-svn metadata locally). Note that right now 481 mirrors reflect only ``trunk`` for each project. You can do the read-only Git 482 clone of LLVM via: 483 484 .. code-block:: console 485 486 % git clone http://llvm.org/git/llvm.git 487 488 If you want to check out clang too, run: 489 490 .. code-block:: console 491 492 % cd llvm/tools 493 % git clone http://llvm.org/git/clang.git 494 495 If you want to check out compiler-rt too, run: 496 497 .. code-block:: console 498 499 % cd llvm/projects 500 % git clone http://llvm.org/git/compiler-rt.git 501 502 If you want to check out the Test Suite Source Code (optional), run: 503 504 .. code-block:: console 505 506 % cd llvm/projects 507 % git clone http://llvm.org/git/test-suite.git 508 509 Since the upstream repository is in Subversion, you should use ``git 510 pull --rebase`` instead of ``git pull`` to avoid generating a non-linear history 511 in your clone. To configure ``git pull`` to pass ``--rebase`` by default on the 512 master branch, run the following command: 513 514 .. code-block:: console 515 516 % git config branch.master.rebase true 517 518 Sending patches with Git 519 ^^^^^^^^^^^^^^^^^^^^^^^^ 520 521 Please read `Developer Policy <DeveloperPolicy.html#one-off-patches>`_, too. 522 523 Assume ``master`` points the upstream and ``mybranch`` points your working 524 branch, and ``mybranch`` is rebased onto ``master``. At first you may check 525 sanity of whitespaces: 526 527 .. code-block:: console 528 529 % git diff --check master..mybranch 530 531 The easiest way to generate a patch is as below: 532 533 .. code-block:: console 534 535 % git diff master..mybranch > /path/to/mybranch.diff 536 537 It is a little different from svn-generated diff. git-diff-generated diff has 538 prefixes like ``a/`` and ``b/``. Don't worry, most developers might know it 539 could be accepted with ``patch -p1 -N``. 540 541 But you may generate patchset with git-format-patch. It generates by-each-commit 542 patchset. To generate patch files to attach to your article: 543 544 .. code-block:: console 545 546 % git format-patch --no-attach master..mybranch -o /path/to/your/patchset 547 548 If you would like to send patches directly, you may use git-send-email or 549 git-imap-send. Here is an example to generate the patchset in Gmail's [Drafts]. 550 551 .. code-block:: console 552 553 % git format-patch --attach master..mybranch --stdout | git imap-send 554 555 Then, your .git/config should have [imap] sections. 556 557 .. code-block:: ini 558 559 [imap] 560 host = imaps://imap.gmail.com 561 user = your.gmail.account (a] gmail.com 562 pass = himitsu! 563 port = 993 564 sslverify = false 565 ; in English 566 folder = "[Gmail]/Drafts" 567 ; example for Japanese, "Modified UTF-7" encoded. 568 folder = "[Gmail]/&Tgtm+DBN-" 569 ; example for Traditional Chinese 570 folder = "[Gmail]/&g0l6Pw-" 571 572 For developers to work with git-svn 573 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 574 575 To set up clone from which you can submit code using ``git-svn``, run: 576 577 .. code-block:: console 578 579 % git clone http://llvm.org/git/llvm.git 580 % cd llvm 581 % git svn init https://llvm.org/svn/llvm-project/llvm/trunk --username=<username> 582 % git config svn-remote.svn.fetch :refs/remotes/origin/master 583 % git svn rebase -l # -l avoids fetching ahead of the git mirror. 584 585 # If you have clang too: 586 % cd tools 587 % git clone http://llvm.org/git/clang.git 588 % cd clang 589 % git svn init https://llvm.org/svn/llvm-project/cfe/trunk --username=<username> 590 % git config svn-remote.svn.fetch :refs/remotes/origin/master 591 % git svn rebase -l 592 593 Likewise for compiler-rt and test-suite. 594 595 To update this clone without generating git-svn tags that conflict with the 596 upstream Git repo, run: 597 598 .. code-block:: console 599 600 % git fetch && (cd tools/clang && git fetch) # Get matching revisions of both trees. 601 % git checkout master 602 % git svn rebase -l 603 % (cd tools/clang && 604 git checkout master && 605 git svn rebase -l) 606 607 Likewise for compiler-rt and test-suite. 608 609 This leaves your working directories on their master branches, so you'll need to 610 ``checkout`` each working branch individually and ``rebase`` it on top of its 611 parent branch. 612 613 For those who wish to be able to update an llvm repo/revert patches easily using 614 git-svn, please look in the directory for the scripts ``git-svnup`` and 615 ``git-svnrevert``. 616 617 To perform the aforementioned update steps go into your source directory and 618 just type ``git-svnup`` or ``git svnup`` and everything will just work. 619 620 If one wishes to revert a commit with git-svn, but do not want the git hash to 621 escape into the commit message, one can use the script ``git-svnrevert`` or 622 ``git svnrevert`` which will take in the git hash for the commit you want to 623 revert, look up the appropriate svn revision, and output a message where all 624 references to the git hash have been replaced with the svn revision. 625 626 To commit back changes via git-svn, use ``git svn dcommit``: 627 628 .. code-block:: console 629 630 % git svn dcommit 631 632 Note that git-svn will create one SVN commit for each Git commit you have pending, 633 so squash and edit each commit before executing ``dcommit`` to make sure they all 634 conform to the coding standards and the developers' policy. 635 636 On success, ``dcommit`` will rebase against the HEAD of SVN, so to avoid conflict, 637 please make sure your current branch is up-to-date (via fetch/rebase) before 638 proceeding. 639 640 The git-svn metadata can get out of sync after you mess around with branches and 641 ``dcommit``. When that happens, ``git svn dcommit`` stops working, complaining 642 about files with uncommitted changes. The fix is to rebuild the metadata: 643 644 .. code-block:: console 645 646 % rm -rf .git/svn 647 % git svn rebase -l 648 649 Please, refer to the Git-SVN manual (``man git-svn``) for more information. 650 651 Local LLVM Configuration 652 ------------------------ 653 654 Once checked out from the Subversion repository, the LLVM suite source code must 655 be configured via the ``configure`` script. This script sets variables in the 656 various ``*.in`` files, most notably ``llvm/Makefile.config`` and 657 ``llvm/include/Config/config.h``. It also populates *OBJ_ROOT* with the 658 Makefiles needed to begin building LLVM. 659 660 The following environment variables are used by the ``configure`` script to 661 configure the build system: 662 663 +------------+-----------------------------------------------------------+ 664 | Variable | Purpose | 665 +============+===========================================================+ 666 | CC | Tells ``configure`` which C compiler to use. By default, | 667 | | ``configure`` will check ``PATH`` for ``clang`` and GCC C | 668 | | compilers (in this order). Use this variable to override | 669 | | ``configure``\'s default behavior. | 670 +------------+-----------------------------------------------------------+ 671 | CXX | Tells ``configure`` which C++ compiler to use. By | 672 | | default, ``configure`` will check ``PATH`` for | 673 | | ``clang++`` and GCC C++ compilers (in this order). Use | 674 | | this variable to override ``configure``'s default | 675 | | behavior. | 676 +------------+-----------------------------------------------------------+ 677 678 The following options can be used to set or enable LLVM specific options: 679 680 ``--enable-optimized`` 681 682 Enables optimized compilation (debugging symbols are removed and GCC 683 optimization flags are enabled). Note that this is the default setting if you 684 are using the LLVM distribution. The default behavior of a Subversion 685 checkout is to use an unoptimized build (also known as a debug build). 686 687 ``--enable-debug-runtime`` 688 689 Enables debug symbols in the runtime libraries. The default is to strip debug 690 symbols from the runtime libraries. 691 692 ``--enable-jit`` 693 694 Compile the Just In Time (JIT) compiler functionality. This is not available 695 on all platforms. The default is dependent on platform, so it is best to 696 explicitly enable it if you want it. 697 698 ``--enable-targets=target-option`` 699 700 Controls which targets will be built and linked into llc. The default value 701 for ``target_options`` is "all" which builds and links all available targets. 702 The "host" target is selected as the target of the build host. You can also 703 specify a comma separated list of target names that you want available in llc. 704 The target names use all lower case. The current set of targets is: 705 706 ``aarch64, arm, arm64, cpp, hexagon, mips, mipsel, mips64, mips64el, msp430, 707 powerpc, nvptx, r600, sparc, systemz, x86, x86_64, xcore``. 708 709 ``--enable-doxygen`` 710 711 Look for the doxygen program and enable construction of doxygen based 712 documentation from the source code. This is disabled by default because 713 generating the documentation can take a long time and producess 100s of 714 megabytes of output. 715 716 ``--with-udis86`` 717 718 LLVM can use external disassembler library for various purposes (now it's used 719 only for examining code produced by JIT). This option will enable usage of 720 `udis86 <http://udis86.sourceforge.net/>`_ x86 (both 32 and 64 bits) 721 disassembler library. 722 723 To configure LLVM, follow these steps: 724 725 #. Change directory into the object root directory: 726 727 .. code-block:: console 728 729 % cd OBJ_ROOT 730 731 #. Run the ``configure`` script located in the LLVM source tree: 732 733 .. code-block:: console 734 735 % SRC_ROOT/configure --prefix=/install/path [other options] 736 737 Compiling the LLVM Suite Source Code 738 ------------------------------------ 739 740 Once you have configured LLVM, you can build it. There are three types of 741 builds: 742 743 Debug Builds 744 745 These builds are the default when one is using a Subversion checkout and 746 types ``gmake`` (unless the ``--enable-optimized`` option was used during 747 configuration). The build system will compile the tools and libraries with 748 debugging information. To get a Debug Build using the LLVM distribution the 749 ``--disable-optimized`` option must be passed to ``configure``. 750 751 Release (Optimized) Builds 752 753 These builds are enabled with the ``--enable-optimized`` option to 754 ``configure`` or by specifying ``ENABLE_OPTIMIZED=1`` on the ``gmake`` command 755 line. For these builds, the build system will compile the tools and libraries 756 with GCC optimizations enabled and strip debugging information from the 757 libraries and executables it generates. Note that Release Builds are default 758 when using an LLVM distribution. 759 760 Profile Builds 761 762 These builds are for use with profiling. They compile profiling information 763 into the code for use with programs like ``gprof``. Profile builds must be 764 started by specifying ``ENABLE_PROFILING=1`` on the ``gmake`` command line. 765 766 Once you have LLVM configured, you can build it by entering the *OBJ_ROOT* 767 directory and issuing the following command: 768 769 .. code-block:: console 770 771 % gmake 772 773 If the build fails, please `check here`_ to see if you are using a version of 774 GCC that is known not to compile LLVM. 775 776 If you have multiple processors in your machine, you may wish to use some of the 777 parallel build options provided by GNU Make. For example, you could use the 778 command: 779 780 .. code-block:: console 781 782 % gmake -j2 783 784 There are several special targets which are useful when working with the LLVM 785 source code: 786 787 ``gmake clean`` 788 789 Removes all files generated by the build. This includes object files, 790 generated C/C++ files, libraries, and executables. 791 792 ``gmake dist-clean`` 793 794 Removes everything that ``gmake clean`` does, but also removes files generated 795 by ``configure``. It attempts to return the source tree to the original state 796 in which it was shipped. 797 798 ``gmake install`` 799 800 Installs LLVM header files, libraries, tools, and documentation in a hierarchy 801 under ``$PREFIX``, specified with ``./configure --prefix=[dir]``, which 802 defaults to ``/usr/local``. 803 804 ``gmake -C runtime install-bytecode`` 805 806 Assuming you built LLVM into $OBJDIR, when this command is run, it will 807 install bitcode libraries into the GCC front end's bitcode library directory. 808 If you need to update your bitcode libraries, this is the target to use once 809 you've built them. 810 811 Please see the `Makefile Guide <MakefileGuide.html>`_ for further details on 812 these ``make`` targets and descriptions of other targets available. 813 814 It is also possible to override default values from ``configure`` by declaring 815 variables on the command line. The following are some examples: 816 817 ``gmake ENABLE_OPTIMIZED=1`` 818 819 Perform a Release (Optimized) build. 820 821 ``gmake ENABLE_OPTIMIZED=1 DISABLE_ASSERTIONS=1`` 822 823 Perform a Release (Optimized) build without assertions enabled. 824 825 ``gmake ENABLE_OPTIMIZED=0`` 826 827 Perform a Debug build. 828 829 ``gmake ENABLE_PROFILING=1`` 830 831 Perform a Profiling build. 832 833 ``gmake VERBOSE=1`` 834 835 Print what ``gmake`` is doing on standard output. 836 837 ``gmake TOOL_VERBOSE=1`` 838 839 Ask each tool invoked by the makefiles to print out what it is doing on 840 the standard output. This also implies ``VERBOSE=1``. 841 842 Every directory in the LLVM object tree includes a ``Makefile`` to build it and 843 any subdirectories that it contains. Entering any directory inside the LLVM 844 object tree and typing ``gmake`` should rebuild anything in or below that 845 directory that is out of date. 846 847 This does not apply to building the documentation. 848 LLVM's (non-Doxygen) documentation is produced with the 849 `Sphinx <http://sphinx-doc.org/>`_ documentation generation system. 850 There are some HTML documents that have not yet been converted to the new 851 system (which uses the easy-to-read and easy-to-write 852 `reStructuredText <http://sphinx-doc.org/rest.html>`_ plaintext markup 853 language). 854 The generated documentation is built in the ``SRC_ROOT/docs`` directory using 855 a special makefile. 856 For instructions on how to install Sphinx, see 857 `Sphinx Introduction for LLVM Developers 858 <http://lld.llvm.org/sphinx_intro.html>`_. 859 After following the instructions there for installing Sphinx, build the LLVM 860 HTML documentation by doing the following: 861 862 .. code-block:: console 863 864 $ cd SRC_ROOT/docs 865 $ make -f Makefile.sphinx 866 867 This creates a ``_build/html`` sub-directory with all of the HTML files, not 868 just the generated ones. 869 This directory corresponds to ``llvm.org/docs``. 870 For example, ``_build/html/SphinxQuickstartTemplate.html`` corresponds to 871 ``llvm.org/docs/SphinxQuickstartTemplate.html``. 872 The :doc:`SphinxQuickstartTemplate` is useful when creating a new document. 873 874 Cross-Compiling LLVM 875 -------------------- 876 877 It is possible to cross-compile LLVM itself. That is, you can create LLVM 878 executables and libraries to be hosted on a platform different from the platform 879 where they are built (a Canadian Cross build). To configure a cross-compile, 880 supply the configure script with ``--build`` and ``--host`` options that are 881 different. The values of these options must be legal target triples that your 882 GCC compiler supports. 883 884 The result of such a build is executables that are not runnable on on the build 885 host (--build option) but can be executed on the compile host (--host option). 886 887 Check :doc:`HowToCrossCompileLLVM` and `Clang docs on how to cross-compile in general 888 <http://clang.llvm.org/docs/CrossCompilation.html>`_ for more information 889 about cross-compiling. 890 891 The Location of LLVM Object Files 892 --------------------------------- 893 894 The LLVM build system is capable of sharing a single LLVM source tree among 895 several LLVM builds. Hence, it is possible to build LLVM for several different 896 platforms or configurations using the same source tree. 897 898 This is accomplished in the typical autoconf manner: 899 900 * Change directory to where the LLVM object files should live: 901 902 .. code-block:: console 903 904 % cd OBJ_ROOT 905 906 * Run the ``configure`` script found in the LLVM source directory: 907 908 .. code-block:: console 909 910 % SRC_ROOT/configure 911 912 The LLVM build will place files underneath *OBJ_ROOT* in directories named after 913 the build type: 914 915 Debug Builds with assertions enabled (the default) 916 917 Tools 918 919 ``OBJ_ROOT/Debug+Asserts/bin`` 920 921 Libraries 922 923 ``OBJ_ROOT/Debug+Asserts/lib`` 924 925 Release Builds 926 927 Tools 928 929 ``OBJ_ROOT/Release/bin`` 930 931 Libraries 932 933 ``OBJ_ROOT/Release/lib`` 934 935 Profile Builds 936 937 Tools 938 939 ``OBJ_ROOT/Profile/bin`` 940 941 Libraries 942 943 ``OBJ_ROOT/Profile/lib`` 944 945 Optional Configuration Items 946 ---------------------------- 947 948 If you're running on a Linux system that supports the `binfmt_misc 949 <http://en.wikipedia.org/wiki/binfmt_misc>`_ 950 module, and you have root access on the system, you can set your system up to 951 execute LLVM bitcode files directly. To do this, use commands like this (the 952 first command may not be required if you are already using the module): 953 954 .. code-block:: console 955 956 % mount -t binfmt_misc none /proc/sys/fs/binfmt_misc 957 % echo ':llvm:M::BC::/path/to/lli:' > /proc/sys/fs/binfmt_misc/register 958 % chmod u+x hello.bc (if needed) 959 % ./hello.bc 960 961 This allows you to execute LLVM bitcode files directly. On Debian, you can also 962 use this command instead of the 'echo' command above: 963 964 .. code-block:: console 965 966 % sudo update-binfmts --install llvm /path/to/lli --magic 'BC' 967 968 .. _Program Layout: 969 .. _general layout: 970 971 Program Layout 972 ============== 973 974 One useful source of information about the LLVM source base is the LLVM `doxygen 975 <http://www.doxygen.org/>`_ documentation available at 976 `<http://llvm.org/doxygen/>`_. The following is a brief introduction to code 977 layout: 978 979 ``llvm/examples`` 980 ----------------- 981 982 This directory contains some simple examples of how to use the LLVM IR and JIT. 983 984 ``llvm/include`` 985 ---------------- 986 987 This directory contains public header files exported from the LLVM library. The 988 three main subdirectories of this directory are: 989 990 ``llvm/include/llvm`` 991 992 This directory contains all of the LLVM specific header files. This directory 993 also has subdirectories for different portions of LLVM: ``Analysis``, 994 ``CodeGen``, ``Target``, ``Transforms``, etc... 995 996 ``llvm/include/llvm/Support`` 997 998 This directory contains generic support libraries that are provided with LLVM 999 but not necessarily specific to LLVM. For example, some C++ STL utilities and 1000 a Command Line option processing library store their header files here. 1001 1002 ``llvm/include/llvm/Config`` 1003 1004 This directory contains header files configured by the ``configure`` script. 1005 They wrap "standard" UNIX and C header files. Source code can include these 1006 header files which automatically take care of the conditional #includes that 1007 the ``configure`` script generates. 1008 1009 ``llvm/lib`` 1010 ------------ 1011 1012 This directory contains most of the source files of the LLVM system. In LLVM, 1013 almost all code exists in libraries, making it very easy to share code among the 1014 different `tools`_. 1015 1016 ``llvm/lib/VMCore/`` 1017 1018 This directory holds the core LLVM source files that implement core classes 1019 like Instruction and BasicBlock. 1020 1021 ``llvm/lib/AsmParser/`` 1022 1023 This directory holds the source code for the LLVM assembly language parser 1024 library. 1025 1026 ``llvm/lib/Bitcode/`` 1027 1028 This directory holds code for reading and write LLVM bitcode. 1029 1030 ``llvm/lib/Analysis/`` 1031 1032 This directory contains a variety of different program analyses, such as 1033 Dominator Information, Call Graphs, Induction Variables, Interval 1034 Identification, Natural Loop Identification, etc. 1035 1036 ``llvm/lib/Transforms/`` 1037 1038 This directory contains the source code for the LLVM to LLVM program 1039 transformations, such as Aggressive Dead Code Elimination, Sparse Conditional 1040 Constant Propagation, Inlining, Loop Invariant Code Motion, Dead Global 1041 Elimination, and many others. 1042 1043 ``llvm/lib/Target/`` 1044 1045 This directory contains files that describe various target architectures for 1046 code generation. For example, the ``llvm/lib/Target/X86`` directory holds the 1047 X86 machine description while ``llvm/lib/Target/ARM`` implements the ARM 1048 backend. 1049 1050 ``llvm/lib/CodeGen/`` 1051 1052 This directory contains the major parts of the code generator: Instruction 1053 Selector, Instruction Scheduling, and Register Allocation. 1054 1055 ``llvm/lib/MC/`` 1056 1057 (FIXME: T.B.D.) 1058 1059 ``llvm/lib/Debugger/`` 1060 1061 This directory contains the source level debugger library that makes it 1062 possible to instrument LLVM programs so that a debugger could identify source 1063 code locations at which the program is executing. 1064 1065 ``llvm/lib/ExecutionEngine/`` 1066 1067 This directory contains libraries for executing LLVM bitcode directly at 1068 runtime in both interpreted and JIT compiled fashions. 1069 1070 ``llvm/lib/Support/`` 1071 1072 This directory contains the source code that corresponds to the header files 1073 located in ``llvm/include/ADT/`` and ``llvm/include/Support/``. 1074 1075 ``llvm/projects`` 1076 ----------------- 1077 1078 This directory contains projects that are not strictly part of LLVM but are 1079 shipped with LLVM. This is also the directory where you should create your own 1080 LLVM-based projects. 1081 1082 ``llvm/runtime`` 1083 ---------------- 1084 1085 This directory contains libraries which are compiled into LLVM bitcode and used 1086 when linking programs with the Clang front end. Most of these libraries are 1087 skeleton versions of real libraries; for example, libc is a stripped down 1088 version of glibc. 1089 1090 Unlike the rest of the LLVM suite, this directory needs the LLVM GCC front end 1091 to compile. 1092 1093 ``llvm/test`` 1094 ------------- 1095 1096 This directory contains feature and regression tests and other basic sanity 1097 checks on the LLVM infrastructure. These are intended to run quickly and cover a 1098 lot of territory without being exhaustive. 1099 1100 ``test-suite`` 1101 -------------- 1102 1103 This is not a directory in the normal llvm module; it is a separate Subversion 1104 module that must be checked out (usually to ``projects/test-suite``). This 1105 module contains a comprehensive correctness, performance, and benchmarking test 1106 suite for LLVM. It is a separate Subversion module because not every LLVM user 1107 is interested in downloading or building such a comprehensive test suite. For 1108 further details on this test suite, please see the :doc:`Testing Guide 1109 <TestingGuide>` document. 1110 1111 .. _tools: 1112 1113 ``llvm/tools`` 1114 -------------- 1115 1116 The **tools** directory contains the executables built out of the libraries 1117 above, which form the main part of the user interface. You can always get help 1118 for a tool by typing ``tool_name -help``. The following is a brief introduction 1119 to the most important tools. More detailed information is in 1120 the `Command Guide <CommandGuide/index.html>`_. 1121 1122 ``bugpoint`` 1123 1124 ``bugpoint`` is used to debug optimization passes or code generation backends 1125 by narrowing down the given test case to the minimum number of passes and/or 1126 instructions that still cause a problem, whether it is a crash or 1127 miscompilation. See `<HowToSubmitABug.html>`_ for more information on using 1128 ``bugpoint``. 1129 1130 ``llvm-ar`` 1131 1132 The archiver produces an archive containing the given LLVM bitcode files, 1133 optionally with an index for faster lookup. 1134 1135 ``llvm-as`` 1136 1137 The assembler transforms the human readable LLVM assembly to LLVM bitcode. 1138 1139 ``llvm-dis`` 1140 1141 The disassembler transforms the LLVM bitcode to human readable LLVM assembly. 1142 1143 ``llvm-link`` 1144 1145 ``llvm-link``, not surprisingly, links multiple LLVM modules into a single 1146 program. 1147 1148 ``lli`` 1149 1150 ``lli`` is the LLVM interpreter, which can directly execute LLVM bitcode 1151 (although very slowly...). For architectures that support it (currently x86, 1152 Sparc, and PowerPC), by default, ``lli`` will function as a Just-In-Time 1153 compiler (if the functionality was compiled in), and will execute the code 1154 *much* faster than the interpreter. 1155 1156 ``llc`` 1157 1158 ``llc`` is the LLVM backend compiler, which translates LLVM bitcode to a 1159 native code assembly file or to C code (with the ``-march=c`` option). 1160 1161 ``opt`` 1162 1163 ``opt`` reads LLVM bitcode, applies a series of LLVM to LLVM transformations 1164 (which are specified on the command line), and then outputs the resultant 1165 bitcode. The '``opt -help``' command is a good way to get a list of the 1166 program transformations available in LLVM. 1167 1168 ``opt`` can also be used to run a specific analysis on an input LLVM bitcode 1169 file and print out the results. It is primarily useful for debugging 1170 analyses, or familiarizing yourself with what an analysis does. 1171 1172 ``llvm/utils`` 1173 -------------- 1174 1175 This directory contains utilities for working with LLVM source code, and some of 1176 the utilities are actually required as part of the build process because they 1177 are code generators for parts of LLVM infrastructure. 1178 1179 1180 ``codegen-diff`` 1181 1182 ``codegen-diff`` is a script that finds differences between code that LLC 1183 generates and code that LLI generates. This is a useful tool if you are 1184 debugging one of them, assuming that the other generates correct output. For 1185 the full user manual, run ```perldoc codegen-diff'``. 1186 1187 ``emacs/`` 1188 1189 The ``emacs`` directory contains syntax-highlighting files which will work 1190 with Emacs and XEmacs editors, providing syntax highlighting support for LLVM 1191 assembly files and TableGen description files. For information on how to use 1192 the syntax files, consult the ``README`` file in that directory. 1193 1194 ``getsrcs.sh`` 1195 1196 The ``getsrcs.sh`` script finds and outputs all non-generated source files, 1197 which is useful if one wishes to do a lot of development across directories 1198 and does not want to individually find each file. One way to use it is to run, 1199 for example: ``xemacs `utils/getsources.sh``` from the top of your LLVM source 1200 tree. 1201 1202 ``llvmgrep`` 1203 1204 This little tool performs an ``egrep -H -n`` on each source file in LLVM and 1205 passes to it a regular expression provided on ``llvmgrep``'s command 1206 line. This is a very efficient way of searching the source base for a 1207 particular regular expression. 1208 1209 ``makellvm`` 1210 1211 The ``makellvm`` script compiles all files in the current directory and then 1212 compiles and links the tool that is the first argument. For example, assuming 1213 you are in the directory ``llvm/lib/Target/Sparc``, if ``makellvm`` is in your 1214 path, simply running ``makellvm llc`` will make a build of the current 1215 directory, switch to directory ``llvm/tools/llc`` and build it, causing a 1216 re-linking of LLC. 1217 1218 ``TableGen/`` 1219 1220 The ``TableGen`` directory contains the tool used to generate register 1221 descriptions, instruction set descriptions, and even assemblers from common 1222 TableGen description files. 1223 1224 ``vim/`` 1225 1226 The ``vim`` directory contains syntax-highlighting files which will work with 1227 the VIM editor, providing syntax highlighting support for LLVM assembly files 1228 and TableGen description files. For information on how to use the syntax 1229 files, consult the ``README`` file in that directory. 1230 1231 .. _simple example: 1232 1233 An Example Using the LLVM Tool Chain 1234 ==================================== 1235 1236 This section gives an example of using LLVM with the Clang front end. 1237 1238 Example with clang 1239 ------------------ 1240 1241 #. First, create a simple C file, name it 'hello.c': 1242 1243 .. code-block:: c 1244 1245 #include <stdio.h> 1246 1247 int main() { 1248 printf("hello world\n"); 1249 return 0; 1250 } 1251 1252 #. Next, compile the C file into a native executable: 1253 1254 .. code-block:: console 1255 1256 % clang hello.c -o hello 1257 1258 .. note:: 1259 1260 Clang works just like GCC by default. The standard -S and -c arguments 1261 work as usual (producing a native .s or .o file, respectively). 1262 1263 #. Next, compile the C file into an LLVM bitcode file: 1264 1265 .. code-block:: console 1266 1267 % clang -O3 -emit-llvm hello.c -c -o hello.bc 1268 1269 The -emit-llvm option can be used with the -S or -c options to emit an LLVM 1270 ``.ll`` or ``.bc`` file (respectively) for the code. This allows you to use 1271 the `standard LLVM tools <CommandGuide/index.html>`_ on the bitcode file. 1272 1273 #. Run the program in both forms. To run the program, use: 1274 1275 .. code-block:: console 1276 1277 % ./hello 1278 1279 and 1280 1281 .. code-block:: console 1282 1283 % lli hello.bc 1284 1285 The second examples shows how to invoke the LLVM JIT, :doc:`lli 1286 <CommandGuide/lli>`. 1287 1288 #. Use the ``llvm-dis`` utility to take a look at the LLVM assembly code: 1289 1290 .. code-block:: console 1291 1292 % llvm-dis < hello.bc | less 1293 1294 #. Compile the program to native assembly using the LLC code generator: 1295 1296 .. code-block:: console 1297 1298 % llc hello.bc -o hello.s 1299 1300 #. Assemble the native assembly language file into a program: 1301 1302 .. code-block:: console 1303 1304 % /opt/SUNWspro/bin/cc -xarch=v9 hello.s -o hello.native # On Solaris 1305 1306 % gcc hello.s -o hello.native # On others 1307 1308 #. Execute the native code program: 1309 1310 .. code-block:: console 1311 1312 % ./hello.native 1313 1314 Note that using clang to compile directly to native code (i.e. when the 1315 ``-emit-llvm`` option is not present) does steps 6/7/8 for you. 1316 1317 Common Problems 1318 =============== 1319 1320 If you are having problems building or using LLVM, or if you have any other 1321 general questions about LLVM, please consult the `Frequently Asked 1322 Questions <FAQ.html>`_ page. 1323 1324 .. _links: 1325 1326 Links 1327 ===== 1328 1329 This document is just an **introduction** on how to use LLVM to do some simple 1330 things... there are many more interesting and complicated things that you can do 1331 that aren't documented here (but we'll gladly accept a patch if you want to 1332 write something up!). For more information about LLVM, check out: 1333 1334 * `LLVM Homepage <http://llvm.org/>`_ 1335 * `LLVM Doxygen Tree <http://llvm.org/doxygen/>`_ 1336 * `Starting a Project that Uses LLVM <http://llvm.org/docs/Projects.html>`_ 1337