//===--- BackendUtil.cpp - LLVM Backend Utilities -------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "clang/CodeGen/BackendUtil.h"

#include "BackendConsumer.h"

#include "LinkInModulesPass.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/TargetOptions.h"

#include "clang/Frontend/FrontendDiagnostic.h"

#include "clang/Frontend/Utils.h"

#include "clang/Lex/HeaderSearchOptions.h"

#include "llvm/ADT/SmallSet.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Analysis/AliasAnalysis.h"

#include "llvm/Analysis/GlobalsModRef.h"

#include "llvm/Analysis/TargetLibraryInfo.h"

#include "llvm/Analysis/TargetTransformInfo.h"

#include "llvm/Bitcode/BitcodeReader.h"

#include "llvm/Bitcode/BitcodeWriter.h"

#include "llvm/Bitcode/BitcodeWriterPass.h"

#include "llvm/CodeGen/RegAllocRegistry.h"

#include "llvm/CodeGen/SchedulerRegistry.h"

#include "llvm/CodeGen/TargetSubtargetInfo.h"

#include "llvm/Frontend/Driver/CodeGenOptions.h"

#include "llvm/IR/DataLayout.h"

#include "llvm/IR/DebugInfo.h"

#include "llvm/IR/LegacyPassManager.h"

#include "llvm/IR/Module.h"

#include "llvm/IR/ModuleSummaryIndex.h"

#include "llvm/IR/PassManager.h"

#include "llvm/IR/Verifier.h"

#include "llvm/IRPrinter/IRPrintingPasses.h"

#include "llvm/LTO/LTOBackend.h"

#include "llvm/MC/MCAsmInfo.h"

#include "llvm/MC/TargetRegistry.h"

#include "llvm/Object/OffloadBinary.h"

#include "llvm/Passes/PassBuilder.h"

#include "llvm/Passes/PassPlugin.h"

#include "llvm/Passes/StandardInstrumentations.h"

#include "llvm/ProfileData/InstrProfCorrelator.h"

#include "llvm/Support/BuryPointer.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/PrettyStackTrace.h"

#include "llvm/Support/TimeProfiler.h"

#include "llvm/Support/Timer.h"

#include "llvm/Support/ToolOutputFile.h"

#include "llvm/Support/VirtualFileSystem.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Target/TargetMachine.h"

#include "llvm/Target/TargetOptions.h"

#include "llvm/TargetParser/SubtargetFeature.h"

#include "llvm/TargetParser/Triple.h"

#include "llvm/Transforms/HipStdPar/HipStdPar.h"

#include "llvm/Transforms/IPO/EmbedBitcodePass.h"

#include "llvm/Transforms/IPO/LowerTypeTests.h"

#include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"

#include "llvm/Transforms/InstCombine/InstCombine.h"

#include "llvm/Transforms/Instrumentation.h"

#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"

#include "llvm/Transforms/Instrumentation/AddressSanitizerOptions.h"

#include "llvm/Transforms/Instrumentation/BoundsChecking.h"

#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"

#include "llvm/Transforms/Instrumentation/GCOVProfiler.h"

#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"

#include "llvm/Transforms/Instrumentation/InstrProfiling.h"

#include "llvm/Transforms/Instrumentation/KCFI.h"

#include "llvm/Transforms/Instrumentation/MemProfiler.h"

#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"

#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"

#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"

#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"

#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"

#include "llvm/Transforms/ObjCARC.h"

#include "llvm/Transforms/Scalar/EarlyCSE.h"

#include "llvm/Transforms/Scalar/GVN.h"

#include "llvm/Transforms/Scalar/JumpThreading.h"

#include "llvm/Transforms/Utils/Debugify.h"

#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"

#include "llvm/Transforms/Utils/ModuleUtils.h"

#include <memory>

#include <optional>

using namespace clang;

using namespace llvm;

#define HANDLE_EXTENSION(Ext)                                                  \

  llvm::PassPluginLibraryInfo get##Ext##PluginInfo();

#include "llvm/Support/Extension.def"

namespace llvm {

extern cl::opt<bool> PrintPipelinePasses;

// Experiment to move sanitizers earlier.

static cl::opt<bool> ClSanitizeOnOptimizerEarlyEP(

    "sanitizer-early-opt-ep", cl::Optional,

    cl::desc("Insert sanitizers on OptimizerEarlyEP."), cl::init(false));

extern cl::opt<InstrProfCorrelator::ProfCorrelatorKind> ProfileCorrelate;

// Re-link builtin bitcodes after optimization

cl::opt<bool> ClRelinkBuiltinBitcodePostop(

    "relink-builtin-bitcode-postop", cl::Optional,

    cl::desc("Re-link builtin bitcodes after optimization."), cl::init(false));

} // namespace llvm

namespace {

// Default filename used for profile generation.

std::string getDefaultProfileGenName() {

  return DebugInfoCorrelate || ProfileCorrelate != InstrProfCorrelator::NONE

             ? "default_%m.proflite"

             : "default_%m.profraw";

}

class EmitAssemblyHelper {

