//===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===//

//

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

#include "AMDGPU.h"

#include "Arch/AArch64.h"

#include "Arch/ARM.h"

#include "Arch/CSKY.h"

#include "Arch/LoongArch.h"

#include "Arch/M68k.h"

#include "Arch/Mips.h"

#include "Arch/PPC.h"

#include "Arch/RISCV.h"

#include "Arch/Sparc.h"

#include "Arch/SystemZ.h"

#include "Arch/VE.h"

#include "Arch/X86.h"

#include "CommonArgs.h"

#include "Hexagon.h"

#include "MSP430.h"

#include "PS4CPU.h"

#include "clang/Basic/CLWarnings.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/Basic/HeaderInclude.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/MakeSupport.h"

#include "clang/Basic/ObjCRuntime.h"

#include "clang/Basic/Version.h"

#include "clang/Config/config.h"

#include "clang/Driver/Action.h"

#include "clang/Driver/Distro.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/InputInfo.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/SanitizerArgs.h"

#include "clang/Driver/Types.h"

#include "clang/Driver/XRayArgs.h"

#include "llvm/ADT/SmallSet.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/BinaryFormat/Magic.h"

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

#include "llvm/Object/ObjectFile.h"

#include "llvm/Option/ArgList.h"

#include "llvm/Support/CodeGen.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/Compression.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/Process.h"

#include "llvm/Support/RISCVISAInfo.h"

#include "llvm/Support/YAMLParser.h"

#include "llvm/TargetParser/ARMTargetParserCommon.h"

#include "llvm/TargetParser/Host.h"

#include "llvm/TargetParser/LoongArchTargetParser.h"

#include "llvm/TargetParser/RISCVTargetParser.h"

#include <cctype>

using namespace clang::driver;

using namespace clang::driver::tools;

using namespace clang;

using namespace llvm::opt;

static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {

  if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,

                               options::OPT_fminimize_whitespace,

                               options::OPT_fno_minimize_whitespace,

                               options::OPT_fkeep_system_includes,

                               options::OPT_fno_keep_system_includes)) {

    if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&

        !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {

      D.Diag(clang::diag::err_drv_argument_only_allowed_with)

          << A->getBaseArg().getAsString(Args)

          << (D.IsCLMode() ? "/E, /P or /EP" : "-E");

    }

  }

}

static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) {

  // In gcc, only ARM checks this, but it seems reasonable to check universally.

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

    if (const Arg *A =

            Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))

      D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)

                                                      << "-static";

}

// Add backslashes to escape spaces and other backslashes.

// This is used for the space-separated argument list specified with

// the -dwarf-debug-flags option.

static void EscapeSpacesAndBackslashes(const char *Arg,

                                       SmallVectorImpl<char> &Res) {

  for (; *Arg; ++Arg) {

    switch (*Arg) {

    default:

      break;

    case ' ':

    case '\\':

      Res.push_back('\\');

      break;

    }

    Res.push_back(*Arg);

  }

}

/// Apply \a Work on the current tool chain \a RegularToolChain and any other

/// offloading tool chain that is associated with the current action \a JA.

static void

forAllAssociatedToolChains(Compilation &C, const JobAction &JA,

                           const ToolChain &RegularToolChain,

                           llvm::function_ref<void(const ToolChain &)> Work) {

  // Apply Work on the current/regular tool chain.

  Work(RegularToolChain);

  // Apply Work on all the offloading tool chains associated with the current

  // action.

  if (JA.isHostOffloading(Action::OFK_Cuda))

    Work(*C.getSingleOffloadToolChain<Action::OFK_Cuda>());

  else if (JA.isDeviceOffloading(Action::OFK_Cuda))

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

  else if (JA.isHostOffloading(Action::OFK_HIP))

    Work(*C.getSingleOffloadToolChain<Action::OFK_HIP>());

  else if (JA.isDeviceOffloading(Action::OFK_HIP))

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

  if (JA.isHostOffloading(Action::OFK_OpenMP)) {

    auto TCs = C.getOffloadToolChains<Action::OFK_OpenMP>();

    for (auto II = TCs.first, IE = TCs.second; II != IE; ++II)

      Work(*II->second);

  } else if (JA.isDeviceOffloading(Action::OFK_OpenMP))

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

  //

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

  //

}

/// This is a helper function for validating the optional refinement step

/// parameter in reciprocal argument strings. Return false if there is an error

