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/CodeGen/TargetSubtargetInfo.h" 30 #include "llvm/IR/DataLayout.h" 31 #include "llvm/IR/IRPrintingPasses.h" 32 #include "llvm/IR/LegacyPassManager.h" 33 #include "llvm/IR/Module.h" 34 #include "llvm/IR/ModuleSummaryIndex.h" 35 #include "llvm/IR/Verifier.h" 36 #include "llvm/LTO/LTOBackend.h" 37 #include "llvm/MC/MCAsmInfo.h" 38 #include "llvm/MC/SubtargetFeature.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/Transforms/Coroutines.h" 49 #include "llvm/Transforms/IPO.h" 50 #include "llvm/Transforms/IPO/AlwaysInliner.h" 51 #include "llvm/Transforms/IPO/PassManagerBuilder.h" 52 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h" 53 #include "llvm/Transforms/InstCombine/InstCombine.h" 54 #include "llvm/Transforms/Instrumentation.h" 55 #include "llvm/Transforms/Instrumentation/BoundsChecking.h" 56 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h" 57 #include "llvm/Transforms/ObjCARC.h" 58 #include "llvm/Transforms/Scalar.h" 59 #include "llvm/Transforms/Scalar/GVN.h" 60 #include "llvm/Transforms/Utils.h" 61 #include "llvm/Transforms/Utils/NameAnonGlobals.h" 62 #include "llvm/Transforms/Utils/SymbolRewriter.h" 64 using namespace clang;
70 static constexpr
StringLiteral DefaultProfileGenName =
"default_%m.profraw";
72 class EmitAssemblyHelper {
80 Timer CodeGenerationTime;
82 std::unique_ptr<raw_pwrite_stream> OS;
84 TargetIRAnalysis getTargetIRAnalysis()
const {
86 return TM->getTargetIRAnalysis();
88 return TargetIRAnalysis();
91 void CreatePasses(legacy::PassManager &MPM, legacy::FunctionPassManager &FPM);
101 void CreateTargetMachine(
bool MustCreateTM);
106 bool AddEmitPasses(legacy::PassManager &CodeGenPasses,
BackendAction Action,
107 raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);
109 std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
111 auto F = llvm::make_unique<llvm::ToolOutputFile>(Path, EC,
112 llvm::sys::fs::F_None);
114 Diags.
Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
126 : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
127 TargetOpts(TOpts), LangOpts(LOpts), TheModule(M),
128 CodeGenerationTime(
"codegen",
"Code Generation Time") {}
130 ~EmitAssemblyHelper() {
131 if (CodeGenOpts.DisableFree)
135 std::unique_ptr<TargetMachine> TM;
138 std::unique_ptr<raw_pwrite_stream> OS);
141 std::unique_ptr<raw_pwrite_stream> OS);
146 class PassManagerBuilderWrapper :
public PassManagerBuilder {
148 PassManagerBuilderWrapper(
const Triple &TargetTriple,
151 : PassManagerBuilder(), TargetTriple(TargetTriple), CGOpts(CGOpts),
152 LangOpts(LangOpts) {}
153 const Triple &getTargetTriple()
const {
return TargetTriple; }
155 const LangOptions &getLangOpts()
const {
return LangOpts; }
158 const Triple &TargetTriple;
165 if (Builder.OptLevel > 0)
166 PM.add(createObjCARCAPElimPass());
170 if (Builder.OptLevel > 0)
171 PM.add(createObjCARCExpandPass());
175 if (Builder.OptLevel > 0)
176 PM.add(createObjCARCOptPass());
180 legacy::PassManagerBase &PM) {
181 PM.add(createAddDiscriminatorsPass());
185 legacy::PassManagerBase &PM) {
186 PM.add(createBoundsCheckingLegacyPass());
190 legacy::PassManagerBase &PM) {
191 const PassManagerBuilderWrapper &BuilderWrapper =
192 static_cast<const PassManagerBuilderWrapper&
>(Builder);
194 SanitizerCoverageOptions Opts;
197 Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
198 Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
199 Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
200 Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
201 Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
202 Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
203 Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
204 Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
205 Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;
206 Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;
207 Opts.PCTable = CGOpts.SanitizeCoveragePCTable;
208 Opts.StackDepth = CGOpts.SanitizeCoverageStackDepth;
209 PM.add(createSanitizerCoverageModulePass(Opts));
217 if (!CGOpts.SanitizeAddressGlobalsDeadStripping)
219 switch (T.getObjectFormat()) {
224 return CGOpts.DataSections && !CGOpts.DisableIntegratedAS;
231 legacy::PassManagerBase &PM) {
232 const PassManagerBuilderWrapper &BuilderWrapper =
233 static_cast<const PassManagerBuilderWrapper&
>(Builder);
234 const Triple &T = BuilderWrapper.getTargetTriple();
237 bool UseAfterScope = CGOpts.SanitizeAddressUseAfterScope;
239 PM.add(createAddressSanitizerFunctionPass(
false, Recover,
241 PM.add(createAddressSanitizerModulePass(
false, Recover,
246 legacy::PassManagerBase &PM) {
247 PM.add(createAddressSanitizerFunctionPass(
249 PM.add(createAddressSanitizerModulePass(
254 legacy::PassManagerBase &PM) {
255 const PassManagerBuilderWrapper &BuilderWrapper =
256 static_cast<const PassManagerBuilderWrapper &
>(Builder);
259 PM.add(createHWAddressSanitizerPass(
false, Recover));
263 legacy::PassManagerBase &PM) {
264 PM.add(createHWAddressSanitizerPass(
269 legacy::PassManagerBase &PM) {
270 const PassManagerBuilderWrapper &BuilderWrapper =
271 static_cast<const PassManagerBuilderWrapper&
>(Builder);
273 int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
275 PM.add(createMemorySanitizerPass(TrackOrigins, Recover));
280 if (Builder.OptLevel > 0) {
281 PM.add(createEarlyCSEPass());
282 PM.add(createReassociatePass());
283 PM.add(createLICMPass());
284 PM.add(createGVNPass());
285 PM.add(createInstructionCombiningPass());
286 PM.add(createDeadStoreEliminationPass());
291 legacy::PassManagerBase &PM) {
292 PM.add(createThreadSanitizerPass());
296 legacy::PassManagerBase &PM) {
297 const PassManagerBuilderWrapper &BuilderWrapper =
298 static_cast<const PassManagerBuilderWrapper&
>(Builder);
299 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
304 legacy::PassManagerBase &PM) {
305 const PassManagerBuilderWrapper &BuilderWrapper =
306 static_cast<const PassManagerBuilderWrapper&
>(Builder);
307 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
308 EfficiencySanitizerOptions Opts;
309 if (LangOpts.
Sanitize.
has(SanitizerKind::EfficiencyCacheFrag))
310 Opts.ToolType = EfficiencySanitizerOptions::ESAN_CacheFrag;
311 else if (LangOpts.
Sanitize.
has(SanitizerKind::EfficiencyWorkingSet))
312 Opts.ToolType = EfficiencySanitizerOptions::ESAN_WorkingSet;
313 PM.add(createEfficiencySanitizerPass(Opts));
316 static TargetLibraryInfoImpl *
createTLII(llvm::Triple &TargetTriple,
318 TargetLibraryInfoImpl *TLII =
new TargetLibraryInfoImpl(TargetTriple);
319 if (!CodeGenOpts.SimplifyLibCalls)
320 TLII->disableAllFunctions();
325 if (TLII->getLibFunc(FuncName, F))
326 TLII->setUnavailable(F);
329 switch (CodeGenOpts.getVecLib()) {
331 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
334 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
343 legacy::PassManager *MPM) {
344 llvm::SymbolRewriter::RewriteDescriptorList DL;
346 llvm::SymbolRewriter::RewriteMapParser MapParser;
348 MapParser.parse(MapFile, &DL);
350 MPM->add(createRewriteSymbolsPass(DL));
354 switch (CodeGenOpts.OptimizationLevel) {
356 llvm_unreachable(
"Invalid optimization level!");
364 return CodeGenOpt::Aggressive;
370 unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.
CodeModel)
371 .Case(
"small", llvm::CodeModel::Small)
372 .Case(
"kernel", llvm::CodeModel::Kernel)
373 .Case(
"medium", llvm::CodeModel::Medium)
374 .Case(
"large", llvm::CodeModel::Large)
375 .Case(
"default", ~1u)
377 assert(CodeModel != ~0u &&
"invalid code model!");
378 if (CodeModel == ~1u)
380 return static_cast<llvm::CodeModel::Model
>(CodeModel);
385 return TargetMachine::CGFT_ObjectFile;
387 return TargetMachine::CGFT_Null;
390 return TargetMachine::CGFT_AssemblyFile;
399 Options.ThreadModel =
400 llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.
ThreadModel)
401 .Case(
"posix", llvm::ThreadModel::POSIX)
402 .Case(
"single", llvm::ThreadModel::Single);
405 assert((CodeGenOpts.
FloatABI ==
"soft" || CodeGenOpts.
FloatABI ==
"softfp" ||
407 "Invalid Floating Point ABI!");
408 Options.FloatABIType =
409 llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.
FloatABI)
410 .Case(
"soft", llvm::FloatABI::Soft)
411 .Case(
"softfp", llvm::FloatABI::Soft)
412 .Case(
"hard", llvm::FloatABI::Hard)
413 .Default(llvm::FloatABI::Default);
416 switch (LangOpts.getDefaultFPContractMode()) {
420 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
423 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
426 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
430 Options.UseInitArray = CodeGenOpts.UseInitArray;
431 Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
432 Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
433 Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
438 if (LangOpts.SjLjExceptions)
439 Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
440 if (LangOpts.SEHExceptions)
441 Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
442 if (LangOpts.DWARFExceptions)
443 Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
445 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
446 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
447 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
448 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
449 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
450 Options.FunctionSections = CodeGenOpts.FunctionSections;
451 Options.DataSections = CodeGenOpts.DataSections;
452 Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
453 Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
454 Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
455 Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
456 Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
457 Options.EmitAddrsig = CodeGenOpts.Addrsig;
459 if (CodeGenOpts.EnableSplitDwarf)
461 Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
462 Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
463 Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
464 Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
465 Options.MCOptions.MCIncrementalLinkerCompatible =
466 CodeGenOpts.IncrementalLinkerCompatible;
467 Options.MCOptions.MCPIECopyRelocations = CodeGenOpts.PIECopyRelocations;
468 Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
469 Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
470 Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
471 Options.MCOptions.ABIName = TargetOpts.
ABI;
473 if (!Entry.IsFramework &&
477 Options.MCOptions.IASSearchPaths.push_back(
478 Entry.IgnoreSysRoot ? Entry.Path : HSOpts.
Sysroot + Entry.Path);
481 if (CodeGenOpts.DisableGCov)
483 if (!CodeGenOpts.EmitGcovArcs && !CodeGenOpts.EmitGcovNotes)
488 Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
489 Options.EmitData = CodeGenOpts.EmitGcovArcs;
491 Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
492 Options.NoRedZone = CodeGenOpts.DisableRedZone;
493 Options.FunctionNamesInData = !CodeGenOpts.CoverageNoFunctionNamesInData;
494 Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
498 void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
499 legacy::FunctionPassManager &FPM) {
502 if (CodeGenOpts.DisableLLVMPasses)
509 Triple TargetTriple(TheModule->getTargetTriple());
510 std::unique_ptr<TargetLibraryInfoImpl> TLII(
513 PassManagerBuilderWrapper PMBuilder(TargetTriple, CodeGenOpts, LangOpts);
517 if (CodeGenOpts.OptimizationLevel <= 1) {
518 bool InsertLifetimeIntrinsics = (CodeGenOpts.OptimizationLevel != 0 &&
519 !CodeGenOpts.DisableLifetimeMarkers);
520 PMBuilder.Inliner = createAlwaysInlinerLegacyPass(InsertLifetimeIntrinsics);
525 PMBuilder.Inliner = createFunctionInliningPass(
526 CodeGenOpts.OptimizationLevel, CodeGenOpts.OptimizeSize,
528 CodeGenOpts.PrepareForThinLTO));
531 PMBuilder.OptLevel = CodeGenOpts.OptimizationLevel;
532 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
533 PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
534 PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
536 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
537 PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
538 PMBuilder.PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;
539 PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
540 PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;
542 MPM.add(
new TargetLibraryInfoWrapperPass(*TLII));
545 TM->adjustPassManager(PMBuilder);
547 if (CodeGenOpts.DebugInfoForProfiling ||
549 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
553 if (LangOpts.ObjCAutoRefCount) {
554 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
556 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
558 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
562 if (LangOpts.CoroutinesTS)
563 addCoroutinePassesToExtensionPoints(PMBuilder);
565 if (LangOpts.
Sanitize.
has(SanitizerKind::LocalBounds)) {
566 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
568 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
572 if (CodeGenOpts.SanitizeCoverageType ||
573 CodeGenOpts.SanitizeCoverageIndirectCalls ||
574 CodeGenOpts.SanitizeCoverageTraceCmp) {
575 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
577 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
581 if (LangOpts.
Sanitize.
has(SanitizerKind::Address)) {
582 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
584 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
588 if (LangOpts.
Sanitize.
has(SanitizerKind::KernelAddress)) {
589 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
591 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
595 if (LangOpts.
Sanitize.
has(SanitizerKind::HWAddress)) {
596 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
598 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
602 if (LangOpts.
Sanitize.
has(SanitizerKind::KernelHWAddress)) {
603 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
605 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
609 if (LangOpts.
Sanitize.
has(SanitizerKind::Memory)) {
610 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
612 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
616 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread)) {
617 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
619 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
623 if (LangOpts.
Sanitize.
has(SanitizerKind::DataFlow)) {
624 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
626 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
631 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
633 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
638 FPM.add(
new TargetLibraryInfoWrapperPass(*TLII));
639 if (CodeGenOpts.VerifyModule)
640 FPM.add(createVerifierPass());
647 MPM.add(createGCOVProfilerPass(*Options));
649 MPM.add(createStripSymbolsPass(
true));
653 InstrProfOptions Options;
654 Options.NoRedZone = CodeGenOpts.DisableRedZone;
656 MPM.add(createInstrProfilingLegacyPass(Options));
659 PMBuilder.EnablePGOInstrGen =
true;
663 PMBuilder.PGOInstrGen = DefaultProfileGenName;
671 PMBuilder.populateFunctionPassManager(FPM);
672 PMBuilder.populateModulePassManager(MPM);
677 BackendArgs.push_back(
"clang");
679 BackendArgs.push_back(
"-debug-pass");
680 BackendArgs.push_back(CodeGenOpts.
DebugPass.c_str());
683 BackendArgs.push_back(
"-limit-float-precision");
686 BackendArgs.push_back(
nullptr);
687 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
691 void EmitAssemblyHelper::CreateTargetMachine(
bool MustCreateTM) {
694 std::string Triple = TheModule->getTargetTriple();
695 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
698 Diags.
Report(diag::err_fe_unable_to_create_target) <<
Error;
703 std::string FeaturesStr =
708 llvm::TargetOptions Options;
710 TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.
CPU, FeaturesStr,
711 Options, RM, CM, OptLevel));
714 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
716 raw_pwrite_stream &OS,
717 raw_pwrite_stream *DwoOS) {
719 llvm::Triple TargetTriple(TheModule->getTargetTriple());
720 std::unique_ptr<TargetLibraryInfoImpl> TLII(
722 CodeGenPasses.add(
new TargetLibraryInfoWrapperPass(*TLII));
731 if (CodeGenOpts.OptimizationLevel > 0)
732 CodeGenPasses.add(createObjCARCContractPass());
734 if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
735 !CodeGenOpts.VerifyModule)) {
736 Diags.
Report(diag::err_fe_unable_to_interface_with_target);
744 std::unique_ptr<raw_pwrite_stream> OS) {
752 CreateTargetMachine(UsesCodeGen);
754 if (UsesCodeGen && !TM)
757 TheModule->setDataLayout(TM->createDataLayout());
759 legacy::PassManager PerModulePasses;
761 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
763 legacy::FunctionPassManager PerFunctionPasses(TheModule);
764 PerFunctionPasses.add(
765 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
767 CreatePasses(PerModulePasses, PerFunctionPasses);
769 legacy::PassManager CodeGenPasses;
771 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
773 std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
780 if (CodeGenOpts.PrepareForThinLTO) {
786 PerModulePasses.add(createWriteThinLTOBitcodePass(
787 *OS, ThinLinkOS ? &ThinLinkOS->os() :
nullptr));
791 bool EmitLTOSummary =
792 (CodeGenOpts.PrepareForLTO &&
793 llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
794 llvm::Triple::Apple);
795 if (EmitLTOSummary && !TheModule->getModuleFlag(
"ThinLTO"))
796 TheModule->addModuleFlag(
Module::Error,
"ThinLTO", uint32_t(0));
799 createBitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
806 createPrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists));
815 if (!AddEmitPasses(CodeGenPasses, Action, *OS,
816 DwoOS ? &DwoOS->os() :
nullptr))
821 cl::PrintOptionValues();
827 PrettyStackTraceString CrashInfo(
"Per-function optimization");
829 PerFunctionPasses.doInitialization();
830 for (Function &F : *TheModule)
831 if (!F.isDeclaration())
832 PerFunctionPasses.run(F);
833 PerFunctionPasses.doFinalization();
837 PrettyStackTraceString CrashInfo(
"Per-module optimization passes");
838 PerModulePasses.run(*TheModule);
842 PrettyStackTraceString CrashInfo(
"Code generation");
843 CodeGenPasses.run(*TheModule);
853 switch (Opts.OptimizationLevel) {
855 llvm_unreachable(
"Invalid optimization level!");
858 return PassBuilder::O1;
861 switch (Opts.OptimizeSize) {
863 llvm_unreachable(
"Invalid optimization level for size!");
866 return PassBuilder::O2;
869 return PassBuilder::Os;
872 return PassBuilder::Oz;
876 return PassBuilder::O3;
888 void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
889 BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
895 CreateTargetMachine(
true);
899 TheModule->setDataLayout(TM->createDataLayout());
906 ? DefaultProfileGenName
908 "",
"",
true, CodeGenOpts.DebugInfoForProfiling);
912 CodeGenOpts.DebugInfoForProfiling);
916 CodeGenOpts.DebugInfoForProfiling);
917 else if (CodeGenOpts.DebugInfoForProfiling)
919 PGOOpt = PGOOptions(
"",
"",
"",
false,
true);
921 PassBuilder PB(TM.get(), PGOOpt);
923 LoopAnalysisManager LAM(CodeGenOpts.DebugPassManager);
924 FunctionAnalysisManager FAM(CodeGenOpts.DebugPassManager);
925 CGSCCAnalysisManager CGAM(CodeGenOpts.DebugPassManager);
926 ModuleAnalysisManager MAM(CodeGenOpts.DebugPassManager);
929 FAM.registerPass([&] {
return PB.buildDefaultAAPipeline(); });
933 Triple TargetTriple(TheModule->getTargetTriple());
934 std::unique_ptr<TargetLibraryInfoImpl> TLII(
936 FAM.registerPass([&] {
return TargetLibraryAnalysis(*TLII); });
937 MAM.registerPass([&] {
return TargetLibraryAnalysis(*TLII); });
940 PB.registerModuleAnalyses(MAM);
941 PB.registerCGSCCAnalyses(CGAM);
942 PB.registerFunctionAnalyses(FAM);
943 PB.registerLoopAnalyses(LAM);
944 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
946 ModulePassManager MPM(CodeGenOpts.DebugPassManager);
948 if (!CodeGenOpts.DisableLLVMPasses) {
949 bool IsThinLTO = CodeGenOpts.PrepareForThinLTO;
950 bool IsLTO = CodeGenOpts.PrepareForLTO;
952 if (CodeGenOpts.OptimizationLevel == 0) {
954 MPM.addPass(GCOVProfilerPass(*Options));
958 MPM.addPass(AlwaysInlinerPass());
961 if (LangOpts.
Sanitize.
has(SanitizerKind::LocalBounds))
962 MPM.addPass(createModuleToFunctionPassAdaptor(BoundsCheckingPass()));
965 if (IsLTO || IsThinLTO)
966 MPM.addPass(NameAnonGlobalPass());
974 if (LangOpts.
Sanitize.
has(SanitizerKind::LocalBounds))
975 PB.registerScalarOptimizerLateEPCallback(
976 [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
977 FPM.addPass(BoundsCheckingPass());
980 PB.registerPipelineStartEPCallback([Options](ModulePassManager &MPM) {
981 MPM.addPass(GCOVProfilerPass(*Options));
985 MPM = PB.buildThinLTOPreLinkDefaultPipeline(
986 Level, CodeGenOpts.DebugPassManager);
987 MPM.addPass(NameAnonGlobalPass());
989 MPM = PB.buildLTOPreLinkDefaultPipeline(Level,
990 CodeGenOpts.DebugPassManager);
991 MPM.addPass(NameAnonGlobalPass());
993 MPM = PB.buildPerModuleDefaultPipeline(Level,
994 CodeGenOpts.DebugPassManager);
1001 legacy::PassManager CodeGenPasses;
1002 bool NeedCodeGen =
false;
1003 std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
1011 if (CodeGenOpts.PrepareForThinLTO) {
1017 MPM.addPass(ThinLTOBitcodeWriterPass(*OS, ThinLinkOS ? &ThinLinkOS->os()
1022 bool EmitLTOSummary =
1023 (CodeGenOpts.PrepareForLTO &&
1024 llvm::Triple(TheModule->getTargetTriple()).getVendor() !=
1025 llvm::Triple::Apple);
1026 if (EmitLTOSummary && !TheModule->getModuleFlag(
"ThinLTO"))
1027 TheModule->addModuleFlag(
Module::Error,
"ThinLTO", uint32_t(0));
1029 MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
1035 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists));
1043 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
1049 if (!AddEmitPasses(CodeGenPasses, Action, *OS,
1050 DwoOS ? &DwoOS->os() :
nullptr))
1057 cl::PrintOptionValues();
1061 PrettyStackTraceString CrashInfo(
"Optimizer");
1062 MPM.run(*TheModule, MAM);
1067 PrettyStackTraceString CrashInfo(
"Code generation");
1068 CodeGenPasses.run(*TheModule);
1080 return BMsOrErr.takeError();
1087 return make_error<StringError>(
"Could not find module summary",
1088 inconvertibleErrorCode());
1092 for (BitcodeModule &BM : BMs) {
1094 if (LTOInfo && LTOInfo->IsThinLTO)
1105 std::unique_ptr<raw_pwrite_stream> OS,
1106 std::string SampleProfile,
1108 StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
1109 ModuleToDefinedGVSummaries;
1110 CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1117 FunctionImporter::ImportMapTy ImportList;
1118 for (
auto &GlobalList : *CombinedIndex) {
1120 if (GlobalList.second.SummaryList.empty())
1123 auto GUID = GlobalList.first;
1124 assert(GlobalList.second.SummaryList.size() == 1 &&
1125 "Expected individual combined index to have one summary per GUID");
1126 auto &Summary = GlobalList.second.SummaryList[0];
1129 if (Summary->modulePath() == M->getModuleIdentifier())
1132 ImportList[Summary->modulePath()].insert(GUID);
1135 std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
1136 MapVector<llvm::StringRef, llvm::BitcodeModule>
ModuleMap;
1138 for (
auto &I : ImportList) {
1139 ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
1140 llvm::MemoryBuffer::getFile(I.first());
1142 errs() <<
"Error loading imported file '" << I.first()
1143 <<
"': " << MBOrErr.getError().message() <<
"\n";
1149 handleAllErrors(BMOrErr.takeError(), [&](ErrorInfoBase &EIB) {
1150 errs() <<
"Error loading imported file '" << I.first()
1151 <<
"': " << EIB.message() <<
'\n';
1155 ModuleMap.insert({I.first(), *BMOrErr});
1157 OwnedImports.push_back(std::move(*MBOrErr));
1159 auto AddStream = [&](
size_t Task) {
1160 return llvm::make_unique<lto::NativeObjectStream>(std::move(OS));
1166 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1167 errs() <<
"Error setting up ThinLTO save-temps: " << EIB.message()
1172 Conf.CPU = TOpts.
CPU;
1178 Conf.SampleProfile = std::move(SampleProfile);
1179 Conf.UseNewPM = CGOpts.ExperimentalNewPassManager;
1180 Conf.DebugPassManager = CGOpts.DebugPassManager;
1181 Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
1186 Conf.PreCodeGenModuleHook = [](
size_t Task,
const Module &Mod) {
1191 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const Module &Mod) {
1192 M->
print(*OS,
nullptr, CGOpts.EmitLLVMUseLists);
1197 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const Module &Mod) {
1198 WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists);
1206 if (
Error E = thinBackend(
1207 Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
1208 ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
1209 handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1210 errs() <<
"Error running ThinLTO backend: " << EIB.message() <<
'\n';
1220 const llvm::DataLayout &TDesc,
Module *M,
1222 std::unique_ptr<raw_pwrite_stream> OS) {
1223 std::unique_ptr<llvm::Module> EmptyModule;
1232 logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
1233 "Error loading index file '" +
1237 std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
1241 if (CombinedIndex) {
1242 if (!CombinedIndex->skipModuleByDistributedBackend()) {
1244 LOpts, std::move(OS), CGOpts.SampleProfileFile,
1254 EmptyModule = llvm::make_unique<llvm::Module>(
"empty", M->getContext());
1255 EmptyModule->setTargetTriple(M->getTargetTriple());
1256 M = EmptyModule.get();
1260 EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);
1262 if (CGOpts.ExperimentalNewPassManager)
1263 AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
1265 AsmHelper.EmitAssembly(Action, std::move(OS));
1270 std::string DLDesc = M->getDataLayout().getStringRepresentation();
1271 if (DLDesc != TDesc.getStringRepresentation()) {
1274 "expected target description '%1'");
1275 Diags.
Report(DiagID) << DLDesc << TDesc.getStringRepresentation();
1281 switch (T.getObjectFormat()) {
1283 return "__LLVM,__bitcode";
1287 case Triple::UnknownObjectFormat:
1290 llvm_unreachable(
"Unimplemented ObjectFormatType");
1294 switch (T.getObjectFormat()) {
1296 return "__LLVM,__cmdline";
1300 case Triple::UnknownObjectFormat:
1303 llvm_unreachable(
"Unimplemented ObjectFormatType");
1309 llvm::MemoryBufferRef Buf) {
1315 SmallPtrSet<GlobalValue*, 4> UsedGlobals;
1316 Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
1317 GlobalVariable *
Used = collectUsedGlobalVariables(*M, UsedGlobals,
true);
1318 for (
auto *GV : UsedGlobals) {
1319 if (GV->getName() !=
"llvm.embedded.module" &&
1320 GV->getName() !=
"llvm.cmdline")
1321 UsedArray.push_back(
1322 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1325 Used->eraseFromParent();
1330 Triple T(M->getTargetTriple());
1335 if (!isBitcode((
const unsigned char *)Buf.getBufferStart(),
1336 (
const unsigned char *)Buf.getBufferEnd())) {
1339 llvm::raw_string_ostream OS(Data);
1340 llvm::WriteBitcodeToFile(*M, OS,
true);
1346 Buf.getBufferSize());
1348 llvm::Constant *ModuleConstant =
1349 llvm::ConstantDataArray::get(M->getContext(), ModuleData);
1350 llvm::GlobalVariable *GV =
new llvm::GlobalVariable(
1351 *M, ModuleConstant->getType(),
true, llvm::GlobalValue::PrivateLinkage,
1354 UsedArray.push_back(
1355 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1356 if (llvm::GlobalVariable *Old =
1357 M->getGlobalVariable(
"llvm.embedded.module",
true)) {
1358 assert(Old->hasOneUse() &&
1359 "llvm.embedded.module can only be used once in llvm.compiler.used");
1361 Old->eraseFromParent();
1363 GV->setName(
"llvm.embedded.module");
1371 llvm::Constant *CmdConstant =
1372 llvm::ConstantDataArray::get(M->getContext(), CmdData);
1373 GV =
new llvm::GlobalVariable(*M, CmdConstant->getType(),
true,
1374 llvm::GlobalValue::PrivateLinkage,
1377 UsedArray.push_back(
1378 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1379 if (llvm::GlobalVariable *Old =
1380 M->getGlobalVariable(
"llvm.cmdline",
true)) {
1381 assert(Old->hasOneUse() &&
1382 "llvm.cmdline can only be used once in llvm.compiler.used");
1384 Old->eraseFromParent();
1386 GV->setName(
"llvm.cmdline");
1390 if (UsedArray.empty())
1394 ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());
1395 auto *NewUsed =
new GlobalVariable(
1396 *M, ATy,
false, llvm::GlobalValue::AppendingLinkage,
1397 llvm::ConstantArray::get(ATy, UsedArray),
"llvm.compiler.used");
1398 NewUsed->setSection(
"llvm.metadata");
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M, const HeaderSearchOptions &HeaderOpts, const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts, const LangOptions &LOpts, std::unique_ptr< raw_pwrite_stream > OS, std::string SampleProfile, BackendAction Action)
Paths for '#include <>' added by '-I'.
static void addObjCARCExpandPass(const PassManagerBuilder &Builder, PassManagerBase &PM)
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
Emit human-readable LLVM assembly.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Run CodeGen, but don't emit anything.
SanitizerSet Sanitize
Set of enabled sanitizers.
The base class of the type hierarchy.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
static void addAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static Optional< GCOVOptions > getGCOVOptions(const CodeGenOptions &CodeGenOpts)
std::vector< std::string > RewriteMapFiles
Set of files defining the rules for the symbol rewriting.
Don't emit anything (benchmarking mode)
Options for controlling the target.
std::string SplitDwarfFile
The name for the split debug info file that we'll break out.
std::string DebugPass
Enable additional debugging information.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
std::string CodeModel
The code model to use (-mcmodel).
Describes a module or submodule.
Concrete class used by the front-end to report problems and issues.
static void addThreadSanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
Defines the Diagnostic-related interfaces.
static CodeGenOpt::Level getCGOptLevel(const CodeGenOptions &CodeGenOpts)
static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts)
static void addSanitizerCoveragePass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
std::string FloatABI
The ABI to use for passing floating point arguments.
std::string ThreadModel
The thread model to use.
char CoverageVersion[4]
The version string to put into coverage files.
std::string LimitFloatPrecision
The float precision limit to use, if non-empty.
Defines the clang::LangOptions interface.
static void addHWAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM)
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
static TargetLibraryInfoImpl * createTLII(llvm::Triple &TargetTriple, const CodeGenOptions &CodeGenOpts)
static void addKernelHWAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
Emit native object files.
Emit native assembly files.
std::string CPU
If given, the name of the target CPU to generate code for.
std::string ABI
If given, the name of the target ABI to use.
static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static void addSymbolRewriterPass(const CodeGenOptions &Opts, legacy::PassManager *MPM)
static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
Defines the clang::TargetOptions class.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings startin...
static void initTargetOptions(llvm::TargetOptions &Options, const CodeGenOptions &CodeGenOpts, const clang::TargetOptions &TargetOpts, const LangOptions &LangOpts, const HeaderSearchOptions &HSOpts)
static bool asanUseGlobalsGC(const Triple &T, const CodeGenOptions &CGOpts)
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
llvm::EABI EABIVersion
The EABI version to use.
'#include ""' paths, added by 'gcc -iquote'.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
Like Angled, but marks system directories.
static TargetMachine::CodeGenFileType getCodeGenFileType(BackendAction Action)
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
Dataflow Directional Tag Classes.
bool FrontendTimesIsEnabled
If the user specifies the -ftime-report argument on an Clang command line then the value of this bool...
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
bool hasProfileIRUse() const
Check if IR level profile use is on.
void EmitBackendOutput(DiagnosticsEngine &Diags, const HeaderSearchOptions &, const CodeGenOptions &CGOpts, const TargetOptions &TOpts, const LangOptions &LOpts, const llvm::DataLayout &TDesc, llvm::Module *M, BackendAction Action, std::unique_ptr< raw_pwrite_stream > OS)
bool hasProfileClangInstr() const
Check if Clang profile instrumenation is on.
llvm::Expected< llvm::BitcodeModule > FindThinLTOModule(llvm::MemoryBufferRef MBRef)
static const char * getSectionNameForBitcode(const Triple &T)
static const char * getSectionNameForCommandline(const Triple &T)
void BuryPointer(const void *Ptr)
static void addBoundsCheckingPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static void addEfficiencySanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static Optional< llvm::CodeModel::Model > getCodeModel(const CodeGenOptions &CodeGenOpts)
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM)
bool hasProfileIRInstr() const
Check if IR level profile instrumentation is on.
const std::vector< std::string > & getNoBuiltinFuncs() const
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
StringLiteral - This represents a string literal expression, e.g.
static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
std::string InstrProfileOutput
Name of the profile file to use as output for -fprofile-instr-generate and -fprofile-generate.
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string ThinLinkBitcodeFile
Name of a file that can optionally be written with minimized bitcode to be used as input for the Thin...
std::vector< std::string > SanitizerBlacklistFiles
Paths to blacklist files specifying which objects (files, functions, variables) should not be instrum...
static void addMemorySanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static PassBuilder::OptimizationLevel mapToLevel(const CodeGenOptions &Opts)