  DiagnosticsEngine &Diags;

  const HeaderSearchOptions &HSOpts;

  const CodeGenOptions &CodeGenOpts;

  const clang::TargetOptions &TargetOpts;

  const LangOptions &LangOpts;

  llvm::Module *TheModule;

  IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS;

  Timer CodeGenerationTime;

  std::unique_ptr<raw_pwrite_stream> OS;

  Triple TargetTriple;

  TargetIRAnalysis getTargetIRAnalysis() const {

    if (TM)

      return TM->getTargetIRAnalysis();

    return TargetIRAnalysis();

  }

  /// Generates the TargetMachine.

  /// Leaves TM unchanged if it is unable to create the target machine.

  /// Some of our clang tests specify triples which are not built

  /// into clang. This is okay because these tests check the generated

  /// IR, and they require DataLayout which depends on the triple.

  /// In this case, we allow this method to fail and not report an error.

  /// When MustCreateTM is used, we print an error if we are unable to load

  /// the requested target.

  void CreateTargetMachine(bool MustCreateTM);

  /// Add passes necessary to emit assembly or LLVM IR.

  ///

  /// \return True on success.

  bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,

                     raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);

  std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {

    std::error_code EC;

    auto F = std::make_unique<llvm::ToolOutputFile>(Path, EC,

                                                     llvm::sys::fs::OF_None);

    if (EC) {

      Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();

      F.reset();

    }

    return F;

  }

  void RunOptimizationPipeline(

      BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,

      std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS, BackendConsumer *BC);

  void RunCodegenPipeline(BackendAction Action,

                          std::unique_ptr<raw_pwrite_stream> &OS,

                          std::unique_ptr<llvm::ToolOutputFile> &DwoOS);

  /// Check whether we should emit a module summary for regular LTO.

  /// The module summary should be emitted by default for regular LTO

  /// except for ld64 targets.

  ///

  /// \return True if the module summary should be emitted.

  bool shouldEmitRegularLTOSummary() const {

    return CodeGenOpts.PrepareForLTO && !CodeGenOpts.DisableLLVMPasses &&

           TargetTriple.getVendor() != llvm::Triple::Apple;

  }

public:

  EmitAssemblyHelper(DiagnosticsEngine &_Diags,

                     const HeaderSearchOptions &HeaderSearchOpts,

                     const CodeGenOptions &CGOpts,

                     const clang::TargetOptions &TOpts,

                     const LangOptions &LOpts, llvm::Module *M,

                     IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)

      : Diags(_Diags), HSOpts(HeaderSearchOpts), CodeGenOpts(CGOpts),

        TargetOpts(TOpts), LangOpts(LOpts), TheModule(M), VFS(std::move(VFS)),

        CodeGenerationTime("codegen", "Code Generation Time"),

        TargetTriple(TheModule->getTargetTriple()) {}

  ~EmitAssemblyHelper() {

    if (CodeGenOpts.DisableFree)

      BuryPointer(std::move(TM));

  }

  std::unique_ptr<TargetMachine> TM;

  // Emit output using the new pass manager for the optimization pipeline.

  void EmitAssembly(BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,

                    BackendConsumer *BC);

};

} // namespace

static SanitizerCoverageOptions

getSancovOptsFromCGOpts(const CodeGenOptions &CGOpts) {

  SanitizerCoverageOptions Opts;

  Opts.CoverageType =

      static_cast<SanitizerCoverageOptions::Type>(CGOpts.SanitizeCoverageType);

  Opts.IndirectCalls = CGOpts.SanitizeCoverageIndirectCalls;

  Opts.TraceBB = CGOpts.SanitizeCoverageTraceBB;

  Opts.TraceCmp = CGOpts.SanitizeCoverageTraceCmp;

  Opts.TraceDiv = CGOpts.SanitizeCoverageTraceDiv;

  Opts.TraceGep = CGOpts.SanitizeCoverageTraceGep;

  Opts.Use8bitCounters = CGOpts.SanitizeCoverage8bitCounters;

  Opts.TracePC = CGOpts.SanitizeCoverageTracePC;

  Opts.TracePCGuard = CGOpts.SanitizeCoverageTracePCGuard;

  Opts.NoPrune = CGOpts.SanitizeCoverageNoPrune;

  Opts.Inline8bitCounters = CGOpts.SanitizeCoverageInline8bitCounters;

  Opts.InlineBoolFlag = CGOpts.SanitizeCoverageInlineBoolFlag;

  Opts.PCTable = CGOpts.SanitizeCoveragePCTable;

  Opts.StackDepth = CGOpts.SanitizeCoverageStackDepth;

  Opts.TraceLoads = CGOpts.SanitizeCoverageTraceLoads;

  Opts.TraceStores = CGOpts.SanitizeCoverageTraceStores;

  Opts.CollectControlFlow = CGOpts.SanitizeCoverageControlFlow;

  return Opts;

}