/// parsing the refinement step. Otherwise, return true and set the Position

/// of the refinement step in the input string.

static bool getRefinementStep(StringRef In, const Driver &D,

                              const Arg &A, size_t &Position) {

  const char RefinementStepToken = ':';

  Position = In.find(RefinementStepToken);

  if (Position != StringRef::npos) {

    StringRef Option = A.getOption().getName();

    StringRef RefStep = In.substr(Position + 1);

    // Allow exactly one numeric character for the additional refinement

    // step parameter. This is reasonable for all currently-supported

    // operations and architectures because we would expect that a larger value

    // of refinement steps would cause the estimate "optimization" to

    // under-perform the native operation. Also, if the estimate does not

    // converge quickly, it probably will not ever converge, so further

    // refinement steps will not produce a better answer.

    if (RefStep.size() != 1) {

      D.Diag(diag::err_drv_invalid_value) << Option << RefStep;

      return false;

    }

    char RefStepChar = RefStep[0];

    if (RefStepChar < '0' || RefStepChar > '9') {

      D.Diag(diag::err_drv_invalid_value) << Option << RefStep;

      return false;

    }

  }

  return true;

}

/// The -mrecip flag requires processing of many optional parameters.

static void ParseMRecip(const Driver &D, const ArgList &Args,

                        ArgStringList &OutStrings) {

  StringRef DisabledPrefixIn = "!";

  StringRef DisabledPrefixOut = "!";

  StringRef EnabledPrefixOut = "";

  StringRef Out = "-mrecip=";

  Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ);

  if (!A)

    return;

  unsigned NumOptions = A->getNumValues();

  if (NumOptions == 0) {

    // No option is the same as "all".

    OutStrings.push_back(Args.MakeArgString(Out + "all"));

    return;

  }

  // Pass through "all", "none", or "default" with an optional refinement step.

  if (NumOptions == 1) {

    StringRef Val = A->getValue(0);

    size_t RefStepLoc;

    if (!getRefinementStep(Val, D, *A, RefStepLoc))

      return;

    StringRef ValBase = Val.slice(0, RefStepLoc);

    if (ValBase == "all" || ValBase == "none" || ValBase == "default") {

      OutStrings.push_back(Args.MakeArgString(Out + Val));

      return;

    }

  }

  // Each reciprocal type may be enabled or disabled individually.

  // Check each input value for validity, concatenate them all back together,

  // and pass through.

  llvm::StringMap<bool> OptionStrings;

  OptionStrings.insert(std::make_pair("divd", false));

  OptionStrings.insert(std::make_pair("divf", false));

  OptionStrings.insert(std::make_pair("divh", false));

  OptionStrings.insert(std::make_pair("vec-divd", false));

  OptionStrings.insert(std::make_pair("vec-divf", false));

  OptionStrings.insert(std::make_pair("vec-divh", false));

  OptionStrings.insert(std::make_pair("sqrtd", false));

  OptionStrings.insert(std::make_pair("sqrtf", false));

  OptionStrings.insert(std::make_pair("sqrth", false));

  OptionStrings.insert(std::make_pair("vec-sqrtd", false));

  OptionStrings.insert(std::make_pair("vec-sqrtf", false));

  OptionStrings.insert(std::make_pair("vec-sqrth", false));

  for (unsigned i = 0; i != NumOptions; ++i) {

    StringRef Val = A->getValue(i);

    bool IsDisabled = Val.starts_with(DisabledPrefixIn);

    // Ignore the disablement token for string matching.

    if (IsDisabled)

      Val = Val.substr(1);

    size_t RefStep;

    if (!getRefinementStep(Val, D, *A, RefStep))

      return;

    StringRef ValBase = Val.slice(0, RefStep);

    llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase);

    if (OptionIter == OptionStrings.end()) {

      // Try again specifying float suffix.

      OptionIter = OptionStrings.find(ValBase.str() + 'f');

      if (OptionIter == OptionStrings.end()) {

        // The input name did not match any known option string.

        D.Diag(diag::err_drv_unknown_argument) << Val;

        return;

      }

      // The option was specified without a half or float or double suffix.

      // Make sure that the double or half entry was not already specified.

      // The float entry will be checked below.

      if (OptionStrings[ValBase.str() + 'd'] ||

          OptionStrings[ValBase.str() + 'h']) {

        D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;

        return;

      }

    }

    if (OptionIter->second == true) {

      // Duplicate option specified.

      D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;

      return;

    }

    // Mark the matched option as found. Do not allow duplicate specifiers.

    OptionIter->second = true;

    // If the precision was not specified, also mark the double and half entry

    // as found.

    if (ValBase.back() != 'f' && ValBase.back() != 'd' && ValBase.back() != 'h') {

      OptionStrings[ValBase.str() + 'd'] = true;

      OptionStrings[ValBase.str() + 'h'] = true;

    }

    // Build the output string.

    StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;

    Out = Args.MakeArgString(Out + Prefix + Val);

    if (i != NumOptions - 1)

      Out = Args.MakeArgString(Out + ",");

  }

  OutStrings.push_back(Args.MakeArgString(Out));

}

