Lines Matching +full:compiler +full:- +full:cache
11 `CMake <http://www.cmake.org/>`_ is a cross-platform build-generator tool. CMake
25 The Clang CMake build system supports bootstrap (aka multi-stage) builds. At a
26 high level a multi-stage build is a chain of builds that pass data from one
30 In a simple two-stage bootstrap build, we build clang using the system compiler,
31 then use that just-built clang to build clang again. In CMake this simplest form
35 .. code-block:: console
37 $ cmake -G Ninja -DCLANG_ENABLE_BOOTSTRAP=On <path to source>
41 configurations for each stage. The next series of examples utilize CMake cache
45 build using the compiler installed on the host, and a stage2 build is built
46 using the stage1 compiler. This nomenclature holds up to more stages too. In
47 general a stage*n* build is built using the output from stage*n-1*.
53 bootstrapping scenario. Apple Clang is built using a 2-stage build.
55 The stage1 compiler is a host-only compiler with some options set. The stage1
56 compiler is a balance of optimization vs build time because it is a throwaway.
57 The stage2 compiler is the fully optimized compiler intended to ship to users.
60 configuration the Apple Clang build settings are contained in CMake Cache files.
61 You can build an Apple Clang compiler using the following commands:
63 .. code-block:: console
65 $ cmake -G Ninja -C <path to clang>/cmake/caches/Apple-stage1.cmake <path to source>
66 $ ninja stage2-distribution
68 This CMake invocation configures the stage1 host compiler, and sets
69 CLANG_BOOTSTRAP_CMAKE_ARGS to pass the Apple-stage2.cmake cache script to the
72 When you build the stage2-distribution target it builds the minimal stage1
73 compiler and required tools, then configures and builds the stage2 compiler
74 based on the settings in Apple-stage2.cmake.
76 This pattern of using cache scripts to set complex settings, and specifically to
77 make later stage builds include cache scripts is common in our more advanced
80 Multi-stage PGO
83 Profile-Guided Optimizations (PGO) is a really great way to optimize the code
84 clang generates. Our multi-stage PGO builds are a workflow for generating PGO
87 At a high level, the way PGO works is that you build an instrumented compiler,
88 then you run the instrumented compiler against sample source files. While the
89 instrumented compiler runs it will output a bunch of files containing
91 you use llvm-profdata to merge the files into a single profdata file that you
94 Our PGO.cmake cache script automates that whole process. You can use it by
97 .. code-block:: console
99 $ cmake -G Ninja -C <path_to_clang>/cmake/caches/PGO.cmake <source dir>
100 $ ninja stage2-instrumented-generate-profdata
104 and you *must* have compiler-rt in your build tree.
106 This process uses any source files under the perf-training directory as training
107 data as long as the source files are marked up with LIT-style RUN lines.
109 After it finishes you can use “find . -name clang.profdata” to find it, but it
112 .. code-block:: console
114 <build dir>/tools/clang/stage2-instrumented-bins/utils/perf-training/clang.profdata
117 optimized compiler.
119 The PGO came cache has a slightly different stage naming scheme than other
120 multi-stage builds. It generates three stages; stage1, stage2-instrumented, and
121 stage2. Both of the stage2 builds are built using the stage1 compiler.
123 The PGO came cache generates the following additional targets:
125 **stage2-instrumented**
126 Builds a stage1 x86 compiler, runtime, and required tools (llvm-config,
127 llvm-profdata) then uses that compiler to build an instrumented stage2 compiler.
129 **stage2-instrumented-generate-profdata**
130 Depends on "stage2-instrumented" and will use the instrumented compiler to
131 generate profdata based on the training files in <clang>/utils/perf-training
134 Depends of "stage2-instrumented-generate-profdata" and will use the stage1
135 compiler with the stage2 profdata to build a PGO-optimized compiler.
137 **stage2-check-llvm**
138 Depends on stage2 and runs check-llvm using the stage2 compiler.
140 **stage2-check-clang**
141 Depends on stage2 and runs check-clang using the stage2 compiler.
143 **stage2-check-all**
144 Depends on stage2 and runs check-all using the stage2 compiler.
146 **stage2-test-suite**
147 Depends on stage2 and runs the test-suite using the stage3 compiler (requires
148 in-tree test-suite).
150 3-Stage Non-Determinism
153 In the ancient lore of compilers non-determinism is like the multi-headed hydra.
156 Historically one of the tests to verify that a compiler was deterministic would
158 and build a compiler (stage1), then use that compiler to rebuild the sources
159 (stage2), then you use that compiler to rebuild the sources a third time
161 this, you have a stage2 and stage3 compiler that should be bit-for-bit
164 You can perform one of these 3-stage builds with LLVM & clang using the
167 .. code-block:: console
169 $ cmake -G Ninja -C <path_to_clang>/cmake/caches/3-stage.cmake <source dir>
173 setup `here <http://lab.llvm.org:8011/builders/clang-3stage-ubuntu>`_ that runs