static SanitizerBinaryMetadataOptions

getSanitizerBinaryMetadataOptions(const CodeGenOptions &CGOpts) {

  SanitizerBinaryMetadataOptions Opts;

  Opts.Covered = CGOpts.SanitizeBinaryMetadataCovered;

  Opts.Atomics = CGOpts.SanitizeBinaryMetadataAtomics;

  Opts.UAR = CGOpts.SanitizeBinaryMetadataUAR;

  return Opts;

}

// Check if ASan should use GC-friendly instrumentation for globals.

// First of all, there is no point if -fdata-sections is off (expect for MachO,

// where this is not a factor). Also, on ELF this feature requires an assembler

// extension that only works with -integrated-as at the moment.

static bool asanUseGlobalsGC(const Triple &T, const CodeGenOptions &CGOpts) {

  if (!CGOpts.SanitizeAddressGlobalsDeadStripping)

    return false;

  switch (T.getObjectFormat()) {

  case Triple::MachO:

  case Triple::COFF:

    return true;

  case Triple::ELF:

    return !CGOpts.DisableIntegratedAS;

  case Triple::GOFF:

    llvm::report_fatal_error("ASan not implemented for GOFF");

  case Triple::XCOFF:

    llvm::report_fatal_error("ASan not implemented for XCOFF.");

  case Triple::Wasm:

  case Triple::DXContainer:

  case Triple::SPIRV:

  case Triple::UnknownObjectFormat:

    break;

  }

  return false;

}

static std::optional<llvm::CodeModel::Model>

getCodeModel(const CodeGenOptions &CodeGenOpts) {

  unsigned CodeModel = llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)

                           .Case("tiny", llvm::CodeModel::Tiny)

                           .Case("small", llvm::CodeModel::Small)

                           .Case("kernel", llvm::CodeModel::Kernel)

                           .Case("medium", llvm::CodeModel::Medium)

                           .Case("large", llvm::CodeModel::Large)

                           .Case("default", ~1u)

                           .Default(~0u);

  assert(CodeModel != ~0u && "invalid code model!");

  if (CodeModel == ~1u)

    return std::nullopt;

  return static_cast<llvm::CodeModel::Model>(CodeModel);

}

static CodeGenFileType getCodeGenFileType(BackendAction Action) {

  if (Action == Backend_EmitObj)

    return CodeGenFileType::ObjectFile;

  else if (Action == Backend_EmitMCNull)

    return CodeGenFileType::Null;

  else {

    assert(Action == Backend_EmitAssembly && "Invalid action!");

    return CodeGenFileType::AssemblyFile;

  }

}

static bool actionRequiresCodeGen(BackendAction Action) {

  return Action != Backend_EmitNothing && Action != Backend_EmitBC &&

         Action != Backend_EmitLL;

}