/// The -mprefer-vector-width option accepts either a positive integer

/// or the string "none".

static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args,

                                    ArgStringList &CmdArgs) {

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

  if (!A)

    return;

  StringRef Value = A->getValue();

  if (Value == "none") {

    CmdArgs.push_back("-mprefer-vector-width=none");

  } else {

    unsigned Width;

    if (Value.getAsInteger(10, Width)) {

      D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value;

      return;

    }

    CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value));

  }

}

static bool

shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime,

                                          const llvm::Triple &Triple) {

  // We use the zero-cost exception tables for Objective-C if the non-fragile

  // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and

  // later.

  if (runtime.isNonFragile())

    return true;

  if (!Triple.isMacOSX())

    return false;

  return (!Triple.isMacOSXVersionLT(10, 5) &&

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

           Triple.getArch() == llvm::Triple::arm));

}

/// Adds exception related arguments to the driver command arguments. There's a

/// main flag, -fexceptions and also language specific flags to enable/disable

/// C++ and Objective-C exceptions. This makes it possible to for example

/// disable C++ exceptions but enable Objective-C exceptions.

static bool addExceptionArgs(const ArgList &Args, types::ID InputType,

                             const ToolChain &TC, bool KernelOrKext,

                             const ObjCRuntime &objcRuntime,

                             ArgStringList &CmdArgs) {

  const llvm::Triple &Triple = TC.getTriple();

  if (KernelOrKext) {

    // -mkernel and -fapple-kext imply no exceptions, so claim exception related

    // arguments now to avoid warnings about unused arguments.

    Args.ClaimAllArgs(options::OPT_fexceptions);

    Args.ClaimAllArgs(options::OPT_fno_exceptions);

    Args.ClaimAllArgs(options::OPT_fobjc_exceptions);

    Args.ClaimAllArgs(options::OPT_fno_objc_exceptions);

    Args.ClaimAllArgs(options::OPT_fcxx_exceptions);

    Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions);

    Args.ClaimAllArgs(options::OPT_fasync_exceptions);

    Args.ClaimAllArgs(options::OPT_fno_async_exceptions);

    return false;

  }

  // See if the user explicitly enabled exceptions.

  bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,

                         false);

  bool EHa = Args.hasFlag(options::OPT_fasync_exceptions,

                          options::OPT_fno_async_exceptions, false);

  if (EHa) {

    CmdArgs.push_back("-fasync-exceptions");

    EH = true;

  }

  // Obj-C exceptions are enabled by default, regardless of -fexceptions. This

  // is not necessarily sensible, but follows GCC.

  if (types::isObjC(InputType) &&

      Args.hasFlag(options::OPT_fobjc_exceptions,

                   options::OPT_fno_objc_exceptions, true)) {

    CmdArgs.push_back("-fobjc-exceptions");

    EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple);

  }

  if (types::isCXX(InputType)) {

    // Disable C++ EH by default on XCore and PS4/PS5.

    bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore &&

                                !Triple.isPS() && !Triple.isDriverKit();

    Arg *ExceptionArg = Args.getLastArg(

        options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions,

        options::OPT_fexceptions, options::OPT_fno_exceptions);

    if (ExceptionArg)

      CXXExceptionsEnabled =

          ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) ||

          ExceptionArg->getOption().matches(options::OPT_fexceptions);

    if (CXXExceptionsEnabled) {

      CmdArgs.push_back("-fcxx-exceptions");

      EH = true;

    }

  }

  // OPT_fignore_exceptions means exception could still be thrown,

  // but no clean up or catch would happen in current module.

  // So we do not set EH to false.

  Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions);

  Args.addOptInFlag(CmdArgs, options::OPT_fassume_nothrow_exception_dtor,

                    options::OPT_fno_assume_nothrow_exception_dtor);

  if (EH)

    CmdArgs.push_back("-fexceptions");

  return EH;

}

