//===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===//

//

// 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/Driver/Driver.h"

#include "ToolChains/AIX.h"

#include "ToolChains/AMDGPU.h"

#include "ToolChains/AMDGPUOpenMP.h"

#include "ToolChains/AVR.h"

#include "ToolChains/Arch/RISCV.h"

#include "ToolChains/BareMetal.h"

#include "ToolChains/CSKYToolChain.h"

#include "ToolChains/Clang.h"

#include "ToolChains/CrossWindows.h"

#include "ToolChains/Cuda.h"

#include "ToolChains/Darwin.h"

#include "ToolChains/DragonFly.h"

#include "ToolChains/FreeBSD.h"

#include "ToolChains/Fuchsia.h"

#include "ToolChains/Gnu.h"

#include "ToolChains/HIPAMD.h"

#include "ToolChains/HIPSPV.h"

#include "ToolChains/HLSL.h"

#include "ToolChains/Haiku.h"

#include "ToolChains/Hexagon.h"

#include "ToolChains/Hurd.h"

#include "ToolChains/Lanai.h"

#include "ToolChains/Linux.h"

#include "ToolChains/MSP430.h"

#include "ToolChains/MSVC.h"

#include "ToolChains/MinGW.h"

#include "ToolChains/MipsLinux.h"

#include "ToolChains/NaCl.h"

#include "ToolChains/NetBSD.h"

#include "ToolChains/OHOS.h"

#include "ToolChains/OpenBSD.h"

#include "ToolChains/PPCFreeBSD.h"

#include "ToolChains/PPCLinux.h"

#include "ToolChains/PS4CPU.h"

#include "ToolChains/RISCVToolchain.h"

#include "ToolChains/SPIRV.h"

#include "ToolChains/Solaris.h"

#include "ToolChains/TCE.h"

#include "ToolChains/VEToolchain.h"

#include "ToolChains/WebAssembly.h"

#include "ToolChains/XCore.h"

#include "ToolChains/ZOS.h"

#include "clang/Basic/TargetID.h"

#include "clang/Basic/Version.h"

#include "clang/Config/config.h"

#include "clang/Driver/Action.h"

#include "clang/Driver/Compilation.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/InputInfo.h"

#include "clang/Driver/Job.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/Phases.h"

#include "clang/Driver/SanitizerArgs.h"

#include "clang/Driver/Tool.h"

#include "clang/Driver/ToolChain.h"

#include "clang/Driver/Types.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/StringSet.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Config/llvm-config.h"

#include "llvm/MC/TargetRegistry.h"

#include "llvm/Option/Arg.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Option/OptSpecifier.h"

#include "llvm/Option/OptTable.h"

#include "llvm/Option/Option.h"

#include "llvm/Support/CommandLine.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/ExitCodes.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/FormatVariadic.h"

#include "llvm/Support/MD5.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/PrettyStackTrace.h"

#include "llvm/Support/Process.h"

#include "llvm/Support/Program.h"

#include "llvm/Support/StringSaver.h"

#include "llvm/Support/VirtualFileSystem.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/TargetParser/Host.h"

#include <cstdlib> // ::getenv

#include <map>

#include <memory>

#include <optional>

#include <set>

#include <utility>

#if LLVM_ON_UNIX

#include <unistd.h> // getpid

#endif

using namespace clang::driver;

using namespace clang;

using namespace llvm::opt;

static std::optional<llvm::Triple> getOffloadTargetTriple(const Driver &D,

                                                          const ArgList &Args) {

  auto OffloadTargets = Args.getAllArgValues(options::OPT_offload_EQ);

  // Offload compilation flow does not support multiple targets for now. We

  // need the HIPActionBuilder (and possibly the CudaActionBuilder{,Base}too)

  // to support multiple tool chains first.

  switch (OffloadTargets.size()) {

  default:

    D.Diag(diag::err_drv_only_one_offload_target_supported);

    return std::nullopt;

  case 0:

    D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << "";

    return std::nullopt;

  case 1:

    break;

  }

  return llvm::Triple(OffloadTargets[0]);

}

static std::optional<llvm::Triple>

getNVIDIAOffloadTargetTriple(const Driver &D, const ArgList &Args,

                             const llvm::Triple &HostTriple) {

  if (!Args.hasArg(options::OPT_offload_EQ)) {

    return llvm::Triple(HostTriple.isArch64Bit() ? 
"nvptx64-nvidia-cuda"78

                                                 : 
"nvptx-nvidia-cuda"8
);

  }

  auto TT = getOffloadTargetTriple(D, Args);

  if (TT && (TT->getArch() == llvm::Triple::spirv32 ||

             
TT->getArch() == llvm::Triple::spirv648
)) {

    if (Args.hasArg(options::OPT_emit_llvm))

      return TT;

    D.Diag(diag::err_drv_cuda_offload_only_emit_bc);

    return std::nullopt;

  }

  D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();

  return std::nullopt;

}

static std::optional<llvm::Triple>

