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/Passes/PassBuilder.h"
39 #include "llvm/Support/CommandLine.h"
40 #include "llvm/Support/MemoryBuffer.h"
41 #include "llvm/Support/PrettyStackTrace.h"
42 #include "llvm/Support/TargetRegistry.h"
43 #include "llvm/Support/Timer.h"
44 #include "llvm/Support/raw_ostream.h"
45 #include "llvm/Target/TargetMachine.h"
46 #include "llvm/Target/TargetOptions.h"
47 #include "llvm/Target/TargetSubtargetInfo.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/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/NameAnonGlobals.h"
58 #include "llvm/Transforms/Utils/SymbolRewriter.h"
60 using namespace clang;
66 static constexpr
StringLiteral DefaultProfileGenName =
"default_%m.profraw";
68 class EmitAssemblyHelper {
76 Timer CodeGenerationTime;
78 std::unique_ptr<raw_pwrite_stream> OS;
80 TargetIRAnalysis getTargetIRAnalysis()
const {
82 return TM->getTargetIRAnalysis();
84 return TargetIRAnalysis();
87 void CreatePasses(legacy::PassManager &MPM, legacy::FunctionPassManager &FPM);
97 void CreateTargetMachine(
bool MustCreateTM);
103 raw_pwrite_stream &OS);
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)
120 std::unique_ptr<TargetMachine> TM;
123 std::unique_ptr<raw_pwrite_stream> OS);
126 std::unique_ptr<raw_pwrite_stream> OS);
131 class PassManagerBuilderWrapper :
public PassManagerBuilder {
133 PassManagerBuilderWrapper(
const Triple &TargetTriple,
136 : PassManagerBuilder(), TargetTriple(TargetTriple), CGOpts(CGOpts),
137 LangOpts(LangOpts) {}
138 const Triple &getTargetTriple()
const {
return TargetTriple; }
140 const LangOptions &getLangOpts()
const {
return LangOpts; }
143 const Triple &TargetTriple;
150 if (Builder.OptLevel > 0)
151 PM.add(createObjCARCAPElimPass());
155 if (Builder.OptLevel > 0)
156 PM.add(createObjCARCExpandPass());
160 if (Builder.OptLevel > 0)
161 PM.add(createObjCARCOptPass());
165 legacy::PassManagerBase &PM) {
166 PM.add(createAddDiscriminatorsPass());
170 legacy::PassManagerBase &PM) {
171 PM.add(createBoundsCheckingPass());
175 legacy::PassManagerBase &PM) {
176 const PassManagerBuilderWrapper &BuilderWrapper =
177 static_cast<const PassManagerBuilderWrapper&
>(
Builder);
179 SanitizerCoverageOptions Opts;
181 static_cast<SanitizerCoverageOptions::Type
>(CGOpts.SanitizeCoverageType);
182 Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
183 Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
184 Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
185 Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
186 Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
187 Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
188 Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
189 Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
190 Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;
191 Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;
192 PM.add(createSanitizerCoverageModulePass(Opts));
200 if (!CGOpts.SanitizeAddressGlobalsDeadStripping)
202 switch (T.getObjectFormat()) {
207 return CGOpts.DataSections && !CGOpts.DisableIntegratedAS;
214 legacy::PassManagerBase &PM) {
215 const PassManagerBuilderWrapper &BuilderWrapper =
216 static_cast<const PassManagerBuilderWrapper&
>(
Builder);
217 const Triple &T = BuilderWrapper.getTargetTriple();
220 bool UseAfterScope = CGOpts.SanitizeAddressUseAfterScope;
222 PM.add(createAddressSanitizerFunctionPass(
false, Recover,
224 PM.add(createAddressSanitizerModulePass(
false, Recover,
229 legacy::PassManagerBase &PM) {
230 PM.add(createAddressSanitizerFunctionPass(
233 PM.add(createAddressSanitizerModulePass(
true,
238 legacy::PassManagerBase &PM) {
239 const PassManagerBuilderWrapper &BuilderWrapper =
240 static_cast<const PassManagerBuilderWrapper&
>(
Builder);
242 int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
244 PM.add(createMemorySanitizerPass(TrackOrigins, Recover));
249 if (Builder.OptLevel > 0) {
250 PM.add(createEarlyCSEPass());
251 PM.add(createReassociatePass());
252 PM.add(createLICMPass());
253 PM.add(createGVNPass());
254 PM.add(createInstructionCombiningPass());
255 PM.add(createDeadStoreEliminationPass());
260 legacy::PassManagerBase &PM) {
261 PM.add(createThreadSanitizerPass());
265 legacy::PassManagerBase &PM) {
266 const PassManagerBuilderWrapper &BuilderWrapper =
267 static_cast<const PassManagerBuilderWrapper&
>(
Builder);
268 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
273 legacy::PassManagerBase &PM) {
274 const PassManagerBuilderWrapper &BuilderWrapper =
275 static_cast<const PassManagerBuilderWrapper&
>(
Builder);
276 const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
277 EfficiencySanitizerOptions Opts;
278 if (LangOpts.
Sanitize.
has(SanitizerKind::EfficiencyCacheFrag))
279 Opts.ToolType = EfficiencySanitizerOptions::ESAN_CacheFrag;
280 else if (LangOpts.
Sanitize.
has(SanitizerKind::EfficiencyWorkingSet))
281 Opts.ToolType = EfficiencySanitizerOptions::ESAN_WorkingSet;
282 PM.add(createEfficiencySanitizerPass(Opts));
285 static TargetLibraryInfoImpl *
createTLII(llvm::Triple &TargetTriple,
287 TargetLibraryInfoImpl *TLII =
new TargetLibraryInfoImpl(TargetTriple);
288 if (!CodeGenOpts.SimplifyLibCalls)
289 TLII->disableAllFunctions();
294 if (TLII->getLibFunc(FuncName, F))
295 TLII->setUnavailable(F);
298 switch (CodeGenOpts.getVecLib()) {
300 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::Accelerate);
303 TLII->addVectorizableFunctionsFromVecLib(TargetLibraryInfoImpl::SVML);
312 legacy::PassManager *MPM) {
313 llvm::SymbolRewriter::RewriteDescriptorList DL;
315 llvm::SymbolRewriter::RewriteMapParser MapParser;
317 MapParser.parse(MapFile, &DL);
319 MPM->add(createRewriteSymbolsPass(DL));
323 switch (CodeGenOpts.OptimizationLevel) {
325 llvm_unreachable(
"Invalid optimization level!");
329 return CodeGenOpt::Less;
333 return CodeGenOpt::Aggressive;
339 llvm::StringSwitch<unsigned>(CodeGenOpts.
CodeModel)
340 .Case(
"small", llvm::CodeModel::Small)
341 .Case(
"kernel", llvm::CodeModel::Kernel)
342 .Case(
"medium", llvm::CodeModel::Medium)
343 .Case(
"large", llvm::CodeModel::Large)
346 assert(CodeModel != ~0u &&
"invalid code model!");
347 return static_cast<llvm::CodeModel::Model
>(CodeModel);
354 RM = llvm::StringSwitch<llvm::Reloc::Model>(CodeGenOpts.
RelocationModel)
355 .Case(
"static", llvm::Reloc::Static)
356 .Case(
"pic", llvm::Reloc::PIC_)
357 .Case(
"ropi", llvm::Reloc::ROPI)
358 .Case(
"rwpi", llvm::Reloc::RWPI)
359 .Case(
"ropi-rwpi", llvm::Reloc::ROPI_RWPI)
360 .Case(
"dynamic-no-pic", llvm::Reloc::DynamicNoPIC);
361 assert(RM.hasValue() &&
"invalid PIC model!");
367 return TargetMachine::CGFT_ObjectFile;
369 return TargetMachine::CGFT_Null;
372 return TargetMachine::CGFT_AssemblyFile;
381 Options.ThreadModel =
382 llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.
ThreadModel)
383 .Case(
"posix", llvm::ThreadModel::POSIX)
384 .Case(
"single", llvm::ThreadModel::Single);
387 assert((CodeGenOpts.
FloatABI ==
"soft" || CodeGenOpts.
FloatABI ==
"softfp" ||
389 "Invalid Floating Point ABI!");
390 Options.FloatABIType =
391 llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.
FloatABI)
392 .Case(
"soft", llvm::FloatABI::Soft)
393 .Case(
"softfp", llvm::FloatABI::Soft)
394 .Case(
"hard", llvm::FloatABI::Hard)
398 switch (LangOpts.getDefaultFPContractMode()) {
402 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
405 Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
408 Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
412 Options.UseInitArray = CodeGenOpts.UseInitArray;
413 Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
414 Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
415 Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
420 if (LangOpts.SjLjExceptions)
421 Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
423 Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
424 Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
425 Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
426 Options.UnsafeFPMath = CodeGenOpts.UnsafeFPMath;
427 Options.StackAlignmentOverride = CodeGenOpts.StackAlignment;
428 Options.FunctionSections = CodeGenOpts.FunctionSections;
429 Options.DataSections = CodeGenOpts.DataSections;
430 Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
431 Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
432 Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
434 if (CodeGenOpts.EnableSplitDwarf)
436 Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
437 Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
438 Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
439 Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
440 Options.MCOptions.MCIncrementalLinkerCompatible =
441 CodeGenOpts.IncrementalLinkerCompatible;
442 Options.MCOptions.MCPIECopyRelocations = CodeGenOpts.PIECopyRelocations;
443 Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
444 Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
445 Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
446 Options.MCOptions.ABIName = TargetOpts.
ABI;
448 if (!Entry.IsFramework &&
452 Options.MCOptions.IASSearchPaths.push_back(
453 Entry.IgnoreSysRoot ? Entry.Path : HSOpts.
Sysroot + Entry.Path);
456 void EmitAssemblyHelper::CreatePasses(legacy::PassManager &MPM,
457 legacy::FunctionPassManager &FPM) {
460 if (CodeGenOpts.DisableLLVMPasses)
467 Triple TargetTriple(TheModule->getTargetTriple());
468 std::unique_ptr<TargetLibraryInfoImpl> TLII(
471 PassManagerBuilderWrapper PMBuilder(TargetTriple, CodeGenOpts, LangOpts);
475 if (CodeGenOpts.OptimizationLevel <= 1) {
476 bool InsertLifetimeIntrinsics = (CodeGenOpts.OptimizationLevel != 0 &&
477 !CodeGenOpts.DisableLifetimeMarkers);
478 PMBuilder.Inliner = createAlwaysInlinerLegacyPass(InsertLifetimeIntrinsics);
483 PMBuilder.Inliner = createFunctionInliningPass(
484 CodeGenOpts.OptimizationLevel, CodeGenOpts.OptimizeSize,
485 (!CodeGenOpts.SampleProfileFile.empty() &&
486 CodeGenOpts.EmitSummaryIndex));
489 PMBuilder.OptLevel = CodeGenOpts.OptimizationLevel;
490 PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
491 PMBuilder.SLPVectorize = CodeGenOpts.VectorizeSLP;
492 PMBuilder.LoopVectorize = CodeGenOpts.VectorizeLoop;
494 PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
495 PMBuilder.MergeFunctions = CodeGenOpts.MergeFunctions;
496 PMBuilder.PrepareForThinLTO = CodeGenOpts.EmitSummaryIndex;
497 PMBuilder.PrepareForLTO = CodeGenOpts.PrepareForLTO;
498 PMBuilder.RerollLoops = CodeGenOpts.RerollLoops;
500 MPM.add(
new TargetLibraryInfoWrapperPass(*TLII));
503 TM->adjustPassManager(PMBuilder);
505 if (CodeGenOpts.DebugInfoForProfiling ||
506 !CodeGenOpts.SampleProfileFile.empty())
507 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
511 if (LangOpts.ObjCAutoRefCount) {
512 PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
514 PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
516 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
520 if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
521 PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
523 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
527 if (CodeGenOpts.SanitizeCoverageType ||
528 CodeGenOpts.SanitizeCoverageIndirectCalls ||
529 CodeGenOpts.SanitizeCoverageTraceCmp) {
530 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
532 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
536 if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
537 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
539 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
543 if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
544 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
546 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
550 if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
551 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
553 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
557 if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
558 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
560 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
564 if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
565 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
567 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
571 if (LangOpts.CoroutinesTS)
572 addCoroutinePassesToExtensionPoints(PMBuilder);
574 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Efficiency)) {
575 PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
577 PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
582 FPM.add(
new TargetLibraryInfoWrapperPass(*TLII));
583 if (CodeGenOpts.VerifyModule)
584 FPM.add(createVerifierPass());
587 if (!CodeGenOpts.RewriteMapFiles.empty())
590 if (!CodeGenOpts.DisableGCov &&
591 (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)) {
595 Options.EmitNotes = CodeGenOpts.EmitGcovNotes;
596 Options.EmitData = CodeGenOpts.EmitGcovArcs;
597 memcpy(Options.Version, CodeGenOpts.CoverageVersion, 4);
598 Options.UseCfgChecksum = CodeGenOpts.CoverageExtraChecksum;
599 Options.NoRedZone = CodeGenOpts.DisableRedZone;
600 Options.FunctionNamesInData =
601 !CodeGenOpts.CoverageNoFunctionNamesInData;
602 Options.ExitBlockBeforeBody = CodeGenOpts.CoverageExitBlockBeforeBody;
603 MPM.add(createGCOVProfilerPass(Options));
605 MPM.add(createStripSymbolsPass(
true));
608 if (CodeGenOpts.hasProfileClangInstr()) {
610 Options.NoRedZone = CodeGenOpts.DisableRedZone;
611 Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
612 MPM.add(createInstrProfilingLegacyPass(Options));
614 if (CodeGenOpts.hasProfileIRInstr()) {
615 PMBuilder.EnablePGOInstrGen =
true;
616 if (!CodeGenOpts.InstrProfileOutput.empty())
617 PMBuilder.PGOInstrGen = CodeGenOpts.InstrProfileOutput;
619 PMBuilder.PGOInstrGen = DefaultProfileGenName;
621 if (CodeGenOpts.hasProfileIRUse())
622 PMBuilder.PGOInstrUse = CodeGenOpts.ProfileInstrumentUsePath;
624 if (!CodeGenOpts.SampleProfileFile.empty())
625 PMBuilder.PGOSampleUse = CodeGenOpts.SampleProfileFile;
627 PMBuilder.populateFunctionPassManager(FPM);
628 PMBuilder.populateModulePassManager(MPM);
633 BackendArgs.push_back(
"clang");
635 BackendArgs.push_back(
"-debug-pass");
636 BackendArgs.push_back(CodeGenOpts.
DebugPass.c_str());
639 BackendArgs.push_back(
"-limit-float-precision");
642 for (
const std::string &BackendOption : CodeGenOpts.
BackendOptions)
643 BackendArgs.push_back(BackendOption.c_str());
644 BackendArgs.push_back(
nullptr);
645 llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
649 void EmitAssemblyHelper::CreateTargetMachine(
bool MustCreateTM) {
652 std::string Triple = TheModule->getTargetTriple();
653 const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
656 Diags.Report(diag::err_fe_unable_to_create_target) <<
Error;
661 std::string FeaturesStr =
662 llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(),
",");
668 TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
669 Options, RM, CM, OptLevel));
672 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
674 raw_pwrite_stream &OS) {
676 llvm::Triple TargetTriple(TheModule->getTargetTriple());
677 std::unique_ptr<TargetLibraryInfoImpl> TLII(
679 CodeGenPasses.add(
new TargetLibraryInfoWrapperPass(*TLII));
688 if (CodeGenOpts.OptimizationLevel > 0)
689 CodeGenPasses.add(createObjCARCContractPass());
691 if (TM->addPassesToEmitFile(CodeGenPasses, OS, CGFT,
692 !CodeGenOpts.VerifyModule)) {
693 Diags.Report(diag::err_fe_unable_to_interface_with_target);
701 std::unique_ptr<raw_pwrite_stream> OS) {
702 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime :
nullptr);
709 CreateTargetMachine(UsesCodeGen);
711 if (UsesCodeGen && !TM)
714 TheModule->setDataLayout(TM->createDataLayout());
716 legacy::PassManager PerModulePasses;
718 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
720 legacy::FunctionPassManager PerFunctionPasses(TheModule);
721 PerFunctionPasses.add(
722 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
724 CreatePasses(PerModulePasses, PerFunctionPasses);
726 legacy::PassManager CodeGenPasses;
728 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
730 std::unique_ptr<raw_fd_ostream> ThinLinkOS;
737 if (CodeGenOpts.EmitSummaryIndex) {
738 if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
740 ThinLinkOS.reset(
new llvm::raw_fd_ostream(
741 CodeGenOpts.ThinLinkBitcodeFile, EC,
742 llvm::sys::fs::F_None));
744 Diags.Report(diag::err_fe_unable_to_open_output) << CodeGenOpts.ThinLinkBitcodeFile
750 createWriteThinLTOBitcodePass(*OS, ThinLinkOS.get()));
754 createBitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists));
759 createPrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists));
763 if (!AddEmitPasses(CodeGenPasses, Action, *OS))
768 cl::PrintOptionValues();
774 PrettyStackTraceString CrashInfo(
"Per-function optimization");
776 PerFunctionPasses.doInitialization();
777 for (Function &F : *TheModule)
778 if (!F.isDeclaration())
779 PerFunctionPasses.run(F);
780 PerFunctionPasses.doFinalization();
784 PrettyStackTraceString CrashInfo(
"Per-module optimization passes");
785 PerModulePasses.run(*TheModule);
789 PrettyStackTraceString CrashInfo(
"Code generation");
790 CodeGenPasses.run(*TheModule);
795 switch (Opts.OptimizationLevel) {
797 llvm_unreachable(
"Invalid optimization level!");
800 return PassBuilder::O1;
803 switch (Opts.OptimizeSize) {
805 llvm_unreachable(
"Invalide optimization level for size!");
808 return PassBuilder::O2;
811 return PassBuilder::Os;
814 return PassBuilder::Oz;
818 return PassBuilder::O3;
830 void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
831 BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
832 TimeRegion Region(llvm::TimePassesIsEnabled ? &CodeGenerationTime :
nullptr);
837 CreateTargetMachine(
true);
841 TheModule->setDataLayout(TM->createDataLayout());
846 PGOOpt.RunProfileGen = CodeGenOpts.hasProfileIRInstr();
847 if (PGOOpt.RunProfileGen)
848 PGOOpt.ProfileGenFile = CodeGenOpts.InstrProfileOutput.empty() ?
849 DefaultProfileGenName : CodeGenOpts.InstrProfileOutput;
852 if (CodeGenOpts.hasProfileIRUse())
853 PGOOpt.ProfileUseFile = CodeGenOpts.ProfileInstrumentUsePath;
855 if (!CodeGenOpts.SampleProfileFile.empty())
856 PGOOpt.SampleProfileFile = CodeGenOpts.SampleProfileFile;
860 PassBuilder PB(TM.get(),
861 (PGOOpt.RunProfileGen ||
862 !PGOOpt.ProfileUseFile.empty() ||
863 !PGOOpt.SampleProfileFile.empty()) ?
866 LoopAnalysisManager LAM;
867 FunctionAnalysisManager FAM;
868 CGSCCAnalysisManager CGAM;
869 ModuleAnalysisManager MAM;
872 FAM.registerPass([&] {
return PB.buildDefaultAAPipeline(); });
875 PB.registerModuleAnalyses(MAM);
876 PB.registerCGSCCAnalyses(CGAM);
877 PB.registerFunctionAnalyses(FAM);
878 PB.registerLoopAnalyses(LAM);
879 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
881 ModulePassManager MPM(CodeGenOpts.DebugPassManager);
883 if (!CodeGenOpts.DisableLLVMPasses) {
884 bool IsThinLTO = CodeGenOpts.EmitSummaryIndex;
885 bool IsLTO = CodeGenOpts.PrepareForLTO;
887 if (CodeGenOpts.OptimizationLevel == 0) {
890 MPM.addPass(AlwaysInlinerPass());
892 MPM.addPass(NameAnonGlobalPass());
899 MPM = PB.buildThinLTOPreLinkDefaultPipeline(
900 Level, CodeGenOpts.DebugPassManager);
901 MPM.addPass(NameAnonGlobalPass());
903 MPM = PB.buildLTOPreLinkDefaultPipeline(Level,
904 CodeGenOpts.DebugPassManager);
906 MPM = PB.buildPerModuleDefaultPipeline(Level,
907 CodeGenOpts.DebugPassManager);
914 legacy::PassManager CodeGenPasses;
915 bool NeedCodeGen =
false;
924 if (CodeGenOpts.EmitSummaryIndex) {
925 if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
927 ThinLinkOS.emplace(CodeGenOpts.ThinLinkBitcodeFile, EC,
928 llvm::sys::fs::F_None);
930 Diags.Report(diag::err_fe_unable_to_open_output)
931 << CodeGenOpts.ThinLinkBitcodeFile << EC.message();
936 ThinLTOBitcodeWriterPass(*OS, ThinLinkOS ? &*ThinLinkOS :
nullptr));
938 MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
939 CodeGenOpts.EmitSummaryIndex,
940 CodeGenOpts.EmitSummaryIndex));
945 MPM.addPass(PrintModulePass(*OS,
"", CodeGenOpts.EmitLLVMUseLists));
953 createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
954 if (!AddEmitPasses(CodeGenPasses, Action, *OS))
961 cl::PrintOptionValues();
965 PrettyStackTraceString CrashInfo(
"Optimizer");
966 MPM.run(*TheModule, MAM);
971 PrettyStackTraceString CrashInfo(
"Code generation");
972 CodeGenPasses.run(*TheModule);
979 return BMsOrErr.takeError();
983 for (BitcodeModule &BM : *BMsOrErr) {
985 if (LTOInfo && LTOInfo->IsThinLTO)
989 return make_error<StringError>(
"Could not find module summary",
990 inconvertibleErrorCode());
998 std::unique_ptr<raw_pwrite_stream> OS,
999 std::string SampleProfile,
1001 StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
1002 ModuleToDefinedGVSummaries;
1003 CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1010 FunctionImporter::ImportMapTy ImportList;
1011 for (
auto &GlobalList : *CombinedIndex) {
1013 if (GlobalList.second.SummaryList.empty())
1016 auto GUID = GlobalList.first;
1017 assert(GlobalList.second.SummaryList.size() == 1 &&
1018 "Expected individual combined index to have one summary per GUID");
1019 auto &Summary = GlobalList.second.SummaryList[0];
1022 if (Summary->modulePath() == M->getModuleIdentifier())
1026 ImportList[Summary->modulePath()][GUID] = 1;
1029 std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
1030 MapVector<llvm::StringRef, llvm::BitcodeModule>
ModuleMap;
1032 for (
auto &
I : ImportList) {
1033 ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
1034 llvm::MemoryBuffer::getFile(
I.first());
1036 errs() <<
"Error loading imported file '" <<
I.first()
1037 <<
"': " << MBOrErr.getError().message() <<
"\n";
1043 handleAllErrors(BMOrErr.takeError(), [&](ErrorInfoBase &EIB) {
1044 errs() <<
"Error loading imported file '" <<
I.first()
1045 <<
"': " << EIB.message() <<
'\n';
1049 ModuleMap.insert({
I.first(), *BMOrErr});
1051 OwnedImports.push_back(std::move(*MBOrErr));
1053 auto AddStream = [&](
size_t Task) {
1054 return llvm::make_unique<lto::NativeObjectStream>(std::move(OS));
1057 Conf.CPU = TOpts.
CPU;
1063 Conf.SampleProfile = std::move(SampleProfile);
1064 Conf.UseNewPM = CGOpts.ExperimentalNewPassManager;
1067 Conf.PreCodeGenModuleHook = [](
size_t Task,
const Module &Mod) {
1072 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const Module &Mod) {
1073 M->
print(*OS,
nullptr, CGOpts.EmitLLVMUseLists);
1078 Conf.PreCodeGenModuleHook = [&](
size_t Task,
const Module &Mod) {
1079 WriteBitcodeToFile(M, *OS, CGOpts.EmitLLVMUseLists);
1087 if (Error
E = thinBackend(
1088 Conf, 0, AddStream, *M, *CombinedIndex, ImportList,
1089 ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
1090 handleAllErrors(std::move(
E), [&](ErrorInfoBase &EIB) {
1091 errs() <<
"Error running ThinLTO backend: " << EIB.message() <<
'\n';
1101 const llvm::DataLayout &TDesc,
Module *M,
1103 std::unique_ptr<raw_pwrite_stream> OS) {
1112 logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
1113 "Error loading index file '" +
1117 std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
1121 bool DoThinLTOBackend = CombinedIndex !=
nullptr;
1122 if (DoThinLTOBackend) {
1124 LOpts, std::move(OS), CGOpts.SampleProfileFile,
Action);
1129 EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);
1131 if (CGOpts.ExperimentalNewPassManager)
1132 AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
1134 AsmHelper.EmitAssembly(Action, std::move(OS));
1139 std::string DLDesc = M->getDataLayout().getStringRepresentation();
1140 if (DLDesc != TDesc.getStringRepresentation()) {
1143 "expected target description '%1'");
1144 Diags.
Report(DiagID) << DLDesc << TDesc.getStringRepresentation();
1150 switch (T.getObjectFormat()) {
1152 return "__LLVM,__bitcode";
1156 case Triple::UnknownObjectFormat:
1159 llvm_unreachable(
"Unimplemented ObjectFormatType");
1163 switch (T.getObjectFormat()) {
1165 return "__LLVM,__cmdline";
1169 case Triple::UnknownObjectFormat:
1172 llvm_unreachable(
"Unimplemented ObjectFormatType");
1178 llvm::MemoryBufferRef Buf) {
1184 SmallSet<GlobalValue*, 4> UsedGlobals;
1185 Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
1186 GlobalVariable *
Used = collectUsedGlobalVariables(*M, UsedGlobals,
true);
1187 for (
auto *GV : UsedGlobals) {
1188 if (GV->getName() !=
"llvm.embedded.module" &&
1189 GV->getName() !=
"llvm.cmdline")
1190 UsedArray.push_back(
1191 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1194 Used->eraseFromParent();
1199 Triple T(M->getTargetTriple());
1204 if (!isBitcode((
const unsigned char *)Buf.getBufferStart(),
1205 (
const unsigned char *)Buf.getBufferEnd())) {
1208 llvm::raw_string_ostream OS(Data);
1209 llvm::WriteBitcodeToFile(M, OS,
true);
1215 Buf.getBufferSize());
1217 llvm::Constant *ModuleConstant =
1218 llvm::ConstantDataArray::get(M->getContext(), ModuleData);
1219 llvm::GlobalVariable *GV =
new llvm::GlobalVariable(
1220 *M, ModuleConstant->getType(),
true, llvm::GlobalValue::PrivateLinkage,
1223 UsedArray.push_back(
1224 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1225 if (llvm::GlobalVariable *Old =
1226 M->getGlobalVariable(
"llvm.embedded.module",
true)) {
1227 assert(Old->hasOneUse() &&
1228 "llvm.embedded.module can only be used once in llvm.compiler.used");
1230 Old->eraseFromParent();
1232 GV->setName(
"llvm.embedded.module");
1240 llvm::Constant *CmdConstant =
1241 llvm::ConstantDataArray::get(M->getContext(), CmdData);
1242 GV =
new llvm::GlobalVariable(*M, CmdConstant->getType(),
true,
1243 llvm::GlobalValue::PrivateLinkage,
1246 UsedArray.push_back(
1247 ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV, UsedElementType));
1248 if (llvm::GlobalVariable *Old =
1249 M->getGlobalVariable(
"llvm.cmdline",
true)) {
1250 assert(Old->hasOneUse() &&
1251 "llvm.cmdline can only be used once in llvm.compiler.used");
1253 Old->eraseFromParent();
1255 GV->setName(
"llvm.cmdline");
1259 if (UsedArray.empty())
1263 ArrayType *ATy = ArrayType::get(UsedElementType, UsedArray.size());
1264 auto *NewUsed =
new GlobalVariable(
1265 *M, ATy,
false, llvm::GlobalValue::AppendingLinkage,
1266 llvm::ConstantArray::get(ATy, UsedArray),
"llvm.compiler.used");
1267 NewUsed->setSection(
"llvm.metadata");
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)
Emit human-readable LLVM assembly.
Run CodeGen, but don't emit anything.
SanitizerSet Sanitize
Set of enabled sanitizers.
The base class of the type hierarchy.
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)
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.
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)
detail::InMemoryDirectory::const_iterator I
std::string FloatABI
The ABI to use for passing floating point arguments.
std::string ThreadModel
The thread model to use.
std::string LimitFloatPrecision
The float precision limit to use, if non-empty.
Defines the clang::LangOptions interface.
static void addObjCARCAPElimPass(const PassManagerBuilder &Builder, PassManagerBase &PM)
std::string RelocationModel
The name of the relocation model to use.
static TargetLibraryInfoImpl * createTLII(llvm::Triple &TargetTriple, const CodeGenOptions &CodeGenOpts)
Emit native object files.
Emit native assembly files.
std::string CPU
If given, the name of the target CPU to generate code for.
const MatchFinder::MatchFinderOptions & Options
static llvm::Reloc::Model getRelocModel(const CodeGenOptions &CodeGenOpts)
std::string ABI
If given, the name of the target ABI to use.
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
static void addKernelAddressSanitizerPasses(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static void addSymbolRewriterPass(const CodeGenOptions &Opts, legacy::PassManager *MPM)
const std::vector< std::string > & getNoBuiltinFuncs() const
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 starting...
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.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
static TargetMachine::CodeGenFileType getCodeGenFileType(BackendAction Action)
void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::MemoryBufferRef Buf)
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)
detail::InMemoryDirectory::const_iterator E
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)
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
static void addEfficiencySanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
static llvm::CodeModel::Model getCodeModel(const CodeGenOptions &CodeGenOpts)
static void addObjCARCOptPass(const PassManagerBuilder &Builder, PassManagerBase &PM)
BoundNodesTreeBuilder *const Builder
StringLiteral - This represents a string literal expression, e.g.
static void addAddDiscriminatorsPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
std::vector< std::string > SanitizerBlacklistFiles
Paths to blacklist files specifying which objects (files, functions, variables) should not be instrum...
std::vector< std::string > BackendOptions
A list of command-line options to forward to the LLVM backend.
static void addMemorySanitizerPass(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)
static PassBuilder::OptimizationLevel mapToLevel(const CodeGenOptions &Opts)