static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC,

                                 const JobAction &JA) {

  bool Default = true;

  if (TC.getTriple().isOSDarwin()) {

    // The native darwin assembler doesn't support the linker_option directives,

    // so we disable them if we think the .s file will be passed to it.

    Default = TC.useIntegratedAs();

  }

  // The linker_option directives are intended for host compilation.

  if (JA.isDeviceOffloading(Action::OFK_Cuda) ||

      JA.isDeviceOffloading(Action::OFK_HIP))

    Default = false;

  return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink,

                      Default);

}

/// Add a CC1 option to specify the debug compilation directory.

static const char *addDebugCompDirArg(const ArgList &Args,

                                      ArgStringList &CmdArgs,

                                      const llvm::vfs::FileSystem &VFS) {

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

                               options::OPT_fdebug_compilation_dir_EQ)) {

    if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))

      CmdArgs.push_back(Args.MakeArgString(Twine("-fdebug-compilation-dir=") +

                                           A->getValue()));

    else

      A->render(Args, CmdArgs);

  } else if (llvm::ErrorOr<std::string> CWD =

                 VFS.getCurrentWorkingDirectory()) {

    CmdArgs.push_back(Args.MakeArgString("-fdebug-compilation-dir=" + *CWD));

  }

  StringRef Path(CmdArgs.back());

  return Path.substr(Path.find('=') + 1).data();

}

static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs,

                               const char *DebugCompilationDir,

                               const char *OutputFileName) {

  // No need to generate a value for -object-file-name if it was provided.

  for (auto *Arg : Args.filtered(options::OPT_Xclang))

    if (StringRef(Arg->getValue()).starts_with("-object-file-name"))

      return;

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

    return;

  SmallString<128> ObjFileNameForDebug(OutputFileName);

  if (ObjFileNameForDebug != "-" &&

      !llvm::sys::path::is_absolute(ObjFileNameForDebug) &&

      (!DebugCompilationDir ||

       llvm::sys::path::is_absolute(DebugCompilationDir))) {

    // Make the path absolute in the debug infos like MSVC does.

    llvm::sys::fs::make_absolute(ObjFileNameForDebug);

  }

  // If the object file name is a relative path, then always use Windows

  // backslash style as -object-file-name is used for embedding object file path

  // in codeview and it can only be generated when targeting on Windows.

  // Otherwise, just use native absolute path.

  llvm::sys::path::Style Style =

      llvm::sys::path::is_absolute(ObjFileNameForDebug)

          ? llvm::sys::path::Style::native

          : llvm::sys::path::Style::windows_backslash;

  llvm::sys::path::remove_dots(ObjFileNameForDebug, /*remove_dot_dot=*/true,

                               Style);

  CmdArgs.push_back(

      Args.MakeArgString(Twine("-object-file-name=") + ObjFileNameForDebug));

}

/// Add a CC1 and CC1AS option to specify the debug file path prefix map.

static void addDebugPrefixMapArg(const Driver &D, const ToolChain &TC,

                                 const ArgList &Args, ArgStringList &CmdArgs) {

  auto AddOneArg = [&](StringRef Map, StringRef Name) {

    if (!Map.contains('='))

      D.Diag(diag::err_drv_invalid_argument_to_option) << Map << Name;

    else

      CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map));

  };

  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

                                    options::OPT_fdebug_prefix_map_EQ)) {

    AddOneArg(A->getValue(), A->getOption().getName());

    A->claim();

  }

  std::string GlobalRemapEntry = TC.GetGlobalDebugPathRemapping();

  if (GlobalRemapEntry.empty())

    return;

  AddOneArg(GlobalRemapEntry, "environment");

}

/// Add a CC1 and CC1AS option to specify the macro file path prefix map.

static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args,

                                 ArgStringList &CmdArgs) {

  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

                                    options::OPT_fmacro_prefix_map_EQ)) {

    StringRef Map = A->getValue();

    if (!Map.contains('='))

      D.Diag(diag::err_drv_invalid_argument_to_option)

          << Map << A->getOption().getName();

    else

      CmdArgs.push_back(Args.MakeArgString("-fmacro-prefix-map=" + Map));

    A->claim();

  }

}