getHIPOffloadTargetTriple(const Driver &D, const ArgList &Args) {

  if (!Args.hasArg(options::OPT_offload_EQ)) {

    return llvm::Triple("amdgcn-amd-amdhsa"); // Default HIP triple.

  }

  auto TT = getOffloadTargetTriple(D, Args);

  if (!TT)

    return std::nullopt;

  if (TT->getArch() == llvm::Triple::amdgcn &&

      
TT->getVendor() == llvm::Triple::AMD2
 &&

      
TT->getOS() == llvm::Triple::AMDHSA2
)

    return TT;

  if (TT->getArch() == llvm::Triple::spirv64)

    return TT;

  D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();

  return std::nullopt;

}

// static

std::string Driver::GetResourcesPath(StringRef BinaryPath,

                                     StringRef CustomResourceDir) {

  // Since the resource directory is embedded in the module hash, it's important

  // that all places that need it call this function, so that they get the

  // exact same string ("a/../b/" and "b/" get different hashes, for example).

  // Dir is bin/ or lib/, depending on where BinaryPath is.

  std::string Dir = std::string(llvm::sys::path::parent_path(BinaryPath));

  SmallString<128> P(Dir);

  if (CustomResourceDir != "") {

    llvm::sys::path::append(P, CustomResourceDir);

  } else {

    // On Windows, libclang.dll is in bin/.

    // On non-Windows, libclang.so/.dylib is in lib/.

    // With a static-library build of libclang, LibClangPath will contain the

    // path of the embedding binary, which for LLVM binaries will be in bin/.

    // ../lib gets us to lib/ in both cases.

    P = llvm::sys::path::parent_path(Dir);

    // This search path is also created in the COFF driver of lld, so any

    // changes here also needs to happen in lld/COFF/Driver.cpp

    llvm::sys::path::append(P, CLANG_INSTALL_LIBDIR_BASENAME, "clang",

                            CLANG_VERSION_MAJOR_STRING);

  }

  return std::string(P.str());

}

Driver::Driver(StringRef ClangExecutable, StringRef TargetTriple,

               DiagnosticsEngine &Diags, std::string Title,

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

    : Diags(Diags), VFS(std::move(VFS)), Mode(GCCMode),

      SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),

      Offload(OffloadHostDevice), CXX20HeaderType(HeaderMode_None),

      ModulesModeCXX20(false), LTOMode(LTOK_None),

      ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT),

      DriverTitle(Title), CCCPrintBindings(false), CCPrintOptions(false),

      CCLogDiagnostics(false), CCGenDiagnostics(false),

      CCPrintProcessStats(false), CCPrintInternalStats(false),

      TargetTriple(TargetTriple), Saver(Alloc), PrependArg(nullptr),

      CheckInputsExist(true), ProbePrecompiled(true),

      SuppressMissingInputWarning(false) {

  // Provide a sane fallback if no VFS is specified.

  if (!this->VFS)

    this->VFS = llvm::vfs::getRealFileSystem();

  Name = std::string(llvm::sys::path::filename(ClangExecutable));

  Dir = std::string(llvm::sys::path::parent_path(ClangExecutable));

  InstalledDir = Dir; // Provide a sensible default installed dir.

  if ((!SysRoot.empty()) && 
llvm::sys::path::is_relative(SysRoot)0
) {

    // Prepend InstalledDir if SysRoot is relative

    SmallString<128> P(InstalledDir);

    llvm::sys::path::append(P, SysRoot);

    SysRoot = std::string(P);

  }

#if defined(CLANG_CONFIG_FILE_SYSTEM_DIR)

  SystemConfigDir = CLANG_CONFIG_FILE_SYSTEM_DIR;

#endif

#if defined(CLANG_CONFIG_FILE_USER_DIR)

  {

    SmallString<128> P;

    llvm::sys::fs::expand_tilde(CLANG_CONFIG_FILE_USER_DIR, P);

    UserConfigDir = static_cast<std::string>(P);

  }

#endif

  // Compute the path to the resource directory.

  ResourceDir = GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);

}

void Driver::setDriverMode(StringRef Value) {

  static StringRef OptName =

      getOpts().getOption(options::OPT_driver_mode).getPrefixedName();

  if (auto M = llvm::StringSwitch<std::optional<DriverMode>>(Value)

                   .Case("gcc", GCCMode)

                   .Case("g++", GXXMode)

                   .Case("cpp", CPPMode)

                   .Case("cl", CLMode)

                   .Case("flang", FlangMode)

                   .Case("dxc", DXCMode)

                   .Default(std::nullopt))

    Mode = *M;

  else

    Diag(diag::err_drv_unsupported_option_argument) << OptName << Value;

}

InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings,

                                     bool UseDriverMode, bool &ContainsError) {

  llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");

  ContainsError = false;

  llvm::opt::Visibility VisibilityMask = getOptionVisibilityMask(UseDriverMode);

  unsigned MissingArgIndex, MissingArgCount;

  InputArgList Args = getOpts().ParseArgs(ArgStrings, MissingArgIndex,

                                          MissingArgCount, VisibilityMask);

  // Check for missing argument error.

  if (MissingArgCount) {

    Diag(diag::err_drv_missing_argument)

        << Args.getArgString(MissingArgIndex) << MissingArgCount;

    ContainsError |=

        Diags.getDiagnosticLevel(diag::err_drv_missing_argument,

                                 SourceLocation()) > DiagnosticsEngine::Warning;

  }

  // Check for unsupported options.

  for (const Arg *A : Args) {

    if (A->getOption().hasFlag(options::Unsupported)) {

      Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);

      ContainsError |= Diags.getDiagnosticLevel(diag::err_drv_unsupported_opt,

                                                SourceLocation()) >

                       DiagnosticsEngine::Warning;

      continue;

    }

    // Warn about -mcpu= without an argument.

    if (A->getOption().matches(options::OPT_mcpu_EQ) && 
A->containsValue("")1.49k
) {

      Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);

      ContainsError |= Diags.getDiagnosticLevel(

                           diag::warn_drv_empty_joined_argument,

                           SourceLocation()) > DiagnosticsEngine::Warning;

    }

  }

  for (const Arg *A : Args.filtered(options::OPT_UNKNOWN)) {

    unsigned DiagID;

    auto ArgString = A->getAsString(Args);

    std::string Nearest;

    if (getOpts().findNearest(ArgString, Nearest, VisibilityMask) > 1) {

      if (!IsCLMode() &&

          getOpts().findExact(ArgString, Nearest,

                              llvm::opt::Visibility(options::CC1Option))) {

        DiagID = diag::err_drv_unknown_argument_with_suggestion;

        Diags.Report(DiagID) << ArgString << "-Xclang " + Nearest;

      } else {

        DiagID = IsCLMode() ? 
diag::warn_drv_unknown_argument_clang_cl23

                            : 
diag::err_drv_unknown_argument37
;

        Diags.Report(DiagID) << ArgString;

      }

    } else {

      DiagID = IsCLMode()

                   ? 
diag::warn_drv_unknown_argument_clang_cl_with_suggestion2

                   : 
diag::err_drv_unknown_argument_with_suggestion1.23k
;

      Diags.Report(DiagID) << ArgString << Nearest;

    }

    ContainsError |= Diags.getDiagnosticLevel(DiagID, SourceLocation()) >

                     DiagnosticsEngine::Warning;

  }

  for (const Arg *A : Args.filtered(options::OPT_o)) {

    if (ArgStrings[A->getIndex()] == A->getSpelling())

      continue;

    // Warn on joined arguments that are similar to a long argument.

    std::string ArgString = ArgStrings[A->getIndex()];

    std::string Nearest;

    if (getOpts().findExact("-" + ArgString, Nearest, VisibilityMask))

      Diags.Report(diag::warn_drv_potentially_misspelled_joined_argument)

          << A->getAsString(Args) << Nearest;

  }

  return Args;

}

// Determine which compilation mode we are in. We look for options which

// affect the phase, starting with the earliest phases, and record which

// option we used to determine the final phase.

phases::ID Driver::getFinalPhase(const DerivedArgList &DAL,

                                 Arg **FinalPhaseArg) const {

  Arg *PhaseArg = nullptr;

  phases::ID FinalPhase;

  // -{E,EP,P,M,MM} only run the preprocessor.

  if (CCCIsCPP() || 
(PhaseArg = DAL.getLastArg(options::OPT_E))150k
 ||

      
(PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP))145k
 ||

      
(PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))145k
 ||

      
(PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))145k
 ||

      
CCGenDiagnostics145k
) {

    FinalPhase = phases::Preprocess;

    // --precompile only runs up to precompilation.

    // Options that cause the output of C++20 compiled module interfaces or

    // header units have the same effect.

  } else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile)) ||

             
(PhaseArg = DAL.getLastArg(options::OPT_extract_api))144k
 ||

             (PhaseArg = DAL.getLastArg(options::OPT_fmodule_header,

                                        options::OPT_fmodule_header_EQ))) {

    FinalPhase = phases::Precompile;

    // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.

  } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||

             
(PhaseArg = DAL.getLastArg(options::OPT_print_supported_cpus))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT_module_file_info))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT_verify_pch))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT__migrate))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT__analyze))49.0k
 ||

             
(PhaseArg = DAL.getLastArg(options::OPT_emit_ast))48.8k
) {

    FinalPhase = phases::Compile;

  // -S only runs up to the backend.

  } else 
if (48.8k
(PhaseArg = DAL.getLastArg(options::OPT_S))48.8k
) {

    FinalPhase = phases::Backend;

  // -c compilation only runs up to the assembler.

  } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {

    FinalPhase = phases::Assemble;

  } else 
if (21.2k
(PhaseArg = DAL.getLastArg(options::OPT_emit_interface_stubs))21.2k
) {

    FinalPhase = phases::IfsMerge;

  // Otherwise do everything.

  } else

    FinalPhase = phases::Link;

  if (FinalPhaseArg)

    *FinalPhaseArg = PhaseArg;

  return FinalPhase;

}

static Arg *MakeInputArg(DerivedArgList &Args, const OptTable &Opts,

                         StringRef Value, bool Claim = true) {

  Arg *A = new Arg(Opts.getOption(options::OPT_INPUT), Value,

                   Args.getBaseArgs().MakeIndex(Value), Value.data());

  Args.AddSynthesizedArg(A);

  if (Claim)

    A->claim();

  return A;

}

DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {

  const llvm::opt::OptTable &Opts = getOpts();

  DerivedArgList *DAL = new DerivedArgList(Args);

  bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);

  bool HasNostdlibxx = Args.hasArg(options::OPT_nostdlibxx);

  bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);

  bool IgnoreUnused = false;

  for (Arg *A : Args) {

    if (IgnoreUnused)

      A->claim();

    if (A->getOption().matches(options::OPT_start_no_unused_arguments)) {

      IgnoreUnused = true;

      continue;

    }

    if (A->getOption().matches(options::OPT_end_no_unused_arguments)) {

      IgnoreUnused = false;

      continue;

    }

    // Unfortunately, we have to parse some forwarding options (-Xassembler,

    // -Xlinker, -Xpreprocessor) because we either integrate their functionality

    // (assembler and preprocessor), or bypass a previous driver ('collect2').

    // Rewrite linker options, to replace --no-demangle with a custom internal

    // option.

    if ((A->getOption().matches(options::OPT_Wl_COMMA) ||

         
A->getOption().matches(options::OPT_Xlinker)727k
) &&

        
A->containsValue("--no-demangle")2.58k
) {

      // Add the rewritten no-demangle argument.

      DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_Xlinker__no_demangle));

      // Add the remaining values as Xlinker arguments.

      for (StringRef Val : A->getValues())

        if (Val != "--no-demangle")

          DAL->AddSeparateArg(A, Opts.getOption(options::OPT_Xlinker), Val);

      continue;

    }

    // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by

    // some build systems. We don't try to be complete here because we don't

    // care to encourage this usage model.

    if (A->getOption().matches(options::OPT_Wp_COMMA) &&

        
(3
A->getValue(0) == StringRef("-MD")3
 ||

         
A->getValue(0) == StringRef("-MMD")2
)) {

      // Rewrite to -MD/-MMD along with -MF.

      if (A->getValue(0) == StringRef("-MD"))

        DAL->AddFlagArg(A, Opts.getOption(options::OPT_MD));

      else

        DAL->AddFlagArg(A, Opts.getOption(options::OPT_MMD));

      if (A->getNumValues() == 2)

        DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(1));

      continue;

    }

    // Rewrite reserved library names.

    if (A->getOption().matches(options::OPT_l)) {

      StringRef Value = A->getValue();

      // Rewrite unless -nostdlib is present.

      if (!HasNostdlib && 
!HasNodefaultlib3.05k
 && 
!HasNostdlibxx3.05k
 &&

          
Value == "stdc++"3.05k
) {

        DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_stdcxx));

        continue;

      }

      // Rewrite unconditionally.

      if (Value == "cc_kext") {

        DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_cckext));

        continue;

      }

    }

    // Pick up inputs via the -- option.

    if (A->getOption().matches(options::OPT__DASH_DASH)) {

      A->claim();

      for (StringRef Val : A->getValues())

        DAL->append(MakeInputArg(*DAL, Opts, Val, false));

      continue;

    }

    DAL->append(A);

  }

  // DXC mode quits before assembly if an output object file isn't specified.

  if (IsDXCMode() && 
!Args.hasArg(options::OPT_dxc_Fo)63
)

    DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_S));

  // Enforce -static if -miamcu is present.

  if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false))

    DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_static));

// Add a default value of -mlinker-version=, if one was given and the user

// didn't specify one.

#if defined(HOST_LINK_VERSION)

  if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&

      
strlen(51.9k
HOST_LINK_VERSION51.9k
) > 0) {

    DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mlinker_version_EQ),

                      HOST_LINK_VERSION);

    DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();

  }

#endif

  return DAL;

}

/// Compute target triple from args.

///

/// This routine provides the logic to compute a target triple from various

/// args passed to the driver and the default triple string.