static bool initTargetOptions(DiagnosticsEngine &Diags,

                              llvm::TargetOptions &Options,

                              const CodeGenOptions &CodeGenOpts,

                              const clang::TargetOptions &TargetOpts,

                              const LangOptions &LangOpts,

                              const HeaderSearchOptions &HSOpts) {

  switch (LangOpts.getThreadModel()) {

  case LangOptions::ThreadModelKind::POSIX:

    Options.ThreadModel = llvm::ThreadModel::POSIX;

    break;

  case LangOptions::ThreadModelKind::Single:

    Options.ThreadModel = llvm::ThreadModel::Single;

    break;

  }

  // Set float ABI type.

  assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||

          CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&

         "Invalid Floating Point ABI!");

  Options.FloatABIType =

      llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)

          .Case("soft", llvm::FloatABI::Soft)

          .Case("softfp", llvm::FloatABI::Soft)

          .Case("hard", llvm::FloatABI::Hard)

          .Default(llvm::FloatABI::Default);

  // Set FP fusion mode.

  switch (LangOpts.getDefaultFPContractMode()) {

  case LangOptions::FPM_Off:

    // Preserve any contraction performed by the front-end.  (Strict performs

    // splitting of the muladd intrinsic in the backend.)

    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;

    break;

  case LangOptions::FPM_On:

  case LangOptions::FPM_FastHonorPragmas:

    Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;

    break;

  case LangOptions::FPM_Fast:

    Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;

    break;

  }

  Options.BinutilsVersion =

      llvm::TargetMachine::parseBinutilsVersion(CodeGenOpts.BinutilsVersion);

  Options.UseInitArray = CodeGenOpts.UseInitArray;

  Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;

  Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();

  Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;

  // Set EABI version.

  Options.EABIVersion = TargetOpts.EABIVersion;

  if (LangOpts.hasSjLjExceptions())

    Options.ExceptionModel = llvm::ExceptionHandling::SjLj;

  if (LangOpts.hasSEHExceptions())

    Options.ExceptionModel = llvm::ExceptionHandling::WinEH;

  if (LangOpts.hasDWARFExceptions())

    Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;

  if (LangOpts.hasWasmExceptions())

    Options.ExceptionModel = llvm::ExceptionHandling::Wasm;

  Options.NoInfsFPMath = LangOpts.NoHonorInfs;

  Options.NoNaNsFPMath = LangOpts.NoHonorNaNs;

  Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;

  Options.UnsafeFPMath = LangOpts.AllowFPReassoc && LangOpts.AllowRecip &&

                         LangOpts.NoSignedZero && LangOpts.ApproxFunc &&

                         (LangOpts.getDefaultFPContractMode() ==

                              LangOptions::FPModeKind::FPM_Fast ||

                          LangOpts.getDefaultFPContractMode() ==

                              LangOptions::FPModeKind::FPM_FastHonorPragmas);

  Options.ApproxFuncFPMath = LangOpts.ApproxFunc;

  Options.BBSections =

      llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections)

          .Case("all", llvm::BasicBlockSection::All)

          .Case("labels", llvm::BasicBlockSection::Labels)

          .StartsWith("list=", llvm::BasicBlockSection::List)

          .Case("none", llvm::BasicBlockSection::None)

          .Default(llvm::BasicBlockSection::None);

  if (Options.BBSections == llvm::BasicBlockSection::List) {

    ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =

        MemoryBuffer::getFile(CodeGenOpts.BBSections.substr(5));

    if (!MBOrErr) {

      Diags.Report(diag::err_fe_unable_to_load_basic_block_sections_file)

          << MBOrErr.getError().message();

      return false;

    }

    Options.BBSectionsFuncListBuf = std::move(*MBOrErr);

  }

  Options.EnableMachineFunctionSplitter = CodeGenOpts.SplitMachineFunctions;

  Options.FunctionSections = CodeGenOpts.FunctionSections;

  Options.DataSections = CodeGenOpts.DataSections;

  Options.IgnoreXCOFFVisibility = LangOpts.IgnoreXCOFFVisibility;

  Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;

  Options.UniqueBasicBlockSectionNames =

      CodeGenOpts.UniqueBasicBlockSectionNames;

  Options.TLSSize = CodeGenOpts.TLSSize;

  Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;

  Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();

  Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;

  Options.StackUsageOutput = CodeGenOpts.StackUsageOutput;

  Options.EmitAddrsig = CodeGenOpts.Addrsig;

  Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;

  Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;

  Options.EnableAIXExtendedAltivecABI = LangOpts.EnableAIXExtendedAltivecABI;

  Options.XRayFunctionIndex = CodeGenOpts.XRayFunctionIndex;

  Options.LoopAlignment = CodeGenOpts.LoopAlignment;

  Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;

  Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;

  Options.Hotpatch = CodeGenOpts.HotPatch;

  Options.JMCInstrument = CodeGenOpts.JMCInstrument;

  Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;

  switch (CodeGenOpts.getSwiftAsyncFramePointer()) {

  case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:

    Options.SwiftAsyncFramePointer =

        SwiftAsyncFramePointerMode::DeploymentBased;

    break;

  case CodeGenOptions::SwiftAsyncFramePointerKind::Always:

    Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Always;

    break;

  case CodeGenOptions::SwiftAsyncFramePointerKind::Never:

    Options.SwiftAsyncFramePointer = SwiftAsyncFramePointerMode::Never;

    break;

  }

  Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;

  Options.MCOptions.EmitDwarfUnwind = CodeGenOpts.getEmitDwarfUnwind();

  Options.MCOptions.EmitCompactUnwindNonCanonical =

      CodeGenOpts.EmitCompactUnwindNonCanonical;

  Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;

  Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;

  Options.MCOptions.MCUseDwarfDirectory =

      CodeGenOpts.NoDwarfDirectoryAsm

          ? llvm::MCTargetOptions::DisableDwarfDirectory

          : llvm::MCTargetOptions::EnableDwarfDirectory;

  Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;

  Options.MCOptions.MCIncrementalLinkerCompatible =

      CodeGenOpts.IncrementalLinkerCompatible;

  Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;

  Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;

  Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;

  Options.MCOptions.Dwarf64 = CodeGenOpts.Dwarf64;

  Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;

  Options.MCOptions.ABIName = TargetOpts.ABI;

  for (const auto &Entry : HSOpts.UserEntries)

    if (!Entry.IsFramework &&

        (Entry.Group == frontend::IncludeDirGroup::Quoted ||

         Entry.Group == frontend::IncludeDirGroup::Angled ||

         Entry.Group == frontend::IncludeDirGroup::System))

      Options.MCOptions.IASSearchPaths.push_back(

          Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);

  Options.MCOptions.Argv0 = CodeGenOpts.Argv0;

  Options.MCOptions.CommandLineArgs = CodeGenOpts.CommandLineArgs;

  Options.MCOptions.AsSecureLogFile = CodeGenOpts.AsSecureLogFile;

  Options.MCOptions.PPCUseFullRegisterNames =

      CodeGenOpts.PPCUseFullRegisterNames;

  Options.MisExpect = CodeGenOpts.MisExpect;

  return true;

}

