1 //===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/CodeGen/BackendUtil.h"
11 #include "clang/Basic/Diagnostic.h"
12 #include "clang/Basic/LangOptions.h"
13 #include "clang/Basic/TargetOptions.h"
14 #include "clang/Frontend/CodeGenOptions.h"
15 #include "clang/Frontend/FrontendDiagnostic.h"
16 #include "clang/Frontend/Utils.h"
17 #include "clang/Lex/HeaderSearchOptions.h"
18 #include "llvm/ADT/SmallSet.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/ADT/Triple.h"
22 #include "llvm/Analysis/TargetLibraryInfo.h"
23 #include "llvm/Analysis/TargetTransformInfo.h"
24 #include "llvm/Bitcode/BitcodeReader.h"
25 #include "llvm/Bitcode/BitcodeWriter.h"
26 #include "llvm/Bitcode/BitcodeWriterPass.h"
27 #include "llvm/CodeGen/RegAllocRegistry.h"
28 #include "llvm/CodeGen/SchedulerRegistry.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/IRPrintingPasses.h"
31 #include "llvm/IR/LegacyPassManager.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ModuleSummaryIndex.h"
34 #include "llvm/IR/Verifier.h"
35 #include "llvm/LTO/LTOBackend.h"
36 #include "llvm/MC/MCAsmInfo.h"
37 #include "llvm/MC/SubtargetFeature.h"
38 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
39 #include "llvm/Passes/PassBuilder.h"
40 #include "llvm/Support/CommandLine.h"
41 #include "llvm/Support/MemoryBuffer.h"
42 #include "llvm/Support/PrettyStackTrace.h"
43 #include "llvm/Support/TargetRegistry.h"
44 #include "llvm/Support/Timer.h"
45 #include "llvm/Support/raw_ostream.h"
46 #include "llvm/Target/TargetMachine.h"
47 #include "llvm/Target/TargetOptions.h"
48 #include "llvm/Target/TargetSubtargetInfo.h"
49 #include "llvm/Transforms/Coroutines.h"
50 #include "llvm/Transforms/IPO.h"
51 #include "llvm/Transforms/IPO/AlwaysInliner.h"
52 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
53 #include "llvm/Transforms/Instrumentation.h"
54 #include "llvm/Transforms/ObjCARC.h"
55 #include "llvm/Transforms/Scalar.h"
56 #include "llvm/Transforms/Scalar/GVN.h"
57 #include "llvm/Transforms/Utils/SymbolRewriter.h"
59 using namespace clang;
64 class EmitAssemblyHelper {
65 DiagnosticsEngine &Diags;
66 const HeaderSearchOptions &HSOpts;
67 const CodeGenOptions &CodeGenOpts;
68 const clang::TargetOptions &TargetOpts;
69 const LangOptions &LangOpts;
72 Timer CodeGenerationTime;
74 std::unique_ptr<raw_pwrite_stream> OS;
77 TargetIRAnalysis getTargetIRAnalysis() const {
79 return TM->getTargetIRAnalysis();
81 return TargetIRAnalysis();
84 /// Set LLVM command line options passed through -backend-option.
85 void setCommandLineOpts();
87 void CreatePasses(legacy::PassManager &MPM, legacy::FunctionPassManager &FPM);
89 /// Generates the TargetMachine.
90 /// Leaves TM unchanged if it is unable to create the target machine.
91 /// Some of our clang tests specify triples which are not built
92 /// into clang. This is okay because these tests check the generated
93 /// IR, and they require DataLayout which depends on the triple.
94 /// In this case, we allow this method to fail and not report an error.
95 /// When MustCreateTM is used, we print an error if we are unable to load
96 /// the requested target.
97 void CreateTargetMachine(bool MustCreateTM);
99 /// Add passes necessary to emit assembly or LLVM IR.
101 /// \return True on success.
102 bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
103 raw_pwrite_stream &OS);
106 EmitAssemblyHelper(DiagnosticsEngine &_Diags,
107 const HeaderSearchOptions &HeaderSearchOpts,
108 const CodeGenOptions &CGOpts,
109 const clang::TargetOptions &TOpts,
110 const LangOptions &LOpts, Module *M)
111 : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
112 TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
113 CodeGenerationTime("codegen", "Code Generation Time") {}
115 ~EmitAssemblyHelper() {
116 if (CodeGenOpts.DisableFree)
117 BuryPointer(std::move(TM));
120 std::unique_ptr<TargetMachine> TM;
122 void EmitAssembly(BackendAction Action,
123 std::unique_ptr<raw_pwrite_stream> OS);
125 void EmitAssemblyWithNewPassManager(BackendAction Action,
126 std::unique_ptr<raw_pwrite_stream> OS);
129 // We need this wrapper to access LangOpts and CGOpts from extension functions
130 // that we add to the PassManagerBuilder.
131 class PassManagerBuilderWrapper : public PassManagerBuilder {
133 PassManagerBuilderWrapper(const CodeGenOptions &CGOpts,
134 const LangOptions &LangOpts)
135 : PassManagerBuilder(), CGOpts(CGOpts), LangOpts(LangOpts) {}
136 const CodeGenOptions &getCGOpts() const { return CGOpts; }
137 const LangOptions &getLangOpts() const { return LangOpts; }
139 const CodeGenOptions &CGOpts;
140 const LangOptions &LangOpts;
145 static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
146 if (Builder.OptLevel > 0)
147 PM.add(createObjCARCAPElimPass());
150 static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
151 if (Builder.OptLevel > 0)
152 PM.add(createObjCARCExpandPass());
155 static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM) {
156 if (Builder.OptLevel > 0)
157 PM.add(createObjCARCOptPass());
160 static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder,
161 legacy::PassManagerBase &PM) {
162 PM.add(createAddDiscriminatorsPass());
165 static void addBoundsCheckingPass(const PassManagerBuilder &Builder,
166 legacy::PassManagerBase &PM) {
167 PM.add(createBoundsCheckingPass());
170 static void addSanitizerCoveragePass(const PassManagerBuilder &Builder,
171 legacy::PassManagerBase &PM) {
172 const PassManagerBuilderWrapper &BuilderWrapper =
173 static_cast<const PassManagerBuilderWrapper&>(Builder);
174 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
175 SanitizerCoverageOptions Opts;
177 static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
178 Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
179 Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
180 Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
181 Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
182 Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
183 Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
184 Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
185 Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
186 PM.add(createSanitizerCoverageModulePass(Opts));
189 static void addAddressSanitizerPasses(const PassManagerBuilder &Builder,
190 legacy::PassManagerBase &PM) {
191 const PassManagerBuilderWrapper &BuilderWrapper =
192 static_cast<const PassManagerBuilderWrapper&>(Builder);
193 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
194 bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Address);
195 bool UseAfterScope = CGOpts.SanitizeAddressUseAfterScope;
196 PM.add(createAddressSanitizerFunctionPass(/*CompileKernel*/ false, Recover,
198 PM.add(createAddressSanitizerModulePass(/*CompileKernel*/false, Recover));
201 static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder,
202 legacy::PassManagerBase &PM) {
203 PM.add(createAddressSanitizerFunctionPass(
204 /*CompileKernel*/ true,
205 /*Recover*/ true, /*UseAfterScope*/ false));
206 PM.add(createAddressSanitizerModulePass(/*CompileKernel*/true,
210 static void addMemorySanitizerPass(const PassManagerBuilder &Builder,
211 legacy::PassManagerBase &PM) {
212 const PassManagerBuilderWrapper &BuilderWrapper =
213 static_cast<const PassManagerBuilderWrapper&>(Builder);
214 const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
215 int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
216 bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Memory);
217 PM.add(createMemorySanitizerPass(TrackOrigins, Recover));
219 // MemorySanitizer inserts complex instrumentation that mostly follows
220 // the logic of the original code, but operates on "shadow" values.
221 // It can benefit from re-running some general purpose optimization passes.
222 if (Builder.OptLevel > 0) {
223 PM.add(createEarlyCSEPass());
224 PM.add(createReassociatePass());
225 PM.add(createLICMPass());
226 PM.add(createGVNPass());
227 PM.add(createInstructionCombiningPass());
228 PM.add(createDeadStoreEliminationPass());
232 static void addThreadSanitizerPass(const PassManagerBuilder &Builder,
233 legacy::PassManagerBase &PM) {
234 PM.add(createThreadSanitizerPass());
237 static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
238 legacy::PassManagerBase &PM) {
239 const PassManagerBuilderWrapper &BuilderWrapper =
240 static_cast<const PassManagerBuilderWrapper&>(Builder);
241 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
242 PM.add(createDataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
245 static void addEfficiencySanitizerPass(const PassManagerBuilder &Builder,
246 legacy::PassManagerBase &PM) {
247 const PassManagerBuilderWrapper &BuilderWrapper =
248 static_cast<const PassManagerBuilderWrapper&>(Builder);
249 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
250 EfficiencySanitizerOptions Opts;
251 if (LangOpts.Sanitize.has(SanitizerKind::EfficiencyCacheFrag))
252 Opts.ToolType = EfficiencySanitizerOptions::ESAN_CacheFrag;
253 else if (LangOpts.Sanitize.has(SanitizerKind::EfficiencyWorkingSet))
254 Opts.ToolType = EfficiencySanitizerOptions::ESAN_WorkingSet;
255 PM.add(createEfficiencySanitizerPass(Opts));
258 static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
259 const CodeGenOptions &CodeGenOpts) {
260 TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);
261 if (!CodeGenOpts.SimplifyLibCalls)
262 TLII->disableAllFunctions();
264 // Disable individual libc/libm calls in TargetLibraryInfo.
266 for (auto &FuncName : CodeGenOpts.getNoBuiltinFuncs())
267 if (TLII->getLibFunc(FuncName, F))
268 TLII->setUnavailable(F);
271 switch (CodeGenOpts.getVecLib()) {
272 case CodeGenOptions::Accelerate:
273 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
275 case CodeGenOptions::SVML:
276 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
284 static void addSymbolRewriterPass(const CodeGenOptions &Opts,
285 legacy::PassManager *MPM) {
286 llvm::SymbolRewriter::RewriteDescriptorList DL;
288 llvm::SymbolRewriter::RewriteMapParser MapParser;
289 for (const auto &MapFile : Opts.RewriteMapFiles)
290 MapParser.parse(MapFile, &DL);
292 MPM->add(createRewriteSymbolsPass(DL));
295 void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
296 legacy::FunctionPassManager &FPM) {
297 // Handle disabling of all LLVM passes, where we want to preserve the
298 // internal module before any optimization.
299 if (CodeGenOpts.DisableLLVMPasses)
302 PassManagerBuilderWrapper PMBuilder(CodeGenOpts, LangOpts);
304 // Figure out TargetLibraryInfo. This needs to be added to MPM and FPM
305 // manually (and not via PMBuilder), since some passes (eg. InstrProfiling)
306 // are inserted before PMBuilder ones - they'd get the default-constructed
307 // TLI with an unknown target otherwise.
308 Triple TargetTriple(TheModule->getTargetTriple());
309 std::unique_ptr<TargetLibraryInfoImpl> TLII(
310 createTLII(TargetTriple, CodeGenOpts));
312 // At O0 and O1 we only run the always inliner which is more efficient. At
313 // higher optimization levels we run the normal inliner.
314 if (CodeGenOpts.OptimizationLevel <= 1) {
315 bool InsertLifetimeIntrinsics = (CodeGenOpts.OptimizationLevel != 0 &&
316 !CodeGenOpts.DisableLifetimeMarkers);
317 PMBuilder.Inliner = createAlwaysInlinerLegacyPass(InsertLifetimeIntrinsics);
319 PMBuilder.Inliner = createFunctionInliningPass(
320 CodeGenOpts.OptimizationLevel, CodeGenOpts.OptimizeSize);
323 PMBuilder.OptLevel = CodeGenOpts.OptimizationLevel;
324 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
325 PMBuilder.BBVectorize = CodeGenOpts.VectorizeBB;
326 PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
327 PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
329 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
330 PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
331 PMBuilder.PrepareForThinLTO = CodeGenOpts.EmitSummaryIndex;
332 PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
333 PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;
335 MPM.add(new TargetLibraryInfoWrapperPass(*TLII));
337 // Add target-specific passes that need to run as early as possible.
339 PMBuilder.addExtension(
340 PassManagerBuilder::EP_EarlyAsPossible,
341 [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
342 TM->addEarlyAsPossiblePasses(PM);
345 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
346 addAddDiscriminatorsPass);
348 // In ObjC ARC mode, add the main ARC optimization passes.
349 if (LangOpts.ObjCAutoRefCount) {
350 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
351 addObjCARCExpandPass);
352 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
353 addObjCARCAPElimPass);
354 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
358 if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
359 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
360 addBoundsCheckingPass);
361 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
362 addBoundsCheckingPass);
365 if (CodeGenOpts.SanitizeCoverageType ||
366 CodeGenOpts.SanitizeCoverageIndirectCalls ||
367 CodeGenOpts.SanitizeCoverageTraceCmp) {
368 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
369 addSanitizerCoveragePass);
370 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
371 addSanitizerCoveragePass);
374 if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
375 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
376 addAddressSanitizerPasses);
377 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
378 addAddressSanitizerPasses);
381 if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
382 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
383 addKernelAddressSanitizerPasses);
384 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
385 addKernelAddressSanitizerPasses);
388 if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
389 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
390 addMemorySanitizerPass);
391 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
392 addMemorySanitizerPass);
395 if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
396 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
397 addThreadSanitizerPass);
398 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
399 addThreadSanitizerPass);
402 if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
403 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
404 addDataFlowSanitizerPass);
405 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
406 addDataFlowSanitizerPass);
409 if (LangOpts.CoroutinesTS)
410 addCoroutinePassesToExtensionPoints(PMBuilder);
412 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Efficiency)) {
413 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
414 addEfficiencySanitizerPass);
415 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
416 addEfficiencySanitizerPass);
419 // Set up the per-function pass manager.
420 FPM.add(new TargetLibraryInfoWrapperPass(*TLII));
421 if (CodeGenOpts.VerifyModule)
422 FPM.add(createVerifierPass());
424 // Set up the per-module pass manager.
425 if (!CodeGenOpts.RewriteMapFiles.empty())
426 addSymbolRewriterPass(CodeGenOpts, &MPM);
428 if (!CodeGenOpts.DisableGCov &&
429 (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
430 // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
431 // LLVM's -default-gcov-version flag is set to something invalid.
433 Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
434 Options.EmitData = CodeGenOpts.EmitGcovArcs;
435 memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
436 Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
437 Options.NoRedZone = CodeGenOpts.DisableRedZone;
438 Options.FunctionNamesInData =
439 !CodeGenOpts.CoverageNoFunctionNamesInData;
440 Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
441 MPM.add(createGCOVProfilerPass(Options));
442 if (CodeGenOpts.getDebugInfo() == codegenoptions::NoDebugInfo)
443 MPM.add(createStripSymbolsPass(true));
446 if (CodeGenOpts.hasProfileClangInstr()) {
447 InstrProfOptions Options;
448 Options.NoRedZone = CodeGenOpts.DisableRedZone;
449 Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
450 MPM.add(createInstrProfilingLegacyPass(Options));
452 if (CodeGenOpts.hasProfileIRInstr()) {
453 PMBuilder.EnablePGOInstrGen = true;
454 if (!CodeGenOpts.InstrProfileOutput.empty())
455 PMBuilder.PGOInstrGen = CodeGenOpts.InstrProfileOutput;
457 PMBuilder.PGOInstrGen = "default_%m.profraw";
459 if (CodeGenOpts.hasProfileIRUse())
460 PMBuilder.PGOInstrUse = CodeGenOpts.ProfileInstrumentUsePath;
462 if (!CodeGenOpts.SampleProfileFile.empty())
463 PMBuilder.PGOSampleUse = CodeGenOpts.SampleProfileFile;
465 PMBuilder.populateFunctionPassManager(FPM);
466 PMBuilder.populateModulePassManager(MPM);
469 void EmitAssemblyHelper::setCommandLineOpts() {
470 SmallVector<const char *, 16> BackendArgs;
471 BackendArgs.push_back("clang"); // Fake program name.
472 if (!CodeGenOpts.DebugPass.empty()) {
473 BackendArgs.push_back("-debug-pass");
474 BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
476 if (!CodeGenOpts.LimitFloatPrecision.empty()) {
477 BackendArgs.push_back("-limit-float-precision");
478 BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
480 for (const std::string &BackendOption : CodeGenOpts.BackendOptions)
481 BackendArgs.push_back(BackendOption.c_str());
482 BackendArgs.push_back(nullptr);
483 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
487 void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
488 // Create the TargetMachine for generating code.
490 std::string Triple = TheModule->getTargetTriple();
491 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
494 Diags.Report(diag::err_fe_unable_to_create_target) << Error;
499 llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
500 .Case("small", llvm::CodeModel::Small)
501 .Case("kernel", llvm::CodeModel::Kernel)
502 .Case("medium", llvm::CodeModel::Medium)
503 .Case("large", llvm::CodeModel::Large)
504 .Case("default", llvm::CodeModel::Default)
506 assert(CodeModel != ~0u && "invalid code model!");
507 llvm::CodeModel::Model CM = static_cast<llvm::CodeModel::Model>(CodeModel);
509 std::string FeaturesStr =
510 llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
512 // Keep this synced with the equivalent code in tools/driver/cc1as_main.cpp.
513 llvm::Optional<llvm::Reloc::Model> RM;
514 RM = llvm::StringSwitch<llvm::Reloc::Model>(CodeGenOpts.RelocationModel)
515 .Case("static", llvm::Reloc::Static)
516 .Case("pic", llvm::Reloc::PIC_)
517 .Case("ropi", llvm::Reloc::ROPI)
518 .Case("rwpi", llvm::Reloc::RWPI)
519 .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
520 .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC);
521 assert(RM.hasValue() && "invalid PIC model!");
523 CodeGenOpt::Level OptLevel;
524 switch (CodeGenOpts.OptimizationLevel) {
526 llvm_unreachable("Invalid optimization level!");
528 OptLevel = CodeGenOpt::None;
531 OptLevel = CodeGenOpt::Less;
534 OptLevel = CodeGenOpt::Default;
537 OptLevel = CodeGenOpt::Aggressive;
541 llvm::TargetOptions Options;
543 Options.ThreadModel =
544 llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
545 .Case("posix", llvm::ThreadModel::POSIX)
546 .Case("single", llvm::ThreadModel::Single);
548 // Set float ABI type.
549 assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
550 CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
551 "Invalid Floating Point ABI!");
552 Options.FloatABIType =
553 llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
554 .Case("soft", llvm::FloatABI::Soft)
555 .Case("softfp", llvm::FloatABI::Soft)
556 .Case("hard", llvm::FloatABI::Hard)
557 .Default(llvm::FloatABI::Default);
559 // Set FP fusion mode.
560 switch (CodeGenOpts.getFPContractMode()) {
561 case CodeGenOptions::FPC_Off:
562 Options.AllowFPOpFusion = llvm::FPOpFusion::Strict;
564 case CodeGenOptions::FPC_On:
565 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
567 case CodeGenOptions::FPC_Fast:
568 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
572 Options.UseInitArray = CodeGenOpts.UseInitArray;
573 Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
574 Options.CompressDebugSections = CodeGenOpts.CompressDebugSections;
575 Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
578 Options.EABIVersion = llvm::StringSwitch<llvm::EABI>(TargetOpts.EABIVersion)
579 .Case("4", llvm::EABI::EABI4)
580 .Case("5", llvm::EABI::EABI5)
581 .Case("gnu", llvm::EABI::GNU)
582 .Default(llvm::EABI::Default);
584 if (LangOpts.SjLjExceptions)
585 Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
587 Options.LessPreciseFPMADOption = CodeGenOpts.LessPreciseFPMAD;
588 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
589 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
590 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
591 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
592 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
593 Options.FunctionSections = CodeGenOpts.FunctionSections;
594 Options.DataSections = CodeGenOpts.DataSections;
595 Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
596 Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
597 Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
599 Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
600 Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
601 Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
602 Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
603 Options.MCOptions.MCIncrementalLinkerCompatible =
604 CodeGenOpts.IncrementalLinkerCompatible;
605 Options.MCOptions.MCPIECopyRelocations = CodeGenOpts.PIECopyRelocations;
606 Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
607 Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
608 Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
609 Options.MCOptions.ABIName = TargetOpts.ABI;
610 for (const auto &Entry : HSOpts.UserEntries)
611 if (!Entry.IsFramework &&
612 (Entry.Group == frontend::IncludeDirGroup::Quoted ||
613 Entry.Group == frontend::IncludeDirGroup::Angled ||
614 Entry.Group == frontend::IncludeDirGroup::System))
615 Options.MCOptions.IASSearchPaths.push_back(
616 Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
618 TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
619 Options, RM, CM, OptLevel));
622 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
623 BackendAction Action,
624 raw_pwrite_stream &OS) {
626 llvm::Triple TargetTriple(TheModule->getTargetTriple());
627 std::unique_ptr<TargetLibraryInfoImpl> TLII(
628 createTLII(TargetTriple, CodeGenOpts));
629 CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));
631 // Normal mode, emit a .s or .o file by running the code generator. Note,
632 // this also adds codegenerator level optimization passes.
633 TargetMachine::CodeGenFileType CGFT = TargetMachine::CGFT_AssemblyFile;
634 if (Action == Backend_EmitObj)
635 CGFT = TargetMachine::CGFT_ObjectFile;
636 else if (Action == Backend_EmitMCNull)
637 CGFT = TargetMachine::CGFT_Null;
639 assert(Action == Backend_EmitAssembly && "Invalid action!");
641 // Add ObjC ARC final-cleanup optimizations. This is done as part of the
642 // "codegen" passes so that it isn't run multiple times when there is
643 // inlining happening.
644 if (CodeGenOpts.OptimizationLevel > 0)
645 CodeGenPasses.add(createObjCARCContractPass());
647 if (TM->addPassesToEmitFile(CodeGenPasses, OS, CGFT,
648 /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
649 Diags.Report(diag::err_fe_unable_to_interface_with_target);
656 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
657 std::unique_ptr<raw_pwrite_stream> OS) {
658 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
660 setCommandLineOpts();
662 bool UsesCodeGen = (Action != Backend_EmitNothing &&
663 Action != Backend_EmitBC &&
664 Action != Backend_EmitLL);
665 CreateTargetMachine(UsesCodeGen);
667 if (UsesCodeGen && !TM)
670 TheModule->setDataLayout(TM->createDataLayout());
672 legacy::PassManager PerModulePasses;
674 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
676 legacy::FunctionPassManager PerFunctionPasses(TheModule);
677 PerFunctionPasses.add(
678 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
680 CreatePasses(PerModulePasses, PerFunctionPasses);
682 legacy::PassManager CodeGenPasses;
684 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
687 case Backend_EmitNothing:
691 PerModulePasses.add(createBitcodeWriterPass(
692 *OS, CodeGenOpts.EmitLLVMUseLists, CodeGenOpts.EmitSummaryIndex,
693 CodeGenOpts.EmitSummaryIndex));
698 createPrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
702 if (!AddEmitPasses(CodeGenPasses, Action, *OS))
706 // Before executing passes, print the final values of the LLVM options.
707 cl::PrintOptionValues();
709 // Run passes. For now we do all passes at once, but eventually we
710 // would like to have the option of streaming code generation.
713 PrettyStackTraceString CrashInfo("Per-function optimization");
715 PerFunctionPasses.doInitialization();
716 for (Function &F : *TheModule)
717 if (!F.isDeclaration())
718 PerFunctionPasses.run(F);
719 PerFunctionPasses.doFinalization();
723 PrettyStackTraceString CrashInfo("Per-module optimization passes");
724 PerModulePasses.run(*TheModule);
728 PrettyStackTraceString CrashInfo("Code generation");
729 CodeGenPasses.run(*TheModule);
733 static PassBuilder::OptimizationLevel mapToLevel(const CodeGenOptions &Opts) {
734 switch (Opts.OptimizationLevel) {
736 llvm_unreachable("Invalid optimization level!");
739 return PassBuilder::O1;
742 switch (Opts.OptimizeSize) {
744 llvm_unreachable("Invalide optimization level for size!");
747 return PassBuilder::O2;
750 return PassBuilder::Os;
753 return PassBuilder::Oz;
757 return PassBuilder::O3;
761 /// A clean version of `EmitAssembly` that uses the new pass manager.
763 /// Not all features are currently supported in this system, but where
764 /// necessary it falls back to the legacy pass manager to at least provide
765 /// basic functionality.
767 /// This API is planned to have its functionality finished and then to replace
768 /// `EmitAssembly` at some point in the future when the default switches.
769 void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
770 BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
771 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime : nullptr);
772 setCommandLineOpts();
774 // The new pass manager always makes a target machine available to passes
775 // during construction.
776 CreateTargetMachine(/*MustCreateTM*/ true);
778 // This will already be diagnosed, just bail.
780 TheModule->setDataLayout(TM->createDataLayout());
782 PassBuilder PB(TM.get());
784 LoopAnalysisManager LAM;
785 FunctionAnalysisManager FAM;
786 CGSCCAnalysisManager CGAM;
787 ModuleAnalysisManager MAM;
789 // Register the AA manager first so that our version is the one used.
790 FAM.registerPass([&] { return PB.buildDefaultAAPipeline(); });
792 // Register all the basic analyses with the managers.
793 PB.registerModuleAnalyses(MAM);
794 PB.registerCGSCCAnalyses(CGAM);
795 PB.registerFunctionAnalyses(FAM);
796 PB.registerLoopAnalyses(LAM);
797 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
799 ModulePassManager MPM;
801 if (!CodeGenOpts.DisableLLVMPasses) {
802 if (CodeGenOpts.OptimizationLevel == 0) {
803 // Build a minimal pipeline based on the semantics required by Clang,
804 // which is just that always inlining occurs.
805 MPM.addPass(AlwaysInlinerPass());
807 // Otherwise, use the default pass pipeline. We also have to map our
808 // optimization levels into one of the distinct levels used to configure
810 PassBuilder::OptimizationLevel Level = mapToLevel(CodeGenOpts);
812 MPM = PB.buildPerModuleDefaultPipeline(Level);
816 // FIXME: We still use the legacy pass manager to do code generation. We
817 // create that pass manager here and use it as needed below.
818 legacy::PassManager CodeGenPasses;
819 bool NeedCodeGen = false;
821 // Append any output we need to the pass manager.
823 case Backend_EmitNothing:
827 MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
828 CodeGenOpts.EmitSummaryIndex,
829 CodeGenOpts.EmitSummaryIndex));
833 MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists));
836 case Backend_EmitAssembly:
837 case Backend_EmitMCNull:
838 case Backend_EmitObj:
841 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
842 if (!AddEmitPasses(CodeGenPasses, Action, *OS))
843 // FIXME: Should we handle this error differently?
848 // Before executing passes, print the final values of the LLVM options.
849 cl::PrintOptionValues();
851 // Now that we have all of the passes ready, run them.
853 PrettyStackTraceString CrashInfo("Optimizer");
854 MPM.run(*TheModule, MAM);
857 // Now if needed, run the legacy PM for codegen.
859 PrettyStackTraceString CrashInfo("Code generation");
860 CodeGenPasses.run(*TheModule);
864 static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
865 std::unique_ptr<raw_pwrite_stream> OS) {
866 StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
867 ModuleToDefinedGVSummaries;
868 CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
870 // We can simply import the values mentioned in the combined index, since
871 // we should only invoke this using the individual indexes written out
872 // via a WriteIndexesThinBackend.
873 FunctionImporter::ImportMapTy ImportList;
874 for (auto &GlobalList : *CombinedIndex) {
875 auto GUID = GlobalList.first;
876 assert(GlobalList.second.size() == 1 &&
877 "Expected individual combined index to have one summary per GUID");
878 auto &Summary = GlobalList.second[0];
879 // Skip the summaries for the importing module. These are included to
880 // e.g. record required linkage changes.
881 if (Summary->modulePath() == M->getModuleIdentifier())
883 // Doesn't matter what value we plug in to the map, just needs an entry
884 // to provoke importing by thinBackend.
885 ImportList[Summary->modulePath()][GUID] = 1;
888 std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
889 MapVector<llvm::StringRef, llvm::BitcodeModule> ModuleMap;
891 for (auto &I : ImportList) {
892 ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
893 llvm::MemoryBuffer::getFile(I.first());
895 errs() << "Error loading imported file '" << I.first()
896 << "': " << MBOrErr.getError().message() << "\n";
900 Expected<std::vector<BitcodeModule>> BMsOrErr =
901 getBitcodeModuleList(**MBOrErr);
903 handleAllErrors(BMsOrErr.takeError(), [&](ErrorInfoBase &EIB) {
904 errs() << "Error loading imported file '" << I.first()
905 << "': " << EIB.message() << '\n';
910 // The bitcode file may contain multiple modules, we want the one with a
912 bool FoundModule = false;
913 for (BitcodeModule &BM : *BMsOrErr) {
914 Expected<bool> HasSummary = BM.hasSummary();
915 if (HasSummary && *HasSummary) {
916 ModuleMap.insert({I.first(), BM});
922 errs() << "Error loading imported file '" << I.first()
923 << "': Could not find module summary\n";
927 OwnedImports.push_back(std::move(*MBOrErr));
929 auto AddStream = [&](size_t Task) {
930 return llvm::make_unique<lto::NativeObjectStream>(std::move(OS));
933 if (Error E = thinBackend(
934 Conf, 0, AddStream, *M, *CombinedIndex, ImportList,
935 ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
936 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
937 errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
942 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
943 const HeaderSearchOptions &HeaderOpts,
944 const CodeGenOptions &CGOpts,
945 const clang::TargetOptions &TOpts,
946 const LangOptions &LOpts,
947 const llvm::DataLayout &TDesc, Module *M,
948 BackendAction Action,
949 std::unique_ptr<raw_pwrite_stream> OS) {
950 if (!CGOpts.ThinLTOIndexFile.empty()) {
951 // If we are performing a ThinLTO importing compile, load the function index
952 // into memory and pass it into runThinLTOBackend, which will run the
953 // function importer and invoke LTO passes.
954 Expected<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
955 llvm::getModuleSummaryIndexForFile(CGOpts.ThinLTOIndexFile);
957 logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
958 "Error loading index file '" +
959 CGOpts.ThinLTOIndexFile + "': ");
962 std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
963 // A null CombinedIndex means we should skip ThinLTO compilation
964 // (LLVM will optionally ignore empty index files, returning null instead
966 bool DoThinLTOBackend = CombinedIndex != nullptr;
967 if (DoThinLTOBackend) {
968 runThinLTOBackend(CombinedIndex.get(), M, std::move(OS));
973 EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);
975 if (CGOpts.ExperimentalNewPassManager)
976 AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
978 AsmHelper.EmitAssembly(Action, std::move(OS));
980 // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
983 std::string DLDesc = M->getDataLayout().getStringRepresentation();
984 if (DLDesc != TDesc.getStringRepresentation()) {
985 unsigned DiagID = Diags.getCustomDiagID(
986 DiagnosticsEngine::Error, "backend data layout '%0' does not match "
987 "expected target description '%1'");
988 Diags.Report(DiagID) << DLDesc << TDesc.getStringRepresentation();
993 static const char* getSectionNameForBitcode(const Triple &T) {
994 switch (T.getObjectFormat()) {
996 return "__LLVM,__bitcode";
999 case Triple::UnknownObjectFormat:
1002 llvm_unreachable("Unimplemented ObjectFormatType");
1005 static const char* getSectionNameForCommandline(const Triple &T) {
1006 switch (T.getObjectFormat()) {
1008 return "__LLVM,__cmdline";
1011 case Triple::UnknownObjectFormat:
1014 llvm_unreachable("Unimplemented ObjectFormatType");
1017 // With -fembed-bitcode, save a copy of the llvm IR as data in the
1018 // __LLVM,__bitcode section.
1019 void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
1020 llvm::MemoryBufferRef Buf) {
1021 if (CGOpts.getEmbedBitcode() == CodeGenOptions::Embed_Off)
1024 // Save llvm.compiler.used and remote it.
1025 SmallVector<Constant*, 2> UsedArray;
1026 SmallSet<GlobalValue*, 4> UsedGlobals;
1027 Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
1028 GlobalVariable *Used = collectUsedGlobalVariables(*M, UsedGlobals, true);
1029 for (auto *GV : UsedGlobals) {
1030 if (GV->getName() != "llvm.embedded.module" &&
1031 GV->getName() != "llvm.cmdline")
1032 UsedArray.push_back(
1033 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1036 Used->eraseFromParent();
1038 // Embed the bitcode for the llvm module.
1040 ArrayRef<uint8_t> ModuleData;
1041 Triple T(M->getTargetTriple());
1042 // Create a constant that contains the bitcode.
1043 // In case of embedding a marker, ignore the input Buf and use the empty
1044 // ArrayRef. It is also legal to create a bitcode marker even Buf is empty.
1045 if (CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Marker) {
1046 if (!isBitcode((const unsigned char *)Buf.getBufferStart(),
1047 (const unsigned char *)Buf.getBufferEnd())) {
1048 // If the input is LLVM Assembly, bitcode is produced by serializing
1049 // the module. Use-lists order need to be perserved in this case.
1050 llvm::raw_string_ostream OS(Data);
1051 llvm::WriteBitcodeToFile(M, OS, /* ShouldPreserveUseListOrder */ true);
1053 ArrayRef<uint8_t>((const uint8_t *)OS.str().data(), OS.str().size());
1055 // If the input is LLVM bitcode, write the input byte stream directly.
1056 ModuleData = ArrayRef<uint8_t>((const uint8_t *)Buf.getBufferStart(),
1057 Buf.getBufferSize());
1059 llvm::Constant *ModuleConstant =
1060 llvm::ConstantDataArray::get(M->getContext(), ModuleData);
1061 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
1062 *M, ModuleConstant->getType(), true, llvm::GlobalValue::PrivateLinkage,
1064 GV->setSection(getSectionNameForBitcode(T));
1065 UsedArray.push_back(
1066 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1067 if (llvm::GlobalVariable *Old =
1068 M->getGlobalVariable("llvm.embedded.module", true)) {
1069 assert(Old->hasOneUse() &&
1070 "llvm.embedded.module can only be used once in llvm.compiler.used");
1072 Old->eraseFromParent();
1074 GV->setName("llvm.embedded.module");
1077 // Skip if only bitcode needs to be embedded.
1078 if (CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Bitcode) {
1079 // Embed command-line options.
1080 ArrayRef<uint8_t> CmdData(const_cast<uint8_t *>(CGOpts.CmdArgs.data()),
1081 CGOpts.CmdArgs.size());
1082 llvm::Constant *CmdConstant =
1083 llvm::ConstantDataArray::get(M->getContext(), CmdData);
1084 GV = new llvm::GlobalVariable(*M, CmdConstant->getType(), true,
1085 llvm::GlobalValue::PrivateLinkage,
1087 GV->setSection(getSectionNameForCommandline(T));
1088 UsedArray.push_back(
1089 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1090 if (llvm::GlobalVariable *Old =
1091 M->getGlobalVariable("llvm.cmdline", true)) {
1092 assert(Old->hasOneUse() &&
1093 "llvm.cmdline can only be used once in llvm.compiler.used");
1095 Old->eraseFromParent();
1097 GV->setName("llvm.cmdline");
1101 if (UsedArray.empty())
1104 // Recreate llvm.compiler.used.
1105 ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());
1106 auto *NewUsed = new GlobalVariable(
1107 *M, ATy, false, llvm::GlobalValue::AppendingLinkage,
1108 llvm::ConstantArray::get(ATy, UsedArray), "llvm.compiler.used");
1109 NewUsed->setSection("llvm.metadata");