static llvm::Triple computeTargetTriple(const Driver &D,

                                        StringRef TargetTriple,

                                        const ArgList &Args,

                                        StringRef DarwinArchName = "") {

  // FIXME: Already done in Compilation *Driver::BuildCompilation

  if (const Arg *A = Args.getLastArg(options::OPT_target))

    TargetTriple = A->getValue();

  llvm::Triple Target(llvm::Triple::normalize(TargetTriple));

  // GNU/Hurd's triples should have been -hurd-gnu*, but were historically made

  // -gnu* only, and we can not change this, so we have to detect that case as

  // being the Hurd OS.

  if (TargetTriple.contains("-unknown-gnu") || 
TargetTriple.contains("-pc-gnu")79.6k
)

    Target.setOSName("hurd");

  // Handle Apple-specific options available here.

  if (Target.isOSBinFormatMachO()) {

    // If an explicit Darwin arch name is given, that trumps all.

    if (!DarwinArchName.empty()) {

      tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName,

                                                   Args);

      return Target;

    }

    // Handle the Darwin '-arch' flag.

    if (Arg *A = Args.getLastArg(options::OPT_arch)) {

      StringRef ArchName = A->getValue();

      tools::darwin::setTripleTypeForMachOArchName(Target, ArchName, Args);

    }

  }

  // Handle pseudo-target flags '-mlittle-endian'/'-EL' and

  // '-mbig-endian'/'-EB'.

  if (Arg *A = Args.getLastArgNoClaim(options::OPT_mlittle_endian,

                                      options::OPT_mbig_endian)) {

    llvm::Triple T = A->getOption().matches(options::OPT_mlittle_endian)

                         ? 
Target.getLittleEndianArchVariant()311

                         : 
Target.getBigEndianArchVariant()290
;

    if (T.getArch() != llvm::Triple::UnknownArch) {

      Target = std::move(T);

      Args.claimAllArgs(options::OPT_mlittle_endian, options::OPT_mbig_endian);

    }

  }

  // Skip further flag support on OSes which don't support '-m32' or '-m64'.

  if (Target.getArch() == llvm::Triple::tce)

    return Target;

  // On AIX, the env OBJECT_MODE may affect the resulting arch variant.

  if (Target.isOSAIX()) {

    if (std::optional<std::string> ObjectModeValue =

            llvm::sys::Process::GetEnv("OBJECT_MODE")) {

      StringRef ObjectMode = *ObjectModeValue;

      llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;

      if (ObjectMode.equals("64")) {

        AT = Target.get64BitArchVariant().getArch();

      } else if (ObjectMode.equals("32")) {

        AT = Target.get32BitArchVariant().getArch();

      } else {

        D.Diag(diag::err_drv_invalid_object_mode) << ObjectMode;

      }

      if (AT != llvm::Triple::UnknownArch && 
AT != Target.getArch()4
)

        Target.setArch(AT);

    }

  }

  // The `-maix[32|64]` flags are only valid for AIX targets.

  if (Arg *A = Args.getLastArgNoClaim(options::OPT_maix32, options::OPT_maix64);

      A && 
!Target.isOSAIX()4
)

    D.Diag(diag::err_drv_unsupported_opt_for_target)

        << A->getAsString(Args) << Target.str();

  // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'.

  Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,

                           options::OPT_m32, options::OPT_m16,

                           options::OPT_maix32, options::OPT_maix64);

  if (A) {

    llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;

    if (A->getOption().matches(options::OPT_m64) ||

        
A->getOption().matches(options::OPT_maix64)177
) {

      AT = Target.get64BitArchVariant().getArch();

      if (Target.getEnvironment() == llvm::Triple::GNUX32)

        Target.setEnvironment(llvm::Triple::GNU);

      else if (Target.getEnvironment() == llvm::Triple::MuslX32)

        Target.setEnvironment(llvm::Triple::Musl);

    } else 
if (175
A->getOption().matches(options::OPT_mx32)175
 &&

               
Target.get64BitArchVariant().getArch() == llvm::Triple::x86_643
) {

      AT = llvm::Triple::x86_64;

      if (Target.getEnvironment() == llvm::Triple::Musl)

        Target.setEnvironment(llvm::Triple::MuslX32);

      else

        Target.setEnvironment(llvm::Triple::GNUX32);

    } else if (A->getOption().matches(options::OPT_m32) ||

               
A->getOption().matches(options::OPT_maix32)3
) {

      AT = Target.get32BitArchVariant().getArch();

      if (Target.getEnvironment() == llvm::Triple::GNUX32)

        Target.setEnvironment(llvm::Triple::GNU);

      else if (Target.getEnvironment() == llvm::Triple::MuslX32)

        Target.setEnvironment(llvm::Triple::Musl);

    } else 
if (1
A->getOption().matches(options::OPT_m16)1
 &&

               Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {

      AT = llvm::Triple::x86;

      Target.setEnvironment(llvm::Triple::CODE16);

    }

    if (AT != llvm::Triple::UnknownArch && AT != Target.getArch()) {

      Target.setArch(AT);

      if (Target.isWindowsGNUEnvironment())

        toolchains::MinGW::fixTripleArch(D, Target, Args);

    }

  }

  // Handle -miamcu flag.

  if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {

    if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)

      D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu"

                                                       << Target.str();

    if (A && 
!A->getOption().matches(options::OPT_m32)2
)

      D.Diag(diag::err_drv_argument_not_allowed_with)

          << "-miamcu" << A->getBaseArg().getAsString(Args);

    Target.setArch(llvm::Triple::x86);

    Target.setArchName("i586");

    Target.setEnvironment(llvm::Triple::UnknownEnvironment);

    Target.setEnvironmentName("");

    Target.setOS(llvm::Triple::ELFIAMCU);

    Target.setVendor(llvm::Triple::UnknownVendor);

    Target.setVendorName("intel");

  }

  // If target is MIPS adjust the target triple

  // accordingly to provided ABI name.

  if (Target.isMIPS()) {

    if ((A = Args.getLastArg(options::OPT_mabi_EQ))) {

      StringRef ABIName = A->getValue();

      if (ABIName == "32") {

        Target = Target.get32BitArchVariant();

        if (Target.getEnvironment() == llvm::Triple::GNUABI64 ||

            
Target.getEnvironment() == llvm::Triple::GNUABIN3211
)

          Target.setEnvironment(llvm::Triple::GNU);

      } else if (ABIName == "n32") {

        Target = Target.get64BitArchVariant();

        if (Target.getEnvironment() == llvm::Triple::GNU ||

            
Target.getEnvironment() == llvm::Triple::GNUABI643
)

          Target.setEnvironment(llvm::Triple::GNUABIN32);

      } else if (ABIName == "64") {

        Target = Target.get64BitArchVariant();

        if (Target.getEnvironment() == llvm::Triple::GNU ||

            
Target.getEnvironment() == llvm::Triple::GNUABIN323
)

          Target.setEnvironment(llvm::Triple::GNUABI64);

      }

    }

  }

  // If target is RISC-V adjust the target triple according to

  // provided architecture name

  if (Target.isRISCV()) {

    if (Args.hasArg(options::OPT_march_EQ) ||

        
Args.hasArg(options::OPT_mcpu_EQ)298
) {

      StringRef ArchName = tools::riscv::getRISCVArch(Args, Target);

      if (ArchName.starts_with_insensitive("rv32"))

        Target.setArch(llvm::Triple::riscv32);

      else if (ArchName.starts_with_insensitive("rv64"))

        Target.setArch(llvm::Triple::riscv64);

    }

  }

  return Target;

}

// Parse the LTO options and record the type of LTO compilation

// based on which -f(no-)?lto(=.*)? or -f(no-)?offload-lto(=.*)?

// option occurs last.

static driver::LTOKind parseLTOMode(Driver &D, const llvm::opt::ArgList &Args,

                                    OptSpecifier OptEq, OptSpecifier OptNeg) {

  if (!Args.hasFlag(OptEq, OptNeg, false))

    return LTOK_None;

  const Arg *A = Args.getLastArg(OptEq);

  StringRef LTOName = A->getValue();

  driver::LTOKind LTOMode = llvm::StringSwitch<LTOKind>(LTOName)

                                .Case("full", LTOK_Full)

                                .Case("thin", LTOK_Thin)

                                .Default(LTOK_Unknown);

  if (LTOMode == LTOK_Unknown) {

    D.Diag(diag::err_drv_unsupported_option_argument)

        << A->getSpelling() << A->getValue();

    return LTOK_None;

  }

  return LTOMode;

}

// Parse the LTO options.

void Driver::setLTOMode(const llvm::opt::ArgList &Args) {

  LTOMode =

      parseLTOMode(*this, Args, options::OPT_flto_EQ, options::OPT_fno_lto);

  OffloadLTOMode = parseLTOMode(*this, Args, options::OPT_foffload_lto_EQ,

                                options::OPT_fno_offload_lto);

  // Try to enable `-foffload-lto=full` if `-fopenmp-target-jit` is on.

  if (Args.hasFlag(options::OPT_fopenmp_target_jit,

                   options::OPT_fno_openmp_target_jit, false)) {

    if (Arg *A = Args.getLastArg(options::OPT_foffload_lto_EQ,

                                 options::OPT_fno_offload_lto))

      if (OffloadLTOMode != LTOK_Full)

        Diag(diag::err_drv_incompatible_options)

            << A->getSpelling() << "-fopenmp-target-jit";

    OffloadLTOMode = LTOK_Full;

  }

}

/// Compute the desired OpenMP runtime from the flags provided.

Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const {

  StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);

  const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);

  if (A)

    RuntimeName = A->getValue();

  auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)

                .Case("libomp", OMPRT_OMP)

                .Case("libgomp", OMPRT_GOMP)

                .Case("libiomp5", OMPRT_IOMP5)

                .Default(OMPRT_Unknown);

  if (RT == OMPRT_Unknown) {

    if (A)

      Diag(diag::err_drv_unsupported_option_argument)

          << A->getSpelling() << A->getValue();

    else

      // FIXME: We could use a nicer diagnostic here.

      Diag(diag::err_drv_unsupported_opt) << "-fopenmp";

  }

  return RT;

}

void Driver::CreateOffloadingDeviceToolChains(Compilation &C,

                                              InputList &Inputs) {

  //

  // CUDA/HIP

  //

  // We need to generate a CUDA/HIP toolchain if any of the inputs has a CUDA

  // or HIP type. However, mixed CUDA/HIP compilation is not supported.

  bool IsCuda =

      llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {

        return types::isCuda(I.first);

      });

  bool IsHIP =

      llvm::any_of(Inputs,

                   [](std::pair<types::ID, const llvm::opt::Arg *> &I) {

                     return types::isHIP(I.first);

                   }) ||

      
C.getInputArgs().hasArg(options::OPT_hip_link)50.1k
;

  if (IsCuda && 
IsHIP98
) {

    Diag(clang::diag::err_drv_mix_cuda_hip);

    return;

  }

  if (IsCuda) {

    const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();

    const llvm::Triple &HostTriple = HostTC->getTriple();

    auto OFK = Action::OFK_Cuda;

    auto CudaTriple =

        getNVIDIAOffloadTargetTriple(*this, C.getInputArgs(), HostTriple);

    if (!CudaTriple)

      return;

    // Use the CUDA and host triples as the key into the ToolChains map,

    // because the device toolchain we create depends on both.

    auto &CudaTC = ToolChains[CudaTriple->str() + "/" + HostTriple.str()];

    if (!CudaTC) {

      CudaTC = std::make_unique<toolchains::CudaToolChain>(

          *this, *CudaTriple, *HostTC, C.getInputArgs());

      // Emit a warning if the detected CUDA version is too new.

      CudaInstallationDetector &CudaInstallation =

          static_cast<toolchains::CudaToolChain &>(*CudaTC).CudaInstallation;

      if (CudaInstallation.isValid())

        CudaInstallation.WarnIfUnsupportedVersion();

    }

    C.addOffloadDeviceToolChain(CudaTC.get(), OFK);

  } else if (IsHIP) {

    if (auto *OMPTargetArg =

            C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {

      Diag(clang::diag::err_drv_unsupported_opt_for_language_mode)

          << OMPTargetArg->getSpelling() << "HIP";

      return;

    }

    const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();

    auto OFK = Action::OFK_HIP;

    auto HIPTriple = getHIPOffloadTargetTriple(*this, C.getInputArgs());

    if (!HIPTriple)

      return;

    auto *HIPTC = &getOffloadingDeviceToolChain(C.getInputArgs(), *HIPTriple,

                                                *HostTC, OFK);

    assert(HIPTC && "Could not create offloading device tool chain.");

    C.addOffloadDeviceToolChain(HIPTC, OFK);

  }

  //

  // OpenMP

  //

  // We need to generate an OpenMP toolchain if the user specified targets with

  // the -fopenmp-targets option or used --offload-arch with OpenMP enabled.

  bool IsOpenMPOffloading =

      C.getInputArgs().hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

                               options::OPT_fno_openmp, false) &&

      
(652
C.getInputArgs().hasArg(options::OPT_fopenmp_targets_EQ)652
 ||

       
C.getInputArgs().hasArg(options::OPT_offload_arch_EQ)644
);

  if (IsOpenMPOffloading) {

    // We expect that -fopenmp-targets is always used in conjunction with the

    // option -fopenmp specifying a valid runtime with offloading support, i.e.

    // libomp or libiomp.

    OpenMPRuntimeKind RuntimeKind = getOpenMPRuntime(C.getInputArgs());

    if (RuntimeKind != OMPRT_OMP && 
RuntimeKind != OMPRT_IOMP50
) {

      Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);

      return;

    }

    llvm::StringMap<llvm::DenseSet<StringRef>> DerivedArchs;

    llvm::StringMap<StringRef> FoundNormalizedTriples;

    std::multiset<StringRef> OpenMPTriples;

    // If the user specified -fopenmp-targets= we create a toolchain for each

    // valid triple. Otherwise, if only --offload-arch= was specified we instead

    // attempt to derive the appropriate toolchains from the arguments.

    if (Arg *OpenMPTargets =

            C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {

      if (OpenMPTargets && !OpenMPTargets->getNumValues()) {

        Diag(clang::diag::warn_drv_empty_joined_argument)

            << OpenMPTargets->getAsString(C.getInputArgs());

        return;

      }

      for (StringRef T : OpenMPTargets->getValues())

        OpenMPTriples.insert(T);

    } else 
if (6
C.getInputArgs().hasArg(options::OPT_offload_arch_EQ)6
 &&

               !IsHIP && 
!IsCuda5
) {

      const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();

      auto AMDTriple = getHIPOffloadTargetTriple(*this, C.getInputArgs());

      auto NVPTXTriple = getNVIDIAOffloadTargetTriple(*this, C.getInputArgs(),

                                                      HostTC->getTriple());

      // Attempt to deduce the offloading triple from the set of architectures.

      // We can only correctly deduce NVPTX / AMDGPU triples currently. We need

      // to temporarily create these toolchains so that we can access tools for

      // inferring architectures.

      llvm::DenseSet<StringRef> Archs;

      if (NVPTXTriple) {

        auto TempTC = std::make_unique<toolchains::CudaToolChain>(

            *this, *NVPTXTriple, *HostTC, C.getInputArgs());

        for (StringRef Arch : getOffloadArchs(

                 C, C.getArgs(), Action::OFK_OpenMP, &*TempTC, true))

          Archs.insert(Arch);

      }

      if (AMDTriple) {

        auto TempTC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(

            *this, *AMDTriple, *HostTC, C.getInputArgs());

        for (StringRef Arch : getOffloadArchs(

                 C, C.getArgs(), Action::OFK_OpenMP, &*TempTC, true))

          Archs.insert(Arch);

      }

      if (!AMDTriple && 
!NVPTXTriple0
) {

        for (StringRef Arch :

             getOffloadArchs(C, C.getArgs(), Action::OFK_OpenMP, nullptr, true))

          Archs.insert(Arch);

      }

      for (StringRef Arch : Archs) {

        if (NVPTXTriple && IsNVIDIAGpuArch(StringToCudaArch(

                               getProcessorFromTargetID(*NVPTXTriple, Arch)))) {

          DerivedArchs[NVPTXTriple->getTriple()].insert(Arch);

        } else if (AMDTriple &&

                   IsAMDGpuArch(StringToCudaArch(

                       getProcessorFromTargetID(*AMDTriple, Arch)))) {

          DerivedArchs[AMDTriple->getTriple()].insert(Arch);

        } else {

          Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch) << Arch;

          return;

        }

      }

      // If the set is empty then we failed to find a native architecture.

      if (Archs.empty()) {

        Diag(clang::diag::err_drv_failed_to_deduce_target_from_arch)

            << "native";

        return;

      }

      for (const auto &TripleAndArchs : DerivedArchs)

        OpenMPTriples.insert(TripleAndArchs.first());

    }

    for (StringRef Val : OpenMPTriples) {

      llvm::Triple TT(ToolChain::getOpenMPTriple(Val));

      std::string NormalizedName = TT.normalize();

      // Make sure we don't have a duplicate triple.

      auto Duplicate = FoundNormalizedTriples.find(NormalizedName);

      if (Duplicate != FoundNormalizedTriples.end()) {

        Diag(clang::diag::warn_drv_omp_offload_target_duplicate)

            << Val << Duplicate->second;

        continue;

      }

      // Store the current triple so that we can check for duplicates in the

      // following iterations.

      FoundNormalizedTriples[NormalizedName] = Val;

      // If the specified target is invalid, emit a diagnostic.

      if (TT.getArch() == llvm::Triple::UnknownArch)

        Diag(clang::diag::err_drv_invalid_omp_target) << Val;

      else {

        const ToolChain *TC;

        // Device toolchains have to be selected differently. They pair host

        // and device in their implementation.

        if (TT.isNVPTX() || TT.isAMDGCN()) {

          const ToolChain *HostTC =

              C.getSingleOffloadToolChain<Action::OFK_Host>();

          assert(HostTC && "Host toolchain should be always defined.");

          auto &DeviceTC =

              ToolChains[TT.str() + "/" + HostTC->getTriple().normalize()];

          if (!DeviceTC) {

            if (TT.isNVPTX())

              DeviceTC = std::make_unique<toolchains::CudaToolChain>(

                  *this, TT, *HostTC, C.getInputArgs());

            else if (TT.isAMDGCN())

              DeviceTC = std::make_unique<toolchains::AMDGPUOpenMPToolChain>(

                  *this, TT, *HostTC, C.getInputArgs());

            else

              assert(DeviceTC && "Device toolchain not defined.");

          }

          TC = DeviceTC.get();

        } else

          TC = &getToolChain(C.getInputArgs(), TT);

        C.addOffloadDeviceToolChain(TC, Action::OFK_OpenMP);

        if (DerivedArchs.contains(TT.getTriple()))

          KnownArchs[TC] = DerivedArchs[TT.getTriple()];

      }

    }

  } else if (C.getInputArgs().hasArg(options::OPT_fopenmp_targets_EQ)) {

    Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);

    return;

  }

  //

  // TODO: Add support for other offloading programming models here.

  //

}

static void appendOneArg(InputArgList &Args, const Arg *Opt,

                         const Arg *BaseArg) {

  // The args for config files or /clang: flags belong to different InputArgList

  // objects than Args. This copies an Arg from one of those other InputArgLists

  // to the ownership of Args.

  unsigned Index = Args.MakeIndex(Opt->getSpelling());

  Arg *Copy = new llvm::opt::Arg(Opt->getOption(), Args.getArgString(Index),

                                 Index, BaseArg);

  Copy->getValues() = Opt->getValues();

  if (Opt->isClaimed())

    Copy->claim();

  Copy->setOwnsValues(Opt->getOwnsValues());

  Opt->setOwnsValues(false);

  Args.append(Copy);

}

bool Driver::readConfigFile(StringRef FileName,

                            llvm::cl::ExpansionContext &ExpCtx) {

  // Try opening the given file.

  auto Status = getVFS().status(FileName);

  if (!Status) {

    Diag(diag::err_drv_cannot_open_config_file)

        << FileName << Status.getError().message();

    return true;

  }

  if (Status->getType() != llvm::sys::fs::file_type::regular_file) {

    Diag(diag::err_drv_cannot_open_config_file)

        << FileName << "not a regular file";

    return true;

  }

  // Try reading the given file.

  SmallVector<const char *, 32> NewCfgArgs;

  if (llvm::Error Err = ExpCtx.readConfigFile(FileName, NewCfgArgs)) {

    Diag(diag::err_drv_cannot_read_config_file)

        << FileName << toString(std::move(Err));

    return true;

  }

  // Read options from config file.

  llvm::SmallString<128> CfgFileName(FileName);

  llvm::sys::path::native(CfgFileName);

  bool ContainErrors;

  std::unique_ptr<InputArgList> NewOptions = std::make_unique<InputArgList>(

      ParseArgStrings(NewCfgArgs, /*UseDriverMode=*/true, ContainErrors));

  if (ContainErrors)

    return true;

  // Claim all arguments that come from a configuration file so that the driver

  // does not warn on any that is unused.

  for (Arg *A : *NewOptions)