static std::optional<GCOVOptions>

getGCOVOptions(const CodeGenOptions &CodeGenOpts, const LangOptions &LangOpts) {

  if (CodeGenOpts.CoverageNotesFile.empty() &&

      CodeGenOpts.CoverageDataFile.empty())

    return std::nullopt;

  // Not using 'GCOVOptions::getDefault' allows us to avoid exiting if

  // LLVM's -default-gcov-version flag is set to something invalid.

  GCOVOptions Options;

  Options.EmitNotes = !CodeGenOpts.CoverageNotesFile.empty();

  Options.EmitData = !CodeGenOpts.CoverageDataFile.empty();

  llvm::copy(CodeGenOpts.CoverageVersion, std::begin(Options.Version));

  Options.NoRedZone = CodeGenOpts.DisableRedZone;

  Options.Filter = CodeGenOpts.ProfileFilterFiles;

  Options.Exclude = CodeGenOpts.ProfileExcludeFiles;

  Options.Atomic = CodeGenOpts.AtomicProfileUpdate;

  return Options;

}

static std::optional<InstrProfOptions>

getInstrProfOptions(const CodeGenOptions &CodeGenOpts,

                    const LangOptions &LangOpts) {

  if (!CodeGenOpts.hasProfileClangInstr())

    return std::nullopt;

  InstrProfOptions Options;

  Options.NoRedZone = CodeGenOpts.DisableRedZone;

  Options.InstrProfileOutput = CodeGenOpts.InstrProfileOutput;

  Options.Atomic = CodeGenOpts.AtomicProfileUpdate;

  return Options;

}

static void setCommandLineOpts(const CodeGenOptions &CodeGenOpts) {

  SmallVector<const char *, 16> BackendArgs;

  BackendArgs.push_back("clang"); // Fake program name.

  if (!CodeGenOpts.DebugPass.empty()) {

    BackendArgs.push_back("-debug-pass");

    BackendArgs.push_back(CodeGenOpts.DebugPass.c_str());

  }

  if (!CodeGenOpts.LimitFloatPrecision.empty()) {

    BackendArgs.push_back("-limit-float-precision");

    BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());

  }

  // Check for the default "clang" invocation that won't set any cl::opt values.

  // Skip trying to parse the command line invocation to avoid the issues

  // described below.

  if (BackendArgs.size() == 1)

    return;

  BackendArgs.push_back(nullptr);

  // FIXME: The command line parser below is not thread-safe and shares a global

  // state, so this call might crash or overwrite the options of another Clang

  // instance in the same process.

  llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,

                                    BackendArgs.data());

}

void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {

  // Create the TargetMachine for generating code.

  std::string Error;

  std::string Triple = TheModule->getTargetTriple();

  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);

  if (!TheTarget) {

    if (MustCreateTM)

      Diags.Report(diag::err_fe_unable_to_create_target) << Error;

    return;

  }

  std::optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);

  std::string FeaturesStr =

      llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");

  llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;

  std::optional<CodeGenOptLevel> OptLevelOrNone =

      CodeGenOpt::getLevel(CodeGenOpts.OptimizationLevel);

  assert(OptLevelOrNone && "Invalid optimization level!");

  CodeGenOptLevel OptLevel = *OptLevelOrNone;

  llvm::TargetOptions Options;

  if (!initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts,

                         HSOpts))

    return;

  TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,

                                          Options, RM, CM, OptLevel));

  TM->setLargeDataThreshold(CodeGenOpts.LargeDataThreshold);

}

bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,

                                       BackendAction Action,

                                       raw_pwrite_stream &OS,

                                       raw_pwrite_stream *DwoOS) {

  // Add LibraryInfo.

  std::unique_ptr<TargetLibraryInfoImpl> TLII(

      llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));

  CodeGenPasses.add(new TargetLibraryInfoWrapperPass(*TLII));

  // Normal mode, emit a .s or .o file by running the code generator. Note,

  // this also adds codegenerator level optimization passes.

  CodeGenFileType CGFT = getCodeGenFileType(Action);

  // Add ObjC ARC final-cleanup optimizations. This is done as part of the

  // "codegen" passes so that it isn't run multiple times when there is

  // inlining happening.

  if (CodeGenOpts.OptimizationLevel > 0)

    CodeGenPasses.add(createObjCARCContractPass());

  if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,

                              /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {

    Diags.Report(diag::err_fe_unable_to_interface_with_target);

    return false;

  }

  return true;

}

static OptimizationLevel mapToLevel(const CodeGenOptions &Opts) {

  switch (Opts.OptimizationLevel) {

  default:

    llvm_unreachable("Invalid optimization level!");

  case 0:

    return OptimizationLevel::O0;

  case 1:

    return OptimizationLevel::O1;

  case 2:

    switch (Opts.OptimizeSize) {

    default:

      llvm_unreachable("Invalid optimization level for size!");

    case 0:

      return OptimizationLevel::O2;

    case 1:

      return OptimizationLevel::Os;

    case 2:

      return OptimizationLevel::Oz;

    }

  case 3:

    return OptimizationLevel::O3;

  }

}

