xref: /llvm-project/clang/lib/CodeGen/BackendUtil.cpp (revision 0f776f1df9ec6345f298cc19c33dfea7f98289ec) 
1 //===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/CodeGen/BackendUtil.h"
10 #include "BackendConsumer.h"
11 #include "LinkInModulesPass.h"
12 #include "clang/Basic/CodeGenOptions.h"
13 #include "clang/Basic/Diagnostic.h"
14 #include "clang/Basic/LangOptions.h"
15 #include "clang/Basic/TargetOptions.h"
16 #include "clang/Frontend/FrontendDiagnostic.h"
17 #include "clang/Frontend/Utils.h"
18 #include "clang/Lex/HeaderSearchOptions.h"
19 #include "llvm/ADT/StringExtras.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Analysis/GlobalsModRef.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/TargetSubtargetInfo.h"
28 #include "llvm/Frontend/Driver/CodeGenOptions.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/LegacyPassManager.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/ModuleSummaryIndex.h"
34 #include "llvm/IR/PassManager.h"
35 #include "llvm/IR/Verifier.h"
36 #include "llvm/IRPrinter/IRPrintingPasses.h"
37 #include "llvm/LTO/LTOBackend.h"
38 #include "llvm/MC/TargetRegistry.h"
39 #include "llvm/Object/OffloadBinary.h"
40 #include "llvm/Passes/PassBuilder.h"
41 #include "llvm/Passes/PassPlugin.h"
42 #include "llvm/Passes/StandardInstrumentations.h"
43 #include "llvm/ProfileData/InstrProfCorrelator.h"
44 #include "llvm/Support/BuryPointer.h"
45 #include "llvm/Support/CommandLine.h"
46 #include "llvm/Support/MemoryBuffer.h"
47 #include "llvm/Support/PrettyStackTrace.h"
48 #include "llvm/Support/Program.h"
49 #include "llvm/Support/TimeProfiler.h"
50 #include "llvm/Support/Timer.h"
51 #include "llvm/Support/ToolOutputFile.h"
52 #include "llvm/Support/VirtualFileSystem.h"
53 #include "llvm/Support/raw_ostream.h"
54 #include "llvm/Target/TargetMachine.h"
55 #include "llvm/Target/TargetOptions.h"
56 #include "llvm/TargetParser/SubtargetFeature.h"
57 #include "llvm/TargetParser/Triple.h"
58 #include "llvm/Transforms/HipStdPar/HipStdPar.h"
59 #include "llvm/Transforms/IPO/EmbedBitcodePass.h"
60 #include "llvm/Transforms/IPO/LowerTypeTests.h"
61 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
62 #include "llvm/Transforms/InstCombine/InstCombine.h"
63 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
64 #include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"
65 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
66 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
67 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
68 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
69 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
70 #include "llvm/Transforms/Instrumentation/KCFI.h"
71 #include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
72 #include "llvm/Transforms/Instrumentation/MemProfiler.h"
73 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
74 #include "llvm/Transforms/Instrumentation/NumericalStabilitySanitizer.h"
75 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
76 #include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
77 #include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
78 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
79 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
80 #include "llvm/Transforms/ObjCARC.h"
81 #include "llvm/Transforms/Scalar/EarlyCSE.h"
82 #include "llvm/Transforms/Scalar/GVN.h"
83 #include "llvm/Transforms/Scalar/JumpThreading.h"
84 #include "llvm/Transforms/Utils/Debugify.h"
85 #include "llvm/Transforms/Utils/ModuleUtils.h"
86 #include <memory>
87 #include <optional>
88 using namespace clang;
89 using namespace llvm;
90 
91 #define HANDLE_EXTENSION(Ext)                                                  \
92   llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
93 #include "llvm/Support/Extension.def"
94 
95 namespace llvm {
96 extern cl::opt<bool> PrintPipelinePasses;
97 
98 // Experiment to move sanitizers earlier.
99 static cl::opt<bool> ClSanitizeOnOptimizerEarlyEP(
100     "sanitizer-early-opt-ep", cl::Optional,
101     cl::desc("Insert sanitizers on OptimizerEarlyEP."));
102 
103 // Experiment to mark cold functions as optsize/minsize/optnone.
104 // TODO: remove once this is exposed as a proper driver flag.
105 static cl::opt<PGOOptions::ColdFuncOpt> ClPGOColdFuncAttr(
106     "pgo-cold-func-opt", cl::init(PGOOptions::ColdFuncOpt::Default), cl::Hidden,
107     cl::desc(
108         "Function attribute to apply to cold functions as determined by PGO"),
109     cl::values(clEnumValN(PGOOptions::ColdFuncOpt::Default, "default",
110                           "Default (no attribute)"),
111                clEnumValN(PGOOptions::ColdFuncOpt::OptSize, "optsize",
112                           "Mark cold functions with optsize."),
113                clEnumValN(PGOOptions::ColdFuncOpt::MinSize, "minsize",
114                           "Mark cold functions with minsize."),
115                clEnumValN(PGOOptions::ColdFuncOpt::OptNone, "optnone",
116                           "Mark cold functions with optnone.")));
117 
118 extern cl::opt<InstrProfCorrelator::ProfCorrelatorKind> ProfileCorrelate;
119 } // namespace llvm
120 
121 namespace {
122 
123 // Default filename used for profile generation.
124 std::string getDefaultProfileGenName() {
125   return DebugInfoCorrelate || ProfileCorrelate != InstrProfCorrelator::NONE
126              ? "default_%m.proflite"
127              : "default_%m.profraw";
128 }
129 
130 class EmitAssemblyHelper {
131   DiagnosticsEngine &Diags;
132   const HeaderSearchOptions &HSOpts;
133   const CodeGenOptions &CodeGenOpts;
134   const clang::TargetOptions &TargetOpts;
135   const LangOptions &LangOpts;
136   llvm::Module *TheModule;
137   IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS;
138 
139   Timer CodeGenerationTime;
140 
141   std::unique_ptr<raw_pwrite_stream> OS;
142 
143   Triple TargetTriple;
144 
145   TargetIRAnalysis getTargetIRAnalysis() const {
146     if (TM)
147       return TM->getTargetIRAnalysis();
148 
149     return TargetIRAnalysis();
150   }
151 
152   /// Generates the TargetMachine.
153   /// Leaves TM unchanged if it is unable to create the target machine.
154   /// Some of our clang tests specify triples which are not built
155   /// into clang. This is okay because these tests check the generated
156   /// IR, and they require DataLayout which depends on the triple.
157   /// In this case, we allow this method to fail and not report an error.
158   /// When MustCreateTM is used, we print an error if we are unable to load
159   /// the requested target.
160   void CreateTargetMachine(bool MustCreateTM);
161 
162   /// Add passes necessary to emit assembly or LLVM IR.
163   ///
164   /// \return True on success.
165   bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
166                      raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);
167 
168   std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
169     std::error_code EC;
170     auto F = std::make_unique<llvm::ToolOutputFile>(Path, EC,
171                                                      llvm::sys::fs::OF_None);
172     if (EC) {
173       Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
174       F.reset();
175     }
176     return F;
177   }
178 
179   void RunOptimizationPipeline(
180       BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
181       std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS, BackendConsumer *BC);
182   void RunCodegenPipeline(BackendAction Action,
183                           std::unique_ptr<raw_pwrite_stream> &OS,
184                           std::unique_ptr<llvm::ToolOutputFile> &DwoOS);
185 
186   /// Check whether we should emit a module summary for regular LTO.
187   /// The module summary should be emitted by default for regular LTO
188   /// except for ld64 targets.
189   ///
190   /// \return True if the module summary should be emitted.
191   bool shouldEmitRegularLTOSummary() const {
192     return CodeGenOpts.PrepareForLTO && !CodeGenOpts.DisableLLVMPasses &&
193            TargetTriple.getVendor() != llvm::Triple::Apple;
194   }
195 
196   /// Check whether we should emit a flag for UnifiedLTO.
197   /// The UnifiedLTO module flag should be set when UnifiedLTO is enabled for
198   /// ThinLTO or Full LTO with module summaries.
199   bool shouldEmitUnifiedLTOModueFlag() const {
200     return CodeGenOpts.UnifiedLTO &&
201            (CodeGenOpts.PrepareForThinLTO || shouldEmitRegularLTOSummary());
202   }
203 
204 public:
205   EmitAssemblyHelper(DiagnosticsEngine &_Diags,
206                      const HeaderSearchOptions &HeaderSearchOpts,
207                      const CodeGenOptions &CGOpts,
208                      const clang::TargetOptions &TOpts,
209                      const LangOptions &LOpts, llvm::Module *M,
210                      IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
211       : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),
212         TargetOpts(TOpts), LangOpts(LOpts), TheModule(M), VFS(std::move(VFS)),
213         CodeGenerationTime("codegen", "Code Generation Time"),
214         TargetTriple(TheModule->getTargetTriple()) {}
215 
216   ~EmitAssemblyHelper() {
217     if (CodeGenOpts.DisableFree)
218       BuryPointer(std::move(TM));
219   }
220 
221   std::unique_ptr<TargetMachine> TM;
222 
223   // Emit output using the new pass manager for the optimization pipeline.
224   void EmitAssembly(BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
225                     BackendConsumer *BC);
226 };
227 } // namespace
228 
229 static SanitizerCoverageOptions
230 getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts) {
231   SanitizerCoverageOptions Opts;
232   Opts.CoverageType =
233       static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);
234   Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;
235   Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;
236   Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;
237   Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;
238   Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;
239   Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;
240   Opts.TracePC = CGOpts.SanitizeCoverageTracePC;
241   Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;
242   Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;
243   Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;
244   Opts.InlineBoolFlag = CGOpts.SanitizeCoverageInlineBoolFlag;
245   Opts.PCTable = CGOpts.SanitizeCoveragePCTable;
246   Opts.StackDepth = CGOpts.SanitizeCoverageStackDepth;
247   Opts.TraceLoads = CGOpts.SanitizeCoverageTraceLoads;
248   Opts.TraceStores = CGOpts.SanitizeCoverageTraceStores;
249   Opts.CollectControlFlow = CGOpts.SanitizeCoverageControlFlow;
250   return Opts;
251 }
252 
253 static SanitizerBinaryMetadataOptions
254 getSanitizerBinaryMetadataOptions(const CodeGenOptions &CGOpts) {
255   SanitizerBinaryMetadataOptions Opts;
256   Opts.Covered = CGOpts.SanitizeBinaryMetadataCovered;
257   Opts.Atomics = CGOpts.SanitizeBinaryMetadataAtomics;
258   Opts.UAR = CGOpts.SanitizeBinaryMetadataUAR;
259   return Opts;
260 }
261 
262 // Check if ASan should use GC-friendly instrumentation for globals.
263 // First of all, there is no point if -fdata-sections is off (expect for MachO,
264 // where this is not a factor). Also, on ELF this feature requires an assembler
265 // extension that only works with -integrated-as at the moment.
266 static bool asanUseGlobalsGC(const Triple &T, const CodeGenOptions &CGOpts) {
267   if (!CGOpts.SanitizeAddressGlobalsDeadStripping)
268     return false;
269   switch (T.getObjectFormat()) {
270   case Triple::MachO:
271   case Triple::COFF:
272     return true;
273   case Triple::ELF:
274     return !CGOpts.DisableIntegratedAS;
275   case Triple::GOFF:
276     llvm::report_fatal_error("ASan not implemented for GOFF");
277   case Triple::XCOFF:
278     llvm::report_fatal_error("ASan not implemented for XCOFF.");
279   case Triple::Wasm:
280   case Triple::DXContainer:
281   case Triple::SPIRV:
282   case Triple::UnknownObjectFormat:
283     break;
284   }
285   return false;
286 }
287 
288 static std::optional<llvm::CodeModel::Model>
289 getCodeModel(const CodeGenOptions &CodeGenOpts) {
290   unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
291                            .Case("tiny", llvm::CodeModel::Tiny)
292                            .Case("small", llvm::CodeModel::Small)
293                            .Case("kernel", llvm::CodeModel::Kernel)
294                            .Case("medium", llvm::CodeModel::Medium)
295                            .Case("large", llvm::CodeModel::Large)
296                            .Case("default", ~1u)
297                            .Default(~0u);
298   assert(CodeModel != ~0u && "invalid code model!");
299   if (CodeModel == ~1u)
300     return std::nullopt;
301   return static_cast<llvm::CodeModel::Model>(CodeModel);
302 }
303 
304 static CodeGenFileType getCodeGenFileType(BackendAction Action) {
305   if (Action == Backend_EmitObj)
306     return CodeGenFileType::ObjectFile;
307   else if (Action == Backend_EmitMCNull)
308     return CodeGenFileType::Null;
309   else {
310     assert(Action == Backend_EmitAssembly && "Invalid action!");
311     return CodeGenFileType::AssemblyFile;
312   }
313 }
314 
315 static bool actionRequiresCodeGen(BackendAction Action) {
316   return Action != Backend_EmitNothing && Action != Backend_EmitBC &&
317          Action != Backend_EmitLL;
318 }
319 
320 static std::string flattenClangCommandLine(ArrayRef<std::string> Args,
321                                            StringRef MainFilename) {
322   if (Args.empty())
323     return std::string{};
324 
325   std::string FlatCmdLine;
326   raw_string_ostream OS(FlatCmdLine);
327   bool PrintedOneArg = false;
328   if (!StringRef(Args[0]).contains("-cc1")) {
329     llvm::sys::printArg(OS, "-cc1", /*Quote=*/true);
330     PrintedOneArg = true;
331   }
332   for (unsigned i = 0; i < Args.size(); i++) {
333     StringRef Arg = Args[i];
334     if (Arg.empty())
335       continue;
336     if (Arg == "-main-file-name" || Arg == "-o") {
337       i++; // Skip this argument and next one.
338       continue;
339     }
340     if (Arg.starts_with("-object-file-name") || Arg == MainFilename)
341       continue;
342     // Skip fmessage-length for reproducibility.
343     if (Arg.starts_with("-fmessage-length"))
344       continue;
345     if (PrintedOneArg)
346       OS << " ";
347     llvm::sys::printArg(OS, Arg, /*Quote=*/true);
348     PrintedOneArg = true;
349   }
350   return FlatCmdLine;
351 }
352 
353 static bool initTargetOptions(DiagnosticsEngine &Diags,
354                               llvm::TargetOptions &Options,
355                               const CodeGenOptions &CodeGenOpts,
356                               const clang::TargetOptions &TargetOpts,
357                               const LangOptions &LangOpts,
358                               const HeaderSearchOptions &HSOpts) {
359   switch (LangOpts.getThreadModel()) {
360   case LangOptions::ThreadModelKind::POSIX:
361     Options.ThreadModel = llvm::ThreadModel::POSIX;
362     break;
363   case LangOptions::ThreadModelKind::Single:
364     Options.ThreadModel = llvm::ThreadModel::Single;
365     break;
366   }
367 
368   // Set float ABI type.
369   assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
370           CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
371          "Invalid Floating Point ABI!");
372   Options.FloatABIType =
373       llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
374           .Case("soft", llvm::FloatABI::Soft)
375           .Case("softfp", llvm::FloatABI::Soft)
376           .Case("hard", llvm::FloatABI::Hard)
377           .Default(llvm::FloatABI::Default);
378 
379   // Set FP fusion mode.
380   switch (LangOpts.getDefaultFPContractMode()) {
381   case LangOptions::FPM_Off:
382     // Preserve any contraction performed by the front-end.  (Strict performs
383     // splitting of the muladd intrinsic in the backend.)
384     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
385     break;
386   case LangOptions::FPM_On:
387   case LangOptions::FPM_FastHonorPragmas:
388     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
389     break;
390   case LangOptions::FPM_Fast:
391     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
392     break;
393   }
394 
395   Options.BinutilsVersion =
396       llvm::TargetMachine::parseBinutilsVersion(CodeGenOpts.BinutilsVersion);
397   Options.UseInitArray = CodeGenOpts.UseInitArray;
398   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
399 
400   // Set EABI version.
401   Options.EABIVersion = TargetOpts.EABIVersion;
402 
403   if (LangOpts.hasSjLjExceptions())
404     Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
405   if (LangOpts.hasSEHExceptions())
406     Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
407   if (LangOpts.hasDWARFExceptions())
408     Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
409   if (LangOpts.hasWasmExceptions())
410     Options.ExceptionModel = llvm::ExceptionHandling::Wasm;
411 
412   Options.NoInfsFPMath = LangOpts.NoHonorInfs;
413   Options.NoNaNsFPMath = LangOpts.NoHonorNaNs;
414   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
415   Options.UnsafeFPMath = LangOpts.AllowFPReassoc && LangOpts.AllowRecip &&
416                          LangOpts.NoSignedZero && LangOpts.ApproxFunc &&
417                          (LangOpts.getDefaultFPContractMode() ==
418                               LangOptions::FPModeKind::FPM_Fast ||
419                           LangOpts.getDefaultFPContractMode() ==
420                               LangOptions::FPModeKind::FPM_FastHonorPragmas);
421   Options.ApproxFuncFPMath = LangOpts.ApproxFunc;
422 
423   Options.BBAddrMap = CodeGenOpts.BBAddrMap;
424   Options.BBSections =
425       llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections)
426           .Case("all", llvm::BasicBlockSection::All)
427           .StartsWith("list=", llvm::BasicBlockSection::List)
428           .Case("none", llvm::BasicBlockSection::None)
429           .Default(llvm::BasicBlockSection::None);
430 
431   if (Options.BBSections == llvm::BasicBlockSection::List) {
432     ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
433         MemoryBuffer::getFile(CodeGenOpts.BBSections.substr(5));
434     if (!MBOrErr) {
435       Diags.Report(diag::err_fe_unable_to_load_basic_block_sections_file)
436           << MBOrErr.getError().message();
437       return false;
438     }
439     Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
440   }
441 
442   Options.EnableMachineFunctionSplitter = CodeGenOpts.SplitMachineFunctions;
443   Options.FunctionSections = CodeGenOpts.FunctionSections;
444   Options.DataSections = CodeGenOpts.DataSections;
445   Options.IgnoreXCOFFVisibility = LangOpts.IgnoreXCOFFVisibility;
446   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
447   Options.UniqueBasicBlockSectionNames =
448       CodeGenOpts.UniqueBasicBlockSectionNames;
449   Options.SeparateNamedSections = CodeGenOpts.SeparateNamedSections;
450   Options.TLSSize = CodeGenOpts.TLSSize;
451   Options.EnableTLSDESC = CodeGenOpts.EnableTLSDESC;
452   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
453   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
454   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
455   Options.StackUsageOutput = CodeGenOpts.StackUsageOutput;
456   Options.EmitAddrsig = CodeGenOpts.Addrsig;
457   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
458   Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
459   Options.EnableAIXExtendedAltivecABI = LangOpts.EnableAIXExtendedAltivecABI;
460   Options.XRayFunctionIndex = CodeGenOpts.XRayFunctionIndex;
461   Options.LoopAlignment = CodeGenOpts.LoopAlignment;
462   Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
463   Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;
464   Options.Hotpatch = CodeGenOpts.HotPatch;
465   Options.JMCInstrument = CodeGenOpts.JMCInstrument;
466   Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;
467 
468   switch (CodeGenOpts.getSwiftAsyncFramePointer()) {
469   case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:
470     Options.SwiftAsyncFramePointer =
471         SwiftAsyncFramePointerMode::DeploymentBased;
472     break;
473 
474   case CodeGenOptions::SwiftAsyncFramePointerKind::Always:
475     Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Always;
476     break;
477 
478   case CodeGenOptions::SwiftAsyncFramePointerKind::Never:
479     Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Never;
480     break;
481   }
482 
483   Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
484   Options.MCOptions.EmitDwarfUnwind = CodeGenOpts.getEmitDwarfUnwind();
485   Options.MCOptions.EmitCompactUnwindNonCanonical =
486       CodeGenOpts.EmitCompactUnwindNonCanonical;
487   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
488   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
489   Options.MCOptions.MCUseDwarfDirectory =
490       CodeGenOpts.NoDwarfDirectoryAsm
491           ? llvm::MCTargetOptions::DisableDwarfDirectory
492           : llvm::MCTargetOptions::EnableDwarfDirectory;
493   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
494   Options.MCOptions.MCIncrementalLinkerCompatible =
495       CodeGenOpts.IncrementalLinkerCompatible;
496   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
497   Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;
498   Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
499   Options.MCOptions.Dwarf64 = CodeGenOpts.Dwarf64;
500   Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
501   Options.MCOptions.Crel = CodeGenOpts.Crel;
502   Options.MCOptions.ImplicitMapSyms = CodeGenOpts.ImplicitMapSyms;
503   Options.MCOptions.X86RelaxRelocations = CodeGenOpts.X86RelaxRelocations;
504   Options.MCOptions.CompressDebugSections =
505       CodeGenOpts.getCompressDebugSections();
506   if (CodeGenOpts.OutputAsmVariant != 3) // 3 (default): not specified
507     Options.MCOptions.OutputAsmVariant = CodeGenOpts.OutputAsmVariant;
508   Options.MCOptions.ABIName = TargetOpts.ABI;
509   for (const auto &Entry : HSOpts.UserEntries)
510     if (!Entry.IsFramework &&
511         (Entry.Group == frontend::IncludeDirGroup::Quoted ||
512          Entry.Group == frontend::IncludeDirGroup::Angled ||
513          Entry.Group == frontend::IncludeDirGroup::System))
514       Options.MCOptions.IASSearchPaths.push_back(
515           Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
516   Options.MCOptions.Argv0 = CodeGenOpts.Argv0 ? CodeGenOpts.Argv0 : "";
517   Options.MCOptions.CommandlineArgs = flattenClangCommandLine(
518       CodeGenOpts.CommandLineArgs, CodeGenOpts.MainFileName);
519   Options.MCOptions.AsSecureLogFile = CodeGenOpts.AsSecureLogFile;
520   Options.MCOptions.PPCUseFullRegisterNames =
521       CodeGenOpts.PPCUseFullRegisterNames;
522   Options.MisExpect = CodeGenOpts.MisExpect;
523 
524   return true;
525 }
526 
527 static std::optional<GCOVOptions>
528 getGCOVOptions(const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts) {
529   if (CodeGenOpts.CoverageNotesFile.empty() &&
530       CodeGenOpts.CoverageDataFile.empty())
531     return std::nullopt;
532   // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if
533   // LLVM's -default-gcov-version flag is set to something invalid.
534   GCOVOptions Options;
535   Options.EmitNotes = !CodeGenOpts.CoverageNotesFile.empty();
536   Options.EmitData = !CodeGenOpts.CoverageDataFile.empty();
537   llvm::copy(CodeGenOpts.CoverageVersion, std::begin(Options.Version));
538   Options.NoRedZone = CodeGenOpts.DisableRedZone;
539   Options.Filter = CodeGenOpts.ProfileFilterFiles;
540   Options.Exclude = CodeGenOpts.ProfileExcludeFiles;
541   Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
542   return Options;
543 }
544 
545 static std::optional<InstrProfOptions>
546 getInstrProfOptions(const CodeGenOptions &CodeGenOpts,
547                     const LangOptions &LangOpts) {
548   if (!CodeGenOpts.hasProfileClangInstr())
549     return std::nullopt;
550   InstrProfOptions Options;
551   Options.NoRedZone = CodeGenOpts.DisableRedZone;
552   Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;
553   Options.Atomic = CodeGenOpts.AtomicProfileUpdate;
554   return Options;
555 }
556 
557 static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {
558   SmallVector<const char *, 16> BackendArgs;
559   BackendArgs.push_back("clang"); // Fake program name.
560   if (!CodeGenOpts.DebugPass.empty()) {
561     BackendArgs.push_back("-debug-pass");
562     BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());
563   }
564   if (!CodeGenOpts.LimitFloatPrecision.empty()) {
565     BackendArgs.push_back("-limit-float-precision");
566     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
567   }
568   // Check for the default "clang" invocation that won't set any cl::opt values.
569   // Skip trying to parse the command line invocation to avoid the issues
570   // described below.
571   if (BackendArgs.size() == 1)
572     return;
573   BackendArgs.push_back(nullptr);
574   // FIXME: The command line parser below is not thread-safe and shares a global
575   // state, so this call might crash or overwrite the options of another Clang
576   // instance in the same process.
577   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
578                                     BackendArgs.data());
579 }
580 
581 void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
582   // Create the TargetMachine for generating code.
583   std::string Error;
584   std::string Triple = TheModule->getTargetTriple();
585   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
586   if (!TheTarget) {
587     if (MustCreateTM)
588       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
589     return;
590   }
591 
592   std::optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
593   std::string FeaturesStr =
594       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
595   llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;
596   std::optional<CodeGenOptLevel> OptLevelOrNone =
597       CodeGenOpt::getLevel(CodeGenOpts.OptimizationLevel);
598   assert(OptLevelOrNone && "Invalid optimization level!");
599   CodeGenOptLevel OptLevel = *OptLevelOrNone;
600 
601   llvm::TargetOptions Options;
602   if (!initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts,
603                          HSOpts))
604     return;
605   TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
606                                           Options, RM, CM, OptLevel));
607   TM->setLargeDataThreshold(CodeGenOpts.LargeDataThreshold);
608 }
609 
610 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
611                                        BackendAction Action,
612                                        raw_pwrite_stream &OS,
613                                        raw_pwrite_stream *DwoOS) {
614   // Add LibraryInfo.
615   std::unique_ptr<TargetLibraryInfoImpl> TLII(
616       llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
617   CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));
618 
619   // Normal mode, emit a .s or .o file by running the code generator. Note,
620   // this also adds codegenerator level optimization passes.
621   CodeGenFileType CGFT = getCodeGenFileType(Action);
622 
623   if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
624                               /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
625     Diags.Report(diag::err_fe_unable_to_interface_with_target);
626     return false;
627   }
628 
629   return true;
630 }
631 
632 static OptimizationLevel mapToLevel(const CodeGenOptions &Opts) {
633   switch (Opts.OptimizationLevel) {
634   default:
635     llvm_unreachable("Invalid optimization level!");
636 
637   case 0:
638     return OptimizationLevel::O0;
639 
640   case 1:
641     return OptimizationLevel::O1;
642 
643   case 2:
644     switch (Opts.OptimizeSize) {
645     default:
646       llvm_unreachable("Invalid optimization level for size!");
647 
648     case 0:
649       return OptimizationLevel::O2;
650 
651     case 1:
652       return OptimizationLevel::Os;
653 
654     case 2:
655       return OptimizationLevel::Oz;
656     }
657 
658   case 3:
659     return OptimizationLevel::O3;
660   }
661 }
662 
663 static void addKCFIPass(const Triple &TargetTriple, const LangOptions &LangOpts,
664                         PassBuilder &PB) {
665   // If the back-end supports KCFI operand bundle lowering, skip KCFIPass.
666   if (TargetTriple.getArch() == llvm::Triple::x86_64 ||
667       TargetTriple.isAArch64(64) || TargetTriple.isRISCV())
668     return;
669 
670   // Ensure we lower KCFI operand bundles with -O0.
671   PB.registerOptimizerLastEPCallback(
672       [&](ModulePassManager &MPM, OptimizationLevel Level, ThinOrFullLTOPhase) {
673         if (Level == OptimizationLevel::O0 &&
674             LangOpts.Sanitize.has(SanitizerKind::KCFI))
675           MPM.addPass(createModuleToFunctionPassAdaptor(KCFIPass()));
676       });
677 
678   // When optimizations are requested, run KCIFPass after InstCombine to
679   // avoid unnecessary checks.
680   PB.registerPeepholeEPCallback(
681       [&](FunctionPassManager &FPM, OptimizationLevel Level) {
682         if (Level != OptimizationLevel::O0 &&
683             LangOpts.Sanitize.has(SanitizerKind::KCFI))
684           FPM.addPass(KCFIPass());
685       });
686 }
687 
688 static void addSanitizers(const Triple &TargetTriple,
689                           const CodeGenOptions &CodeGenOpts,
690                           const LangOptions &LangOpts, PassBuilder &PB) {
691   auto SanitizersCallback = [&](ModulePassManager &MPM, OptimizationLevel Level,
692                                 ThinOrFullLTOPhase) {
693     if (CodeGenOpts.hasSanitizeCoverage()) {
694       auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);
695       MPM.addPass(SanitizerCoveragePass(
696           SancovOpts, CodeGenOpts.SanitizeCoverageAllowlistFiles,
697           CodeGenOpts.SanitizeCoverageIgnorelistFiles));
698     }
699 
700     if (CodeGenOpts.hasSanitizeBinaryMetadata()) {
701       MPM.addPass(SanitizerBinaryMetadataPass(
702           getSanitizerBinaryMetadataOptions(CodeGenOpts),
703           CodeGenOpts.SanitizeMetadataIgnorelistFiles));
704     }
705 
706     auto MSanPass = [&](SanitizerMask Mask, bool CompileKernel) {
707       if (LangOpts.Sanitize.has(Mask)) {
708         int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;
709         bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
710 
711         MemorySanitizerOptions options(TrackOrigins, Recover, CompileKernel,
712                                        CodeGenOpts.SanitizeMemoryParamRetval);
713         MPM.addPass(MemorySanitizerPass(options));
714         if (Level != OptimizationLevel::O0) {
715           // MemorySanitizer inserts complex instrumentation that mostly follows
716           // the logic of the original code, but operates on "shadow" values. It
717           // can benefit from re-running some general purpose optimization
718           // passes.
719           MPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
720           FunctionPassManager FPM;
721           FPM.addPass(EarlyCSEPass(true /* Enable mem-ssa. */));
722           FPM.addPass(InstCombinePass());
723           FPM.addPass(JumpThreadingPass());
724           FPM.addPass(GVNPass());
725           FPM.addPass(InstCombinePass());
726           MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
727         }
728       }
729     };
730     MSanPass(SanitizerKind::Memory, false);
731     MSanPass(SanitizerKind::KernelMemory, true);
732 
733     if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
734       MPM.addPass(ModuleThreadSanitizerPass());
735       MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
736     }
737 
738     if (LangOpts.Sanitize.has(SanitizerKind::NumericalStability))
739       MPM.addPass(NumericalStabilitySanitizerPass());
740 
741     if (LangOpts.Sanitize.has(SanitizerKind::Realtime))
742       MPM.addPass(RealtimeSanitizerPass());
743 
744     auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
745       if (LangOpts.Sanitize.has(Mask)) {
746         bool UseGlobalGC = asanUseGlobalsGC(TargetTriple, CodeGenOpts);
747         bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
748         llvm::AsanDtorKind DestructorKind =
749             CodeGenOpts.getSanitizeAddressDtor();
750         AddressSanitizerOptions Opts;
751         Opts.CompileKernel = CompileKernel;
752         Opts.Recover = CodeGenOpts.SanitizeRecover.has(Mask);
753         Opts.UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
754         Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();
755         MPM.addPass(AddressSanitizerPass(Opts, UseGlobalGC, UseOdrIndicator,
756                                          DestructorKind));
757       }
758     };
759     ASanPass(SanitizerKind::Address, false);
760     ASanPass(SanitizerKind::KernelAddress, true);
761 
762     auto HWASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
763       if (LangOpts.Sanitize.has(Mask)) {
764         bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
765         MPM.addPass(HWAddressSanitizerPass(
766             {CompileKernel, Recover,
767              /*DisableOptimization=*/CodeGenOpts.OptimizationLevel == 0}));
768       }
769     };
770     HWASanPass(SanitizerKind::HWAddress, false);
771     HWASanPass(SanitizerKind::KernelHWAddress, true);
772 
773     if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
774       MPM.addPass(DataFlowSanitizerPass(LangOpts.NoSanitizeFiles));
775     }
776   };
777   if (ClSanitizeOnOptimizerEarlyEP) {
778     PB.registerOptimizerEarlyEPCallback(
779         [SanitizersCallback](ModulePassManager &MPM, OptimizationLevel Level,
780                              ThinOrFullLTOPhase Phase) {
781           ModulePassManager NewMPM;
782           SanitizersCallback(NewMPM, Level, Phase);
783           if (!NewMPM.isEmpty()) {
784             // Sanitizers can abandon<GlobalsAA>.
785             NewMPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());
786             MPM.addPass(std::move(NewMPM));
787           }
788         });
789   } else {
790     // LastEP does not need GlobalsAA.
791     PB.registerOptimizerLastEPCallback(SanitizersCallback);
792   }
793 
794   if (LowerAllowCheckPass::IsRequested()) {
795     // We want to call it after inline, which is about OptimizerEarlyEPCallback.
796     PB.registerOptimizerEarlyEPCallback([](ModulePassManager &MPM,
797                                            OptimizationLevel Level,
798                                            ThinOrFullLTOPhase Phase) {
799       MPM.addPass(createModuleToFunctionPassAdaptor(LowerAllowCheckPass()));
800     });
801   }
802 }
803 
804 void EmitAssemblyHelper::RunOptimizationPipeline(
805     BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
806     std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS, BackendConsumer *BC) {
807   std::optional<PGOOptions> PGOOpt;
808 
809   if (CodeGenOpts.hasProfileIRInstr())
810     // -fprofile-generate.
811     PGOOpt = PGOOptions(
812         CodeGenOpts.InstrProfileOutput.empty() ? getDefaultProfileGenName()
813                                                : CodeGenOpts.InstrProfileOutput,
814         "", "", CodeGenOpts.MemoryProfileUsePath, nullptr, PGOOptions::IRInstr,
815         PGOOptions::NoCSAction, ClPGOColdFuncAttr,
816         CodeGenOpts.DebugInfoForProfiling,
817         /*PseudoProbeForProfiling=*/false, CodeGenOpts.AtomicProfileUpdate);
818   else if (CodeGenOpts.hasProfileIRUse()) {
819     // -fprofile-use.
820     auto CSAction = CodeGenOpts.hasProfileCSIRUse() ? PGOOptions::CSIRUse
821                                                     : PGOOptions::NoCSAction;
822     PGOOpt = PGOOptions(CodeGenOpts.ProfileInstrumentUsePath, "",
823                         CodeGenOpts.ProfileRemappingFile,
824                         CodeGenOpts.MemoryProfileUsePath, VFS,
825                         PGOOptions::IRUse, CSAction, ClPGOColdFuncAttr,
826                         CodeGenOpts.DebugInfoForProfiling);
827   } else if (!CodeGenOpts.SampleProfileFile.empty())
828     // -fprofile-sample-use
829     PGOOpt = PGOOptions(
830         CodeGenOpts.SampleProfileFile, "", CodeGenOpts.ProfileRemappingFile,
831         CodeGenOpts.MemoryProfileUsePath, VFS, PGOOptions::SampleUse,
832         PGOOptions::NoCSAction, ClPGOColdFuncAttr,
833         CodeGenOpts.DebugInfoForProfiling, CodeGenOpts.PseudoProbeForProfiling);
834   else if (!CodeGenOpts.MemoryProfileUsePath.empty())
835     // -fmemory-profile-use (without any of the above options)
836     PGOOpt = PGOOptions("", "", "", CodeGenOpts.MemoryProfileUsePath, VFS,
837                         PGOOptions::NoAction, PGOOptions::NoCSAction,
838                         ClPGOColdFuncAttr, CodeGenOpts.DebugInfoForProfiling);
839   else if (CodeGenOpts.PseudoProbeForProfiling)
840     // -fpseudo-probe-for-profiling
841     PGOOpt =
842         PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,
843                    PGOOptions::NoAction, PGOOptions::NoCSAction,
844                    ClPGOColdFuncAttr, CodeGenOpts.DebugInfoForProfiling, true);
845   else if (CodeGenOpts.DebugInfoForProfiling)
846     // -fdebug-info-for-profiling
847     PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,
848                         PGOOptions::NoAction, PGOOptions::NoCSAction,
849                         ClPGOColdFuncAttr, true);
850 
851   // Check to see if we want to generate a CS profile.
852   if (CodeGenOpts.hasProfileCSIRInstr()) {
853     assert(!CodeGenOpts.hasProfileCSIRUse() &&
854            "Cannot have both CSProfileUse pass and CSProfileGen pass at "
855            "the same time");
856     if (PGOOpt) {
857       assert(PGOOpt->Action != PGOOptions::IRInstr &&
858              PGOOpt->Action != PGOOptions::SampleUse &&
859              "Cannot run CSProfileGen pass with ProfileGen or SampleUse "
860              " pass");
861       PGOOpt->CSProfileGenFile = CodeGenOpts.InstrProfileOutput.empty()
862                                      ? getDefaultProfileGenName()
863                                      : CodeGenOpts.InstrProfileOutput;
864       PGOOpt->CSAction = PGOOptions::CSIRInstr;
865     } else
866       PGOOpt = PGOOptions("",
867                           CodeGenOpts.InstrProfileOutput.empty()
868                               ? getDefaultProfileGenName()
869                               : CodeGenOpts.InstrProfileOutput,
870                           "", /*MemoryProfile=*/"", nullptr,
871                           PGOOptions::NoAction, PGOOptions::CSIRInstr,
872                           ClPGOColdFuncAttr, CodeGenOpts.DebugInfoForProfiling);
873   }
874   if (TM)
875     TM->setPGOOption(PGOOpt);
876 
877   PipelineTuningOptions PTO;
878   PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;
879   // For historical reasons, loop interleaving is set to mirror setting for loop
880   // unrolling.
881   PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;
882   PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;
883   PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;
884   PTO.MergeFunctions = CodeGenOpts.MergeFunctions;
885   // Only enable CGProfilePass when using integrated assembler, since
886   // non-integrated assemblers don't recognize .cgprofile section.
887   PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
888   PTO.UnifiedLTO = CodeGenOpts.UnifiedLTO;
889 
890   LoopAnalysisManager LAM;
891   FunctionAnalysisManager FAM;
892   CGSCCAnalysisManager CGAM;
893   ModuleAnalysisManager MAM;
894 
895   bool DebugPassStructure = CodeGenOpts.DebugPass == "Structure";
896   PassInstrumentationCallbacks PIC;
897   PrintPassOptions PrintPassOpts;
898   PrintPassOpts.Indent = DebugPassStructure;
899   PrintPassOpts.SkipAnalyses = DebugPassStructure;
900   StandardInstrumentations SI(
901       TheModule->getContext(),
902       (CodeGenOpts.DebugPassManager || DebugPassStructure),
903       CodeGenOpts.VerifyEach, PrintPassOpts);
904   SI.registerCallbacks(PIC, &MAM);
905   PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
906 
907   // Handle the assignment tracking feature options.
908   switch (CodeGenOpts.getAssignmentTrackingMode()) {
909   case CodeGenOptions::AssignmentTrackingOpts::Forced:
910     PB.registerPipelineStartEPCallback(
911         [&](ModulePassManager &MPM, OptimizationLevel Level) {
912           MPM.addPass(AssignmentTrackingPass());
913         });
914     break;
915   case CodeGenOptions::AssignmentTrackingOpts::Enabled:
916     // Disable assignment tracking in LTO builds for now as the performance
917     // cost is too high. Disable for LLDB tuning due to llvm.org/PR43126.
918     if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&
919         CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {
920       PB.registerPipelineStartEPCallback(
921           [&](ModulePassManager &MPM, OptimizationLevel Level) {
922             // Only use assignment tracking if optimisations are enabled.
923             if (Level != OptimizationLevel::O0)
924               MPM.addPass(AssignmentTrackingPass());
925           });
926     }
927     break;
928   case CodeGenOptions::AssignmentTrackingOpts::Disabled:
929     break;
930   }
931 
932   // Enable verify-debuginfo-preserve-each for new PM.
933   DebugifyEachInstrumentation Debugify;
934   DebugInfoPerPass DebugInfoBeforePass;
935   if (CodeGenOpts.EnableDIPreservationVerify) {
936     Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
937     Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);
938 
939     if (!CodeGenOpts.DIBugsReportFilePath.empty())
940       Debugify.setOrigDIVerifyBugsReportFilePath(
941           CodeGenOpts.DIBugsReportFilePath);
942     Debugify.registerCallbacks(PIC, MAM);
943   }
944   // Attempt to load pass plugins and register their callbacks with PB.
945   for (auto &PluginFN : CodeGenOpts.PassPlugins) {
946     auto PassPlugin = PassPlugin::Load(PluginFN);
947     if (PassPlugin) {
948       PassPlugin->registerPassBuilderCallbacks(PB);
949     } else {
950       Diags.Report(diag::err_fe_unable_to_load_plugin)
951           << PluginFN << toString(PassPlugin.takeError());
952     }
953   }
954   for (const auto &PassCallback : CodeGenOpts.PassBuilderCallbacks)
955     PassCallback(PB);
956 #define HANDLE_EXTENSION(Ext)                                                  \
957   get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
958 #include "llvm/Support/Extension.def"
959 
960   // Register the target library analysis directly and give it a customized
961   // preset TLI.
962   std::unique_ptr<TargetLibraryInfoImpl> TLII(
963       llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));
964   FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
965 
966   // Register all the basic analyses with the managers.
967   PB.registerModuleAnalyses(MAM);
968   PB.registerCGSCCAnalyses(CGAM);
969   PB.registerFunctionAnalyses(FAM);
970   PB.registerLoopAnalyses(LAM);
971   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
972 
973   ModulePassManager MPM;
974   // Add a verifier pass, before any other passes, to catch CodeGen issues.
975   if (CodeGenOpts.VerifyModule)
976     MPM.addPass(VerifierPass());
977 
978   if (!CodeGenOpts.DisableLLVMPasses) {
979     // Map our optimization levels into one of the distinct levels used to
980     // configure the pipeline.
981     OptimizationLevel Level = mapToLevel(CodeGenOpts);
982 
983     const bool PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;
984     const bool PrepareForLTO = CodeGenOpts.PrepareForLTO;
985 
986     if (LangOpts.ObjCAutoRefCount) {
987       PB.registerPipelineStartEPCallback(
988           [](ModulePassManager &MPM, OptimizationLevel Level) {
989             if (Level != OptimizationLevel::O0)
990               MPM.addPass(
991                   createModuleToFunctionPassAdaptor(ObjCARCExpandPass()));
992           });
993       PB.registerPipelineEarlySimplificationEPCallback(
994           [](ModulePassManager &MPM, OptimizationLevel Level,
995              ThinOrFullLTOPhase) {
996             if (Level != OptimizationLevel::O0)
997               MPM.addPass(ObjCARCAPElimPass());
998           });
999       PB.registerScalarOptimizerLateEPCallback(
1000           [](FunctionPassManager &FPM, OptimizationLevel Level) {
1001             if (Level != OptimizationLevel::O0)
1002               FPM.addPass(ObjCARCOptPass());
1003           });
1004     }
1005 
1006     // If we reached here with a non-empty index file name, then the index
1007     // file was empty and we are not performing ThinLTO backend compilation
1008     // (used in testing in a distributed build environment).
1009     bool IsThinLTOPostLink = !CodeGenOpts.ThinLTOIndexFile.empty();
1010     // If so drop any the type test assume sequences inserted for whole program
1011     // vtables so that codegen doesn't complain.
1012     if (IsThinLTOPostLink)
1013       PB.registerPipelineStartEPCallback(
1014           [](ModulePassManager &MPM, OptimizationLevel Level) {
1015             MPM.addPass(LowerTypeTestsPass(
1016                 /*ExportSummary=*/nullptr,
1017                 /*ImportSummary=*/nullptr,
1018                 /*DropTypeTests=*/lowertypetests::DropTestKind::Assume));
1019           });
1020 
1021     // Register callbacks to schedule sanitizer passes at the appropriate part
1022     // of the pipeline.
1023     if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
1024       PB.registerScalarOptimizerLateEPCallback(
1025           [](FunctionPassManager &FPM, OptimizationLevel Level) {
1026             FPM.addPass(BoundsCheckingPass());
1027           });
1028 
1029     // Don't add sanitizers if we are here from ThinLTO PostLink. That already
1030     // done on PreLink stage.
1031     if (!IsThinLTOPostLink) {
1032       addSanitizers(TargetTriple, CodeGenOpts, LangOpts, PB);
1033       addKCFIPass(TargetTriple, LangOpts, PB);
1034     }
1035 
1036     if (std::optional<GCOVOptions> Options =
1037             getGCOVOptions(CodeGenOpts, LangOpts))
1038       PB.registerPipelineStartEPCallback(
1039           [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1040             MPM.addPass(GCOVProfilerPass(*Options));
1041           });
1042     if (std::optional<InstrProfOptions> Options =
1043             getInstrProfOptions(CodeGenOpts, LangOpts))
1044       PB.registerPipelineStartEPCallback(
1045           [Options](ModulePassManager &MPM, OptimizationLevel Level) {
1046             MPM.addPass(InstrProfilingLoweringPass(*Options, false));
1047           });
1048 
1049     // TODO: Consider passing the MemoryProfileOutput to the pass builder via
1050     // the PGOOptions, and set this up there.
1051     if (!CodeGenOpts.MemoryProfileOutput.empty()) {
1052       PB.registerOptimizerLastEPCallback([](ModulePassManager &MPM,
1053                                             OptimizationLevel Level,
1054                                             ThinOrFullLTOPhase) {
1055         MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
1056         MPM.addPass(ModuleMemProfilerPass());
1057       });
1058     }
1059 
1060     if (CodeGenOpts.FatLTO) {
1061       MPM.addPass(PB.buildFatLTODefaultPipeline(
1062           Level, PrepareForThinLTO,
1063           PrepareForThinLTO || shouldEmitRegularLTOSummary()));
1064     } else if (PrepareForThinLTO) {
1065       MPM.addPass(PB.buildThinLTOPreLinkDefaultPipeline(Level));
1066     } else if (PrepareForLTO) {
1067       MPM.addPass(PB.buildLTOPreLinkDefaultPipeline(Level));
1068     } else {
1069       MPM.addPass(PB.buildPerModuleDefaultPipeline(Level));
1070     }
1071   }
1072 
1073   // Link against bitcodes supplied via the -mlink-builtin-bitcode option
1074   if (CodeGenOpts.LinkBitcodePostopt)
1075     MPM.addPass(LinkInModulesPass(BC));
1076 
1077   // Add a verifier pass if requested. We don't have to do this if the action
1078   // requires code generation because there will already be a verifier pass in
1079   // the code-generation pipeline.
1080   // Since we already added a verifier pass above, this
1081   // might even not run the analysis, if previous passes caused no changes.
1082   if (!actionRequiresCodeGen(Action) && CodeGenOpts.VerifyModule)
1083     MPM.addPass(VerifierPass());
1084 
1085   if (Action == Backend_EmitBC || Action == Backend_EmitLL ||
1086       CodeGenOpts.FatLTO) {
1087     if (CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.DisableLLVMPasses) {
1088       if (!TheModule->getModuleFlag("EnableSplitLTOUnit"))
1089         TheModule->addModuleFlag(llvm::Module::Error, "EnableSplitLTOUnit",
1090                                  CodeGenOpts.EnableSplitLTOUnit);
1091       if (Action == Backend_EmitBC) {
1092         if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
1093           ThinLinkOS = openOutputFile(CodeGenOpts.ThinLinkBitcodeFile);
1094           if (!ThinLinkOS)
1095             return;
1096         }
1097         MPM.addPass(ThinLTOBitcodeWriterPass(
1098             *OS, ThinLinkOS ? &ThinLinkOS->os() : nullptr));
1099       } else if (Action == Backend_EmitLL) {
1100         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
1101                                     /*EmitLTOSummary=*/true));
1102       }
1103     } else {
1104       // Emit a module summary by default for Regular LTO except for ld64
1105       // targets
1106       bool EmitLTOSummary = shouldEmitRegularLTOSummary();
1107       if (EmitLTOSummary) {
1108         if (!TheModule->getModuleFlag("ThinLTO") && !CodeGenOpts.UnifiedLTO)
1109           TheModule->addModuleFlag(llvm::Module::Error, "ThinLTO", uint32_t(0));
1110         if (!TheModule->getModuleFlag("EnableSplitLTOUnit"))
1111           TheModule->addModuleFlag(llvm::Module::Error, "EnableSplitLTOUnit",
1112                                    uint32_t(1));
1113       }
1114       if (Action == Backend_EmitBC) {
1115         MPM.addPass(BitcodeWriterPass(*OS, CodeGenOpts.EmitLLVMUseLists,
1116                                       EmitLTOSummary));
1117       } else if (Action == Backend_EmitLL) {
1118         MPM.addPass(PrintModulePass(*OS, "", CodeGenOpts.EmitLLVMUseLists,
1119                                     EmitLTOSummary));
1120       }
1121     }
1122 
1123     if (shouldEmitUnifiedLTOModueFlag())
1124       TheModule->addModuleFlag(llvm::Module::Error, "UnifiedLTO", uint32_t(1));
1125   }
1126 
1127   // FIXME: This should eventually be replaced by a first-class driver option.
1128   // This should be done for both clang and flang simultaneously.
1129   // Print a textual, '-passes=' compatible, representation of pipeline if
1130   // requested.
1131   if (PrintPipelinePasses) {
1132     MPM.printPipeline(outs(), [&PIC](StringRef ClassName) {
1133       auto PassName = PIC.getPassNameForClassName(ClassName);
1134       return PassName.empty() ? ClassName : PassName;
1135     });
1136     outs() << "\n";
1137     return;
1138   }
1139 
1140   if (LangOpts.HIPStdPar && !LangOpts.CUDAIsDevice &&
1141       LangOpts.HIPStdParInterposeAlloc)
1142     MPM.addPass(HipStdParAllocationInterpositionPass());
1143 
1144   // Now that we have all of the passes ready, run them.
1145   {
1146     PrettyStackTraceString CrashInfo("Optimizer");
1147     llvm::TimeTraceScope TimeScope("Optimizer");
1148     MPM.run(*TheModule, MAM);
1149   }
1150 }
1151 
1152 void EmitAssemblyHelper::RunCodegenPipeline(
1153     BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
1154     std::unique_ptr<llvm::ToolOutputFile> &DwoOS) {
1155   // We still use the legacy PM to run the codegen pipeline since the new PM
1156   // does not work with the codegen pipeline.
1157   // FIXME: make the new PM work with the codegen pipeline.
1158   legacy::PassManager CodeGenPasses;
1159 
1160   // Append any output we need to the pass manager.
1161   switch (Action) {
1162   case Backend_EmitAssembly:
1163   case Backend_EmitMCNull:
1164   case Backend_EmitObj:
1165     CodeGenPasses.add(
1166         createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
1167     if (!CodeGenOpts.SplitDwarfOutput.empty()) {
1168       DwoOS = openOutputFile(CodeGenOpts.SplitDwarfOutput);
1169       if (!DwoOS)
1170         return;
1171     }
1172     if (!AddEmitPasses(CodeGenPasses, Action, *OS,
1173                        DwoOS ? &DwoOS->os() : nullptr))
1174       // FIXME: Should we handle this error differently?
1175       return;
1176     break;
1177   default:
1178     return;
1179   }
1180 
1181   // If -print-pipeline-passes is requested, don't run the legacy pass manager.
1182   // FIXME: when codegen is switched to use the new pass manager, it should also
1183   // emit pass names here.
1184   if (PrintPipelinePasses) {
1185     return;
1186   }
1187 
1188   {
1189     PrettyStackTraceString CrashInfo("Code generation");
1190     llvm::TimeTraceScope TimeScope("CodeGenPasses");
1191     CodeGenPasses.run(*TheModule);
1192   }
1193 }
1194 
1195 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
1196                                       std::unique_ptr<raw_pwrite_stream> OS,
1197                                       BackendConsumer *BC) {
1198   TimeRegion Region(CodeGenOpts.TimePasses ? &CodeGenerationTime : nullptr);
1199   setCommandLineOpts(CodeGenOpts);
1200 
1201   bool RequiresCodeGen = actionRequiresCodeGen(Action);
1202   CreateTargetMachine(RequiresCodeGen);
1203 
1204   if (RequiresCodeGen && !TM)
1205     return;
1206   if (TM)
1207     TheModule->setDataLayout(TM->createDataLayout());
1208 
1209   // Before executing passes, print the final values of the LLVM options.
1210   cl::PrintOptionValues();
1211 
1212   std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
1213   RunOptimizationPipeline(Action, OS, ThinLinkOS, BC);
1214   RunCodegenPipeline(Action, OS, DwoOS);
1215 
1216   if (ThinLinkOS)
1217     ThinLinkOS->keep();
1218   if (DwoOS)
1219     DwoOS->keep();
1220 }
1221 
1222 static void runThinLTOBackend(
1223     DiagnosticsEngine &Diags, ModuleSummaryIndex *CombinedIndex,
1224     llvm::Module *M, const HeaderSearchOptions &HeaderOpts,
1225     const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts,
1226     const LangOptions &LOpts, std::unique_ptr<raw_pwrite_stream> OS,
1227     std::string SampleProfile, std::string ProfileRemapping,
1228     BackendAction Action) {
1229   DenseMap<StringRef, DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
1230       ModuleToDefinedGVSummaries;
1231   CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
1232 
1233   setCommandLineOpts(CGOpts);
1234 
1235   // We can simply import the values mentioned in the combined index, since
1236   // we should only invoke this using the individual indexes written out
1237   // via a WriteIndexesThinBackend.
1238   FunctionImporter::ImportIDTable ImportIDs;
1239   FunctionImporter::ImportMapTy ImportList(ImportIDs);
1240   if (!lto::initImportList(*M, *CombinedIndex, ImportList))
1241     return;
1242 
1243   auto AddStream = [&](size_t Task, const Twine &ModuleName) {
1244     return std::make_unique<CachedFileStream>(std::move(OS),
1245                                               CGOpts.ObjectFilenameForDebug);
1246   };
1247   lto::Config Conf;
1248   if (CGOpts.SaveTempsFilePrefix != "") {
1249     if (Error E = Conf.addSaveTemps(CGOpts.SaveTempsFilePrefix + ".",
1250                                     /* UseInputModulePath */ false)) {
1251       handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1252         errs() << "Error setting up ThinLTO save-temps: " << EIB.message()
1253                << '\n';
1254       });
1255     }
1256   }
1257   Conf.CPU = TOpts.CPU;
1258   Conf.CodeModel = getCodeModel(CGOpts);
1259   Conf.MAttrs = TOpts.Features;
1260   Conf.RelocModel = CGOpts.RelocationModel;
1261   std::optional<CodeGenOptLevel> OptLevelOrNone =
1262       CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
1263   assert(OptLevelOrNone && "Invalid optimization level!");
1264   Conf.CGOptLevel = *OptLevelOrNone;
1265   Conf.OptLevel = CGOpts.OptimizationLevel;
1266   initTargetOptions(Diags, Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts);
1267   Conf.SampleProfile = std::move(SampleProfile);
1268   Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
1269   // For historical reasons, loop interleaving is set to mirror setting for loop
1270   // unrolling.
1271   Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
1272   Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
1273   Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;
1274   // Only enable CGProfilePass when using integrated assembler, since
1275   // non-integrated assemblers don't recognize .cgprofile section.
1276   Conf.PTO.CallGraphProfile = !CGOpts.DisableIntegratedAS;
1277 
1278   // Context sensitive profile.
1279   if (CGOpts.hasProfileCSIRInstr()) {
1280     Conf.RunCSIRInstr = true;
1281     Conf.CSIRProfile = std::move(CGOpts.InstrProfileOutput);
1282   } else if (CGOpts.hasProfileCSIRUse()) {
1283     Conf.RunCSIRInstr = false;
1284     Conf.CSIRProfile = std::move(CGOpts.ProfileInstrumentUsePath);
1285   }
1286 
1287   Conf.ProfileRemapping = std::move(ProfileRemapping);
1288   Conf.DebugPassManager = CGOpts.DebugPassManager;
1289   Conf.VerifyEach = CGOpts.VerifyEach;
1290   Conf.RemarksWithHotness = CGOpts.DiagnosticsWithHotness;
1291   Conf.RemarksFilename = CGOpts.OptRecordFile;
1292   Conf.RemarksPasses = CGOpts.OptRecordPasses;
1293   Conf.RemarksFormat = CGOpts.OptRecordFormat;
1294   Conf.SplitDwarfFile = CGOpts.SplitDwarfFile;
1295   Conf.SplitDwarfOutput = CGOpts.SplitDwarfOutput;
1296   switch (Action) {
1297   case Backend_EmitNothing:
1298     Conf.PreCodeGenModuleHook = [](size_t Task, const llvm::Module &Mod) {
1299       return false;
1300     };
1301     break;
1302   case Backend_EmitLL:
1303     Conf.PreCodeGenModuleHook = [&](size_t Task, const llvm::Module &Mod) {
1304       M->print(*OS, nullptr, CGOpts.EmitLLVMUseLists);
1305       return false;
1306     };
1307     break;
1308   case Backend_EmitBC:
1309     Conf.PreCodeGenModuleHook = [&](size_t Task, const llvm::Module &Mod) {
1310       WriteBitcodeToFile(*M, *OS, CGOpts.EmitLLVMUseLists);
1311       return false;
1312     };
1313     break;
1314   default:
1315     Conf.CGFileType = getCodeGenFileType(Action);
1316     break;
1317   }
1318   if (Error E =
1319           thinBackend(Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
1320                       ModuleToDefinedGVSummaries[M->getModuleIdentifier()],
1321                       /*ModuleMap=*/nullptr, Conf.CodeGenOnly,
1322                       /*IRAddStream=*/nullptr, CGOpts.CmdArgs)) {
1323     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
1324       errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
1325     });
1326   }
1327 }
1328 
1329 void clang::EmitBackendOutput(
1330     DiagnosticsEngine &Diags, const HeaderSearchOptions &HeaderOpts,
1331     const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts,
1332     const LangOptions &LOpts, StringRef TDesc, llvm::Module *M,
1333     BackendAction Action, IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
1334     std::unique_ptr<raw_pwrite_stream> OS, BackendConsumer *BC) {
1335 
1336   llvm::TimeTraceScope TimeScope("Backend");
1337 
1338   std::unique_ptr<llvm::Module> EmptyModule;
1339   if (!CGOpts.ThinLTOIndexFile.empty()) {
1340     // If we are performing a ThinLTO importing compile, load the function index
1341     // into memory and pass it into runThinLTOBackend, which will run the
1342     // function importer and invoke LTO passes.
1343     std::unique_ptr<ModuleSummaryIndex> CombinedIndex;
1344     if (Error E = llvm::getModuleSummaryIndexForFile(
1345                       CGOpts.ThinLTOIndexFile,
1346                       /*IgnoreEmptyThinLTOIndexFile*/ true)
1347                       .moveInto(CombinedIndex)) {
1348       logAllUnhandledErrors(std::move(E), errs(),
1349                             "Error loading index file '" +
1350                             CGOpts.ThinLTOIndexFile + "': ");
1351       return;
1352     }
1353 
1354     // A null CombinedIndex means we should skip ThinLTO compilation
1355     // (LLVM will optionally ignore empty index files, returning null instead
1356     // of an error).
1357     if (CombinedIndex) {
1358       if (!CombinedIndex->skipModuleByDistributedBackend()) {
1359         runThinLTOBackend(Diags, CombinedIndex.get(), M, HeaderOpts, CGOpts,
1360                           TOpts, LOpts, std::move(OS), CGOpts.SampleProfileFile,
1361                           CGOpts.ProfileRemappingFile, Action);
1362         return;
1363       }
1364       // Distributed indexing detected that nothing from the module is needed
1365       // for the final linking. So we can skip the compilation. We sill need to
1366       // output an empty object file to make sure that a linker does not fail
1367       // trying to read it. Also for some features, like CFI, we must skip
1368       // the compilation as CombinedIndex does not contain all required
1369       // information.
1370       EmptyModule = std::make_unique<llvm::Module>("empty", M->getContext());
1371       EmptyModule->setTargetTriple(M->getTargetTriple());
1372       M = EmptyModule.get();
1373     }
1374   }
1375 
1376   EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M, VFS);
1377   AsmHelper.EmitAssembly(Action, std::move(OS), BC);
1378 
1379   // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
1380   // DataLayout.
1381   if (AsmHelper.TM) {
1382     std::string DLDesc = M->getDataLayout().getStringRepresentation();
1383     if (DLDesc != TDesc) {
1384       unsigned DiagID = Diags.getCustomDiagID(
1385           DiagnosticsEngine::Error, "backend data layout '%0' does not match "
1386                                     "expected target description '%1'");
1387       Diags.Report(DiagID) << DLDesc << TDesc;
1388     }
1389   }
1390 }
1391 
1392 // With -fembed-bitcode, save a copy of the llvm IR as data in the
1393 // __LLVM,__bitcode section.
1394 void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
1395                          llvm::MemoryBufferRef Buf) {
1396   if (CGOpts.getEmbedBitcode() == CodeGenOptions::Embed_Off)
1397     return;
1398   llvm::embedBitcodeInModule(
1399       *M, Buf, CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Marker,
1400       CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Bitcode,
1401       CGOpts.CmdArgs);
1402 }
1403 
1404 void clang::EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts,
1405                         DiagnosticsEngine &Diags) {
1406   if (CGOpts.OffloadObjects.empty())
1407     return;
1408 
1409   for (StringRef OffloadObject : CGOpts.OffloadObjects) {
1410     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ObjectOrErr =
1411         llvm::MemoryBuffer::getFileOrSTDIN(OffloadObject);
1412     if (ObjectOrErr.getError()) {
1413       auto DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1414                                           "could not open '%0' for embedding");
1415       Diags.Report(DiagID) << OffloadObject;
1416       return;
1417     }
1418 
1419     llvm::embedBufferInModule(*M, **ObjectOrErr, ".llvm.offloading",
1420                               Align(object::OffloadBinary::getAlignment()));
1421   }
1422 }
1423