Lines Matching refs:compiler

37 In a simple two-stage bootstrap build, we build clang using the system compiler,
78 build using the compiler installed on the host, and a stage2 build is built
79 using the stage1 compiler. This nomenclature holds up to more stages too. In
88 The stage1 compiler is a host-only compiler with some options set. The stage1
89 compiler is a balance of optimization vs build time because it is a throwaway.
90 The stage2 compiler is the fully optimized compiler intended to ship to users.
94 You can build an Apple Clang compiler using the following commands:
101 This CMake invocation configures the stage1 host compiler, and sets
106 compiler and required tools, then configures and builds the stage2 compiler
120 At a high level, the way PGO works is that you build an instrumented compiler,
121 then you run the instrumented compiler against sample source files. While the
122 instrumented compiler runs it will output a bunch of files containing
168 LLVM Test Suite requires compiler-rt to build, so we need to add the
172 will automatically build the stage1 compiler, build the instrumented compiler
173 with the stage1 compiler, and then run the instrumented compiler against the
182 and you *must* have compiler-rt in your build tree.
195 optimized compiler.
207 stage2. Both of the stage2 builds are built using the stage1 compiler.
212   Builds a stage1 compiler, runtime, and required tools (llvm-config,
213   llvm-profdata) then uses that compiler to build an instrumented stage2 compiler.
216   Depends on stage2-instrumented and will use the instrumented compiler to
221   compiler with the stage2 profdata to build a PGO-optimized compiler.
224   Depends on stage2 and runs check-llvm using the stage2 compiler.
227   Depends on stage2 and runs check-clang using the stage2 compiler.
230   Depends on stage2 and runs check-all using the stage2 compiler.
233   Depends on stage2 and runs the test-suite using the stage2 compiler (requires
288 Historically one of the tests to verify that a compiler was deterministic would
290 and build a compiler (stage1), then use that compiler to rebuild the sources
291 (stage2), then you use that compiler to rebuild the sources a third time
293 this, you have a stage2 and stage3 compiler that should be bit-for-bit