static void addKCFIPass(const Triple &TargetTriple, const LangOptions &LangOpts,

                        PassBuilder &PB) {

  // If the back-end supports KCFI operand bundle lowering, skip KCFIPass.

  if (TargetTriple.getArch() == llvm::Triple::x86_64 ||

      TargetTriple.isAArch64(64) || TargetTriple.isRISCV())

    return;

  // Ensure we lower KCFI operand bundles with -O0.

  PB.registerOptimizerLastEPCallback(

      [&](ModulePassManager &MPM, OptimizationLevel Level) {

        if (Level == OptimizationLevel::O0 &&

            LangOpts.Sanitize.has(SanitizerKind::KCFI))

          MPM.addPass(createModuleToFunctionPassAdaptor(KCFIPass()));

      });

  // When optimizations are requested, run KCIFPass after InstCombine to

  // avoid unnecessary checks.

  PB.registerPeepholeEPCallback(

      [&](FunctionPassManager &FPM, OptimizationLevel Level) {

        if (Level != OptimizationLevel::O0 &&

            LangOpts.Sanitize.has(SanitizerKind::KCFI))

          FPM.addPass(KCFIPass());

      });

}

static void addSanitizers(const Triple &TargetTriple,

                          const CodeGenOptions &CodeGenOpts,

                          const LangOptions &LangOpts, PassBuilder &PB) {

  auto SanitizersCallback = [&](ModulePassManager &MPM,

                                OptimizationLevel Level) {

    if (CodeGenOpts.hasSanitizeCoverage()) {

      auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);

      MPM.addPass(SanitizerCoveragePass(

          SancovOpts, CodeGenOpts.SanitizeCoverageAllowlistFiles,

          CodeGenOpts.SanitizeCoverageIgnorelistFiles));

    }

    if (CodeGenOpts.hasSanitizeBinaryMetadata()) {

      MPM.addPass(SanitizerBinaryMetadataPass(

          getSanitizerBinaryMetadataOptions(CodeGenOpts),

          CodeGenOpts.SanitizeMetadataIgnorelistFiles));

    }

    auto MSanPass = [&](SanitizerMask Mask, bool CompileKernel) {

      if (LangOpts.Sanitize.has(Mask)) {

        int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;

        bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);

        MemorySanitizerOptions options(TrackOrigins, Recover, CompileKernel,

                                       CodeGenOpts.SanitizeMemoryParamRetval);

        MPM.addPass(MemorySanitizerPass(options));

        if (Level != OptimizationLevel::O0) {

          // MemorySanitizer inserts complex instrumentation that mostly follows

          // the logic of the original code, but operates on "shadow" values. It

          // can benefit from re-running some general purpose optimization

          // passes.

          MPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());

          FunctionPassManager FPM;

          FPM.addPass(EarlyCSEPass(true /* Enable mem-ssa. */));

          FPM.addPass(InstCombinePass());

          FPM.addPass(JumpThreadingPass());

          FPM.addPass(GVNPass());

          FPM.addPass(InstCombinePass());

          MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));

        }

      }

    };

    MSanPass(SanitizerKind::Memory, false);

    MSanPass(SanitizerKind::KernelMemory, true);

    if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {

      MPM.addPass(ModuleThreadSanitizerPass());

      MPM.addPass(createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));

    }

    auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {

      if (LangOpts.Sanitize.has(Mask)) {

        bool UseGlobalGC = asanUseGlobalsGC(TargetTriple, CodeGenOpts);

        bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;

        llvm::AsanDtorKind DestructorKind =

            CodeGenOpts.getSanitizeAddressDtor();

        AddressSanitizerOptions Opts;

        Opts.CompileKernel = CompileKernel;

        Opts.Recover = CodeGenOpts.SanitizeRecover.has(Mask);

        Opts.UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;

        Opts.UseAfterReturn = CodeGenOpts.getSanitizeAddressUseAfterReturn();

        MPM.addPass(AddressSanitizerPass(Opts, UseGlobalGC, UseOdrIndicator,

                                         DestructorKind));

      }

    };

    ASanPass(SanitizerKind::Address, false);

    ASanPass(SanitizerKind::KernelAddress, true);

    auto HWASanPass = [&](SanitizerMask Mask, bool CompileKernel) {

      if (LangOpts.Sanitize.has(Mask)) {

        bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);

        MPM.addPass(HWAddressSanitizerPass(

            {CompileKernel, Recover,

             /*DisableOptimization=*/CodeGenOpts.OptimizationLevel == 0}));

      }

    };

    HWASanPass(SanitizerKind::HWAddress, false);

    HWASanPass(SanitizerKind::KernelHWAddress, true);

    if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {

      MPM.addPass(DataFlowSanitizerPass(LangOpts.NoSanitizeFiles));

    }

  };

  if (ClSanitizeOnOptimizerEarlyEP) {

    PB.registerOptimizerEarlyEPCallback(

        [SanitizersCallback](ModulePassManager &MPM, OptimizationLevel Level) {

          ModulePassManager NewMPM;

          SanitizersCallback(NewMPM, Level);

          if (!NewMPM.isEmpty()) {

            // Sanitizers can abandon<GlobalsAA>.

            NewMPM.addPass(RequireAnalysisPass<GlobalsAA, llvm::Module>());

            MPM.addPass(std::move(NewMPM));

          }

        });

  } else {

    // LastEP does not need GlobalsAA.

    PB.registerOptimizerLastEPCallback(SanitizersCallback);

  }

}

void EmitAssemblyHelper::RunOptimizationPipeline(

    BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,

    std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS, BackendConsumer *BC) {

  std::optional<PGOOptions> PGOOpt;

  if (CodeGenOpts.hasProfileIRInstr())

    // -fprofile-generate.

    PGOOpt = PGOOptions(

        CodeGenOpts.InstrProfileOutput.empty() ? getDefaultProfileGenName()

                                               : CodeGenOpts.InstrProfileOutput,

        "", "", CodeGenOpts.MemoryProfileUsePath, nullptr, PGOOptions::IRInstr,

        PGOOptions::NoCSAction, CodeGenOpts.DebugInfoForProfiling,

        /*PseudoProbeForProfiling=*/false, CodeGenOpts.AtomicProfileUpdate);

  else if (CodeGenOpts.hasProfileIRUse()) {

    // -fprofile-use.

    auto CSAction = CodeGenOpts.hasProfileCSIRUse() ? PGOOptions::CSIRUse

                                                    : PGOOptions::NoCSAction;

    PGOOpt = PGOOptions(

        CodeGenOpts.ProfileInstrumentUsePath, "",

        CodeGenOpts.ProfileRemappingFile, CodeGenOpts.MemoryProfileUsePath, VFS,

        PGOOptions::IRUse, CSAction, CodeGenOpts.DebugInfoForProfiling);

  } else if (!CodeGenOpts.SampleProfileFile.empty())

    // -fprofile-sample-use

    PGOOpt = PGOOptions(

        CodeGenOpts.SampleProfileFile, "", CodeGenOpts.ProfileRemappingFile,

        CodeGenOpts.MemoryProfileUsePath, VFS, PGOOptions::SampleUse,

        PGOOptions::NoCSAction, CodeGenOpts.DebugInfoForProfiling,

        CodeGenOpts.PseudoProbeForProfiling);

  else if (!CodeGenOpts.MemoryProfileUsePath.empty())

    // -fmemory-profile-use (without any of the above options)

    PGOOpt = PGOOptions("", "", "", CodeGenOpts.MemoryProfileUsePath, VFS,

                        PGOOptions::NoAction, PGOOptions::NoCSAction,

                        CodeGenOpts.DebugInfoForProfiling);

  else if (CodeGenOpts.PseudoProbeForProfiling)

    // -fpseudo-probe-for-profiling

    PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,

                        PGOOptions::NoAction, PGOOptions::NoCSAction,

                        CodeGenOpts.DebugInfoForProfiling, true);

  else if (CodeGenOpts.DebugInfoForProfiling)

    // -fdebug-info-for-profiling

    PGOOpt = PGOOptions("", "", "", /*MemoryProfile=*/"", nullptr,

                        PGOOptions::NoAction, PGOOptions::NoCSAction, true);

  // Check to see if we want to generate a CS profile.

  if (CodeGenOpts.hasProfileCSIRInstr()) {

    assert(!CodeGenOpts.hasProfileCSIRUse() &&

           "Cannot have both CSProfileUse pass and CSProfileGen pass at "

           "the same time");

    if (PGOOpt) {

      assert(PGOOpt->Action != PGOOptions::IRInstr &&

             PGOOpt->Action != PGOOptions::SampleUse &&

             "Cannot run CSProfileGen pass with ProfileGen or SampleUse "

             " pass");

      PGOOpt->CSProfileGenFile = CodeGenOpts.InstrProfileOutput.empty()

                                     ? getDefaultProfileGenName()

                                     : CodeGenOpts.InstrProfileOutput;

      PGOOpt->CSAction = PGOOptions::CSIRInstr;

    } else

      PGOOpt =

          PGOOptions("",

                     CodeGenOpts.InstrProfileOutput.empty()

                         ? getDefaultProfileGenName()

                         : CodeGenOpts.InstrProfileOutput,

                     "", /*MemoryProfile=*/"", nullptr, PGOOptions::NoAction,

                     PGOOptions::CSIRInstr, CodeGenOpts.DebugInfoForProfiling);

  }

  if (TM)

    TM->setPGOOption(PGOOpt);

  PipelineTuningOptions PTO;

  PTO.LoopUnrolling = CodeGenOpts.UnrollLoops;

  // For historical reasons, loop interleaving is set to mirror setting for loop

  // unrolling.

  PTO.LoopInterleaving = CodeGenOpts.UnrollLoops;

  PTO.LoopVectorization = CodeGenOpts.VectorizeLoop;

  PTO.SLPVectorization = CodeGenOpts.VectorizeSLP;

  PTO.MergeFunctions = CodeGenOpts.MergeFunctions;

  // Only enable CGProfilePass when using integrated assembler, since

  // non-integrated assemblers don't recognize .cgprofile section.

  PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;

  PTO.UnifiedLTO = CodeGenOpts.UnifiedLTO;

  LoopAnalysisManager LAM;

  FunctionAnalysisManager FAM;

  CGSCCAnalysisManager CGAM;

  ModuleAnalysisManager MAM;

  bool DebugPassStructure = CodeGenOpts.DebugPass == "Structure";

  PassInstrumentationCallbacks PIC;

  PrintPassOptions PrintPassOpts;

  PrintPassOpts.Indent = DebugPassStructure;

  PrintPassOpts.SkipAnalyses = DebugPassStructure;

  StandardInstrumentations SI(

      TheModule->getContext(),

      (CodeGenOpts.DebugPassManager || DebugPassStructure),

      CodeGenOpts.VerifyEach, PrintPassOpts);

  SI.registerCallbacks(PIC, &MAM);

  PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);

  // Handle the assignment tracking feature options.

  switch (CodeGenOpts.getAssignmentTrackingMode()) {

  case CodeGenOptions::AssignmentTrackingOpts::Forced:

    PB.registerPipelineStartEPCallback(

        [&](ModulePassManager &MPM, OptimizationLevel Level) {

          MPM.addPass(AssignmentTrackingPass());

        });

    break;

  case CodeGenOptions::AssignmentTrackingOpts::Enabled:

    // Disable assignment tracking in LTO builds for now as the performance

    // cost is too high. Disable for LLDB tuning due to llvm.org/PR43126.

    if (!CodeGenOpts.PrepareForThinLTO && !CodeGenOpts.PrepareForLTO &&

        CodeGenOpts.getDebuggerTuning() != llvm::DebuggerKind::LLDB) {

      PB.registerPipelineStartEPCallback(

          [&](ModulePassManager &MPM, OptimizationLevel Level) {

            // Only use assignment tracking if optimisations are enabled.

            if (Level != OptimizationLevel::O0)

              MPM.addPass(AssignmentTrackingPass());

          });

    }

    break;

  case CodeGenOptions::AssignmentTrackingOpts::Disabled:

    break;

  }

  // Enable verify-debuginfo-preserve-each for new PM.

  DebugifyEachInstrumentation Debugify;

  DebugInfoPerPass DebugInfoBeforePass;

  if (CodeGenOpts.EnableDIPreservationVerify) {

    Debugify.setDebugifyMode(DebugifyMode::OriginalDebugInfo);

    Debugify.setDebugInfoBeforePass(DebugInfoBeforePass);

    if (!CodeGenOpts.DIBugsReportFilePath.empty())

      Debugify.setOrigDIVerifyBugsReportFilePath(

          CodeGenOpts.DIBugsReportFilePath);

    Debugify.registerCallbacks(PIC, MAM);

  }

  // Attempt to load pass plugins and register their callbacks with PB.

  for (auto &PluginFN : CodeGenOpts.PassPlugins) {

    auto PassPlugin = PassPlugin::Load(PluginFN);

    if (PassPlugin) {

      PassPlugin->registerPassBuilderCallbacks(PB);

    } else {

      Diags.Report(diag::err_fe_unable_to_load_plugin)

          << PluginFN << toString(PassPlugin.takeError());

    }

  }

  for (const auto &PassCallback : CodeGenOpts.PassBuilderCallbacks)

    PassCallback(PB);

#define HANDLE_EXTENSION(Ext)                                                  \

  get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);

#include "llvm/Support/Extension.def"

  // Register the target library analysis directly and give it a customized

  // preset TLI.

  std::unique_ptr<TargetLibraryInfoImpl> TLII(

      llvm::driver::createTLII(TargetTriple, CodeGenOpts.getVecLib()));

  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });

  // Register all the basic analyses with the managers.

  PB.registerModuleAnalyses(MAM);

  PB.registerCGSCCAnalyses(CGAM);

  PB.registerFunctionAnalyses(FAM);

  PB.registerLoopAnalyses(LAM);

  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);

  ModulePassManager MPM;

  // Add a verifier pass, before any other passes, to catch CodeGen issues.

  if (CodeGenOpts.VerifyModule)

    MPM.addPass(VerifierPass());

  if (!CodeGenOpts.DisableLLVMPasses) {

    // Map our optimization levels into one of the distinct levels used to

    // configure the pipeline.

    OptimizationLevel Level = mapToLevel(CodeGenOpts);

    const bool PrepareForThinLTO = CodeGenOpts.PrepareForThinLTO;