/// Add a CC1 and CC1AS option to specify the coverage file path prefix map.

static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args,

                                   ArgStringList &CmdArgs) {

  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,

                                    options::OPT_fcoverage_prefix_map_EQ)) {

    StringRef Map = A->getValue();

    if (!Map.contains('='))

      D.Diag(diag::err_drv_invalid_argument_to_option)

          << Map << A->getOption().getName();

    else

      CmdArgs.push_back(Args.MakeArgString("-fcoverage-prefix-map=" + Map));

    A->claim();

  }

}

/// Vectorize at all optimization levels greater than 1 except for -Oz.

/// For -Oz the loop vectorizer is disabled, while the slp vectorizer is

/// enabled.

static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {

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

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

        A->getOption().matches(options::OPT_Ofast))

      return true;

    if (A->getOption().matches(options::OPT_O0))

      return false;

    assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");

    // Vectorize -Os.

    StringRef S(A->getValue());

    if (S == "s")

      return true;

    // Don't vectorize -Oz, unless it's the slp vectorizer.

    if (S == "z")

      return isSlpVec;

    unsigned OptLevel = 0;

    if (S.getAsInteger(10, OptLevel))

      return false;

    return OptLevel > 1;

  }

  return false;

}

/// Add -x lang to \p CmdArgs for \p Input.

static void addDashXForInput(const ArgList &Args, const InputInfo &Input,

                             ArgStringList &CmdArgs) {

  // When using -verify-pch, we don't want to provide the type

  // 'precompiled-header' if it was inferred from the file extension

  if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)

    return;

  CmdArgs.push_back("-x");

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

    CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX));

  else {

    // Map the driver type to the frontend type. This is mostly an identity

    // mapping, except that the distinction between module interface units

    // and other source files does not exist at the frontend layer.

    const char *ClangType;

    switch (Input.getType()) {

    case types::TY_CXXModule:

      ClangType = "c++";

      break;

    case types::TY_PP_CXXModule:

      ClangType = "c++-cpp-output";

      break;

    default:

      ClangType = types::getTypeName(Input.getType());

      break;

    }

    CmdArgs.push_back(ClangType);

  }

}

static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C,

                                   const JobAction &JA, const InputInfo &Output,

                                   const ArgList &Args, SanitizerArgs &SanArgs,

                                   ArgStringList &CmdArgs) {

  const Driver &D = TC.getDriver();

  auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,

                                         options::OPT_fprofile_generate_EQ,

                                         options::OPT_fno_profile_generate);

  if (PGOGenerateArg &&

      PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))

    PGOGenerateArg = nullptr;

  auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args);

  auto *ProfileGenerateArg = Args.getLastArg(

      options::OPT_fprofile_instr_generate,

      options::OPT_fprofile_instr_generate_EQ,

      options::OPT_fno_profile_instr_generate);

  if (ProfileGenerateArg &&

      ProfileGenerateArg->getOption().matches(

          options::OPT_fno_profile_instr_generate))

    ProfileGenerateArg = nullptr;

  if (PGOGenerateArg && ProfileGenerateArg)

    D.Diag(diag::err_drv_argument_not_allowed_with)

        << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();

  auto *ProfileUseArg = getLastProfileUseArg(Args);

  if (PGOGenerateArg && ProfileUseArg)

    D.Diag(diag::err_drv_argument_not_allowed_with)

        << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();

  if (ProfileGenerateArg && ProfileUseArg)

    D.Diag(diag::err_drv_argument_not_allowed_with)

        << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();

  if (CSPGOGenerateArg && PGOGenerateArg) {

    D.Diag(diag::err_drv_argument_not_allowed_with)

        << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();

    PGOGenerateArg = nullptr;

  }

  if (TC.getTriple().isOSAIX()) {

    if (Arg *ProfileSampleUseArg = getLastProfileSampleUseArg(Args))

      D.Diag(diag::err_drv_unsupported_opt_for_target)

          << ProfileSampleUseArg->getSpelling() << TC.getTriple().str();

  }

  if (ProfileGenerateArg) {

    if (ProfileGenerateArg->getOption().matches(

            options::OPT_fprofile_instr_generate_EQ))

      CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +

                                           ProfileGenerateArg->getValue()));

    // The default is to use Clang Instrumentation.

    CmdArgs.push_back("-fprofile-instrument=clang");

    if (TC.getTriple().isWindowsMSVCEnvironment()) {

      // Add dependent lib for clang_rt.profile

      CmdArgs.push_back(Args.MakeArgString(

          "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));

    }

  }

  Arg *PGOGenArg = nullptr;

  if (PGOGenerateArg) {

    assert(!CSPGOGenerateArg);

    PGOGenArg = PGOGenerateArg;

    CmdArgs.push_back("-fprofile-instrument=llvm");

  }

  if (CSPGOGenerateArg) {

    assert(!PGOGenerateArg);

    PGOGenArg = CSPGOGenerateArg;

    CmdArgs.push_back("-fprofile-instrument=csllvm");

  }

  if (PGOGenArg) {

    if (TC.getTriple().isWindowsMSVCEnvironment()) {

      // Add dependent lib for clang_rt.profile

      CmdArgs.push_back(Args.MakeArgString(

          "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));

    }

    if (PGOGenArg->getOption().matches(

            PGOGenerateArg ? options::OPT_fprofile_generate_EQ

                           : options::OPT_fcs_profile_generate_EQ)) {

      SmallString<128> Path(PGOGenArg->getValue());

      llvm::sys::path::append(Path, "default_%m.profraw");

      CmdArgs.push_back(

          Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));

    }

  }

  if (ProfileUseArg) {

    if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))

      CmdArgs.push_back(Args.MakeArgString(

          Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));

    else if ((ProfileUseArg->getOption().matches(

                  options::OPT_fprofile_use_EQ) ||

              ProfileUseArg->getOption().matches(

                  options::OPT_fprofile_instr_use))) {

      SmallString<128> Path(

          ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());

      if (Path.empty() || llvm::sys::fs::is_directory(Path))

        llvm::sys::path::append(Path, "default.profdata");

      CmdArgs.push_back(

          Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));

    }

  }

  bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,

                                   options::OPT_fno_test_coverage, false) ||

                      Args.hasArg(options::OPT_coverage);

  bool EmitCovData = TC.needsGCovInstrumentation(Args);

  if (Args.hasFlag(options::OPT_fcoverage_mapping,

                   options::OPT_fno_coverage_mapping, false)) {

    if (!ProfileGenerateArg)

      D.Diag(clang::diag::err_drv_argument_only_allowed_with)

          << "-fcoverage-mapping"

          << "-fprofile-instr-generate";

    CmdArgs.push_back("-fcoverage-mapping");

  }

  if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,

                   false)) {

    if (!Args.hasFlag(options::OPT_fcoverage_mapping,

                      options::OPT_fno_coverage_mapping, false))

      D.Diag(clang::diag::err_drv_argument_only_allowed_with)

          << "-fcoverage-mcdc"

          << "-fcoverage-mapping";

    CmdArgs.push_back("-fcoverage-mcdc");

  }

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

                               options::OPT_fcoverage_compilation_dir_EQ)) {

    if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))

      CmdArgs.push_back(Args.MakeArgString(

          Twine("-fcoverage-compilation-dir=") + A->getValue()));

    else

      A->render(Args, CmdArgs);

  } else if (llvm::ErrorOr<std::string> CWD =

                 D.getVFS().getCurrentWorkingDirectory()) {

    CmdArgs.push_back(Args.MakeArgString("-fcoverage-compilation-dir=" + *CWD));

  }

  if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {

    auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);

    if (!Args.hasArg(options::OPT_coverage))

      D.Diag(clang::diag::err_drv_argument_only_allowed_with)

          << "-fprofile-exclude-files="

          << "--coverage";

    StringRef v = Arg->getValue();

    CmdArgs.push_back(

        Args.MakeArgString(Twine("-fprofile-exclude-files=" + v)));

  }

  if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {

    auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);

    if (!Args.hasArg(options::OPT_coverage))

      D.Diag(clang::diag::err_drv_argument_only_allowed_with)

          << "-fprofile-filter-files="

          << "--coverage";

    StringRef v = Arg->getValue();

    CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v)));

  }

  if (const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {

    StringRef Val = A->getValue();

    if (Val == "atomic" || Val == "prefer-atomic")

      CmdArgs.push_back("-fprofile-update=atomic");

    else if (Val != "single")

      D.Diag(diag::err_drv_unsupported_option_argument)

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

  }

  int FunctionGroups = 1;

  int SelectedFunctionGroup = 0;

  if (const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {

    StringRef Val = A->getValue();

    if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)

      D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;

  }

  if (const auto *A =

          Args.getLastArg(options::OPT_fprofile_selected_function_group)) {

    StringRef Val = A->getValue();

    if (Val.getAsInteger(0, SelectedFunctionGroup) ||

        SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)

      D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;

  }

  if (FunctionGroups != 1)

    CmdArgs.push_back(Args.MakeArgString("-fprofile-function-groups=" +

                                         Twine(FunctionGroups)));

  if (SelectedFunctionGroup != 0)

    CmdArgs.push_back(Args.MakeArgString("-fprofile-selected-function-group=" +

                                         Twine(SelectedFunctionGroup)));

  // Leave -fprofile-dir= an unused argument unless .gcda emission is

  // enabled. To be polite, with '-fprofile-arcs -fno-profile-arcs' consider

  // the flag used. There is no -fno-profile-dir, so the user has no

  // targeted way to suppress the warning.

  Arg *FProfileDir = nullptr;

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

      Args.hasArg(options::OPT_coverage))

    FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);

  // TODO: Don't claim -c/-S to warn about -fsyntax-only -c/-S, -E -c/-S,

  // like we warn about -fsyntax-only -E.

  (void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));

  // Put the .gcno and .gcda files (if needed) next to the primary output file,

  // or fall back to a file in the current directory for `clang -c --coverage

  // d/a.c` in the absence of -o.

  if (EmitCovNotes || EmitCovData) {

    SmallString<128> CoverageFilename;

    if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {

      // Form ${dumpdir}${basename}.gcno. Note that dumpdir may not end with a

      // path separator.

      CoverageFilename = DumpDir->getValue();

      CoverageFilename += llvm::sys::path::filename(Output.getBaseInput());

    } else if (Arg *FinalOutput =

                   C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {

      CoverageFilename = FinalOutput->getValue();

    } else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {

      CoverageFilename = FinalOutput->getValue();

    } else {

      CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());

    }

    if (llvm::sys::path::is_relative(CoverageFilename))

      (void)D.getVFS().makeAbsolute(CoverageFilename);

    llvm::sys::path::replace_extension(CoverageFilename, "gcno");

    if (EmitCovNotes) {

      CmdArgs.push_back(

          Args.MakeArgString("-coverage-notes-file=" + CoverageFilename));

    }

    if (EmitCovData) {

      if (FProfileDir) {

        SmallString<128> Gcno = std::move(CoverageFilename);

        CoverageFilename = FProfileDir->getValue();

        llvm::sys::path::append(CoverageFilename, Gcno);

      }

      llvm::sys::path::replace_extension(CoverageFilename, "gcda");

      CmdArgs.push_back(

          Args.MakeArgString("-coverage-data-file=" + CoverageFilename));

    }

  }

}

/// Check whether the given input tree contains any compilation actions.

static bool ContainsCompileAction(const Action *A) {

  if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A))

    return true;

  return llvm::any_of(A->inputs(), ContainsCompileAction);

}

/// Check if -relax-all should be passed to the internal assembler.

/// This is done by default when compiling non-assembler source with -O0.

static bool UseRelaxAll(Compilation &C, const ArgList &Args) {

  bool RelaxDefault = true;

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

    RelaxDefault = A->getOption().matches(options::OPT_O0);

  if (RelaxDefault) {

    RelaxDefault = false;

    for (const auto &Act : C.getActions()) {

      if (ContainsCompileAction(Act)) {

        RelaxDefault = true;

        break;

      }

    }

  }

  return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all,

                      RelaxDefault);

}

static void

RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs,

                        llvm::codegenoptions::DebugInfoKind DebugInfoKind,

                        unsigned DwarfVersion,

                        llvm::DebuggerKind DebuggerTuning) {

  addDebugInfoKind(CmdArgs, DebugInfoKind);

  if (DwarfVersion > 0)

    CmdArgs.push_back(

        Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion)));

  switch (DebuggerTuning) {

  case llvm::DebuggerKind::GDB:

    CmdArgs.push_back("-debugger-tuning=gdb");

    break;

  case llvm::DebuggerKind::LLDB:

    CmdArgs.push_back("-debugger-tuning=lldb");

    break;

  case llvm::DebuggerKind::SCE: