//===--- Darwin.cpp - Darwin Tool and 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 "Darwin.h"

#include "Arch/AArch64.h"

#include "Arch/ARM.h"

#include "CommonArgs.h"

#include "clang/Basic/AlignedAllocation.h"

#include "clang/Basic/ObjCRuntime.h"

#include "clang/Config/config.h"

#include "clang/Driver/Compilation.h"

#include "clang/Driver/Driver.h"

#include "clang/Driver/DriverDiagnostic.h"

#include "clang/Driver/Options.h"

#include "clang/Driver/SanitizerArgs.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Option/ArgList.h"

#include "llvm/ProfileData/InstrProf.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/ScopedPrinter.h"

#include "llvm/Support/Threading.h"

#include "llvm/Support/VirtualFileSystem.h"

#include "llvm/TargetParser/TargetParser.h"

#include "llvm/TargetParser/Triple.h"

#include <cstdlib> // ::getenv

using namespace clang::driver;

using namespace clang::driver::tools;

using namespace clang::driver::toolchains;

using namespace clang;

using namespace llvm::opt;

static VersionTuple minimumMacCatalystDeploymentTarget() {

  return VersionTuple(13, 1);

}

llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {

  // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for

  // archs which Darwin doesn't use.

  // The matching this routine does is fairly pointless, since it is neither the

  // complete architecture list, nor a reasonable subset. The problem is that

  // historically the driver accepts this and also ties its -march=

  // handling to the architecture name, so we need to be careful before removing

  // support for it.

  // This code must be kept in sync with Clang's Darwin specific argument

  // translation.

  return llvm::StringSwitch<llvm::Triple::ArchType>(Str)

      .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)

      .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",

             llvm::Triple::x86)

      .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)

      // This is derived from the driver.

      .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)

      .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)

      .Cases("armv7s", "xscale", llvm::Triple::arm)

      .Cases("arm64", "arm64e", llvm::Triple::aarch64)

      .Case("arm64_32", llvm::Triple::aarch64_32)

      .Case("r600", llvm::Triple::r600)

      .Case("amdgcn", llvm::Triple::amdgcn)

      .Case("nvptx", llvm::Triple::nvptx)

      .Case("nvptx64", llvm::Triple::nvptx64)

      .Case("amdil", llvm::Triple::amdil)

      .Case("spir", llvm::Triple::spir)

      .Default(llvm::Triple::UnknownArch);

}

void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str,

                                           const ArgList &Args) {

  const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);

  llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);

  T.setArch(Arch);

  if (Arch != llvm::Triple::UnknownArch)

    T.setArchName(Str);

  if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||

      ArchKind == llvm::ARM::ArchKind::ARMV7M ||

      ArchKind == llvm::ARM::ArchKind::ARMV7EM) {

    // Don't reject these -version-min= if we have the appropriate triple.

    if (T.getOS() == llvm::Triple::IOS)

      for (Arg *A : Args.filtered(options::OPT_mios_version_min_EQ))

        A->ignoreTargetSpecific();

    if (T.getOS() == llvm::Triple::WatchOS)

      for (Arg *A : Args.filtered(options::OPT_mwatchos_version_min_EQ))

        A->ignoreTargetSpecific();

    if (T.getOS() == llvm::Triple::TvOS)

      for (Arg *A : Args.filtered(options::OPT_mtvos_version_min_EQ))

        A->ignoreTargetSpecific();

    T.setOS(llvm::Triple::UnknownOS);

    T.setObjectFormat(llvm::Triple::MachO);

  }

}

void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,

                                     const InputInfo &Output,

                                     const InputInfoList &Inputs,

                                     const ArgList &Args,

                                     const char *LinkingOutput) const {

  const llvm::Triple &T(getToolChain().getTriple());

  ArgStringList CmdArgs;

  assert(Inputs.size() == 1 && "Unexpected number of inputs.");

  const InputInfo &Input = Inputs[0];

  // Determine the original source input.

  const Action *SourceAction = &JA;

  while (SourceAction->getKind() != Action::InputClass) {

    assert(!SourceAction->getInputs().empty() && "unexpected root action!");

    SourceAction = SourceAction->getInputs()[0];

  }

  // If -fno-integrated-as is used add -Q to the darwin assembler driver to make

  // sure it runs its system assembler not clang's integrated assembler.

  // Applicable to darwin11+ and Xcode 4+.  darwin<10 lacked integrated-as.

  // FIXME: at run-time detect assembler capabilities or rely on version

  // information forwarded by -target-assembler-version.

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

    if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))

      CmdArgs.push_back("-Q");

  }

  // Forward -g, assuming we are dealing with an actual assembly file.

  if (SourceAction->getType() == types::TY_Asm ||

      SourceAction->getType() == types::TY_PP_Asm) {

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

      CmdArgs.push_back("--gstabs");

    else if (Args.hasArg(options::OPT_g_Group))

      CmdArgs.push_back("-g");

  }

  // Derived from asm spec.

  AddMachOArch(Args, CmdArgs);

  // Use -force_cpusubtype_ALL on x86 by default.

  if (T.isX86() || Args.hasArg(options::OPT_force__cpusubtype__ALL))

    CmdArgs.push_back("-force_cpusubtype_ALL");

  if (getToolChain().getArch() != llvm::Triple::x86_64 &&

      (((Args.hasArg(options::OPT_mkernel) ||

         Args.hasArg(options::OPT_fapple_kext)) &&

        getMachOToolChain().isKernelStatic()) ||

       Args.hasArg(options::OPT_static)))

    CmdArgs.push_back("-static");

  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);

  assert(Output.isFilename() && "Unexpected lipo output.");

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  assert(Input.isFilename() && "Invalid input.");

  CmdArgs.push_back(Input.getFilename());

  // asm_final spec is empty.

  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));

  C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),

                                         Exec, CmdArgs, Inputs, Output));

}

void darwin::MachOTool::anchor() {}

void darwin::MachOTool::AddMachOArch(const ArgList &Args,

                                     ArgStringList &CmdArgs) const {

  StringRef ArchName = getMachOToolChain().getMachOArchName(Args);

  // Derived from darwin_arch spec.

  CmdArgs.push_back("-arch");

  CmdArgs.push_back(Args.MakeArgString(ArchName));

  // FIXME: Is this needed anymore?

  if (ArchName == "arm")

    CmdArgs.push_back("-force_cpusubtype_ALL");

}

bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {

  // We only need to generate a temp path for LTO if we aren't compiling object

  // files. When compiling source files, we run 'dsymutil' after linking. We

  // don't run 'dsymutil' when compiling object files.

  for (const auto &Input : Inputs)

    if (Input.getType() != types::TY_Object)

      return true;

  return false;

}

/// Pass -no_deduplicate to ld64 under certain conditions:

///

/// - Either -O0 or -O1 is explicitly specified

/// - No -O option is specified *and* this is a compile+link (implicit -O0)

///

/// Also do *not* add -no_deduplicate when no -O option is specified and this

/// is just a link (we can't imply -O0)

static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) {

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

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

      return true;

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

      return llvm::StringSwitch<bool>(A->getValue())

                    .Case("1", true)

                    .Default(false);

    return false; // OPT_Ofast & OPT_O4

  }

  if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only.

    return true;

  return false;

}

void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,

                                 ArgStringList &CmdArgs,

                                 const InputInfoList &Inputs,

                                 VersionTuple Version, bool LinkerIsLLD) const {

  const Driver &D = getToolChain().getDriver();

  const toolchains::MachO &MachOTC = getMachOToolChain();

  // Newer linkers support -demangle. Pass it if supported and not disabled by

  // the user.

  if ((Version >= VersionTuple(100) || LinkerIsLLD) &&

      !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))

    CmdArgs.push_back("-demangle");

  if (Args.hasArg(options::OPT_rdynamic) &&

      (Version >= VersionTuple(137) || LinkerIsLLD))

    CmdArgs.push_back("-export_dynamic");

  // If we are using App Extension restrictions, pass a flag to the linker

  // telling it that the compiled code has been audited.

  if (Args.hasFlag(options::OPT_fapplication_extension,

                   options::OPT_fno_application_extension, false))

    CmdArgs.push_back("-application_extension");

  if (D.isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&

      NeedsTempPath(Inputs)) {

    std::string TmpPathName;

    if (D.getLTOMode() == LTOK_Full) {

      // If we are using full LTO, then automatically create a temporary file

      // path for the linker to use, so that it's lifetime will extend past a

      // possible dsymutil step.

      TmpPathName =

          D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object));

    } else if (D.getLTOMode() == LTOK_Thin)

      // If we are using thin LTO, then create a directory instead.

      TmpPathName = D.GetTemporaryDirectory("thinlto");

    if (!TmpPathName.empty()) {

      auto *TmpPath = C.getArgs().MakeArgString(TmpPathName);

      C.addTempFile(TmpPath);

      CmdArgs.push_back("-object_path_lto");

      CmdArgs.push_back(TmpPath);

    }

  }

  // Use -lto_library option to specify the libLTO.dylib path. Try to find

  // it in clang installed libraries. ld64 will only look at this argument

  // when it actually uses LTO, so libLTO.dylib only needs to exist at link

  // time if ld64 decides that it needs to use LTO.

  // Since this is passed unconditionally, ld64 will never look for libLTO.dylib

  // next to it. That's ok since ld64 using a libLTO.dylib not matching the

  // clang version won't work anyways.

  // lld is built at the same revision as clang and statically links in

  // LLVM libraries, so it doesn't need libLTO.dylib.

  if (Version >= VersionTuple(133) && !LinkerIsLLD) {

    // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib

    StringRef P = llvm::sys::path::parent_path(D.Dir);

    SmallString<128> LibLTOPath(P);

    llvm::sys::path::append(LibLTOPath, "lib");

    llvm::sys::path::append(LibLTOPath, "libLTO.dylib");

    CmdArgs.push_back("-lto_library");

    CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));

  }

  // ld64 version 262 and above runs the deduplicate pass by default.

  // FIXME: lld doesn't dedup by default. Should we pass `--icf=safe`

  //        if `!shouldLinkerNotDedup()` if LinkerIsLLD here?

  if (Version >= VersionTuple(262) &&

      shouldLinkerNotDedup(C.getJobs().empty(), Args))

    CmdArgs.push_back("-no_deduplicate");

  // Derived from the "link" spec.

  Args.AddAllArgs(CmdArgs, options::OPT_static);

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

    CmdArgs.push_back("-dynamic");

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

    // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu

    // here. How do we wish to handle such things?

  }

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

    AddMachOArch(Args, CmdArgs);

    // FIXME: Why do this only on this path?

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

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

    Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);

    Args.AddAllArgs(CmdArgs, options::OPT_client__name);

    Arg *A;

    if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||

        (A = Args.getLastArg(options::OPT_current__version)) ||

        (A = Args.getLastArg(options::OPT_install__name)))

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

                                                       << "-dynamiclib";

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

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

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

  } else {

    CmdArgs.push_back("-dylib");

    Arg *A;

    if ((A = Args.getLastArg(options::OPT_bundle)) ||

        (A = Args.getLastArg(options::OPT_bundle__loader)) ||

        (A = Args.getLastArg(options::OPT_client__name)) ||

        (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||

        (A = Args.getLastArg(options::OPT_keep__private__externs)) ||

        (A = Args.getLastArg(options::OPT_private__bundle)))

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

                                                      << "-dynamiclib";

    Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,

                              "-dylib_compatibility_version");

    Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,

                              "-dylib_current_version");

    AddMachOArch(Args, CmdArgs);

    Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,

                              "-dylib_install_name");

  }

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

  Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);

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

  if (MachOTC.isTargetIOSBased())

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

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);

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

  Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);

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

  Args.AddAllArgs(CmdArgs, options::OPT_force__load);

  Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);

  Args.AddAllArgs(CmdArgs, options::OPT_image__base);

  Args.AddAllArgs(CmdArgs, options::OPT_init);

  // Add the deployment target.

  if (Version >= VersionTuple(520) || LinkerIsLLD)

    MachOTC.addPlatformVersionArgs(Args, CmdArgs);

  else

    MachOTC.addMinVersionArgs(Args, CmdArgs);

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

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);

  Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);

  if (const Arg *A =

          Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,

                          options::OPT_fno_pie, options::OPT_fno_PIE)) {

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

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

      CmdArgs.push_back("-pie");

    else

      CmdArgs.push_back("-no_pie");

  }

  // for embed-bitcode, use -bitcode_bundle in linker command

  if (C.getDriver().embedBitcodeEnabled()) {

    // Check if the toolchain supports bitcode build flow.

    if (MachOTC.SupportsEmbeddedBitcode()) {

      CmdArgs.push_back("-bitcode_bundle");

      // FIXME: Pass this if LinkerIsLLD too, once it implements this flag.

      if (C.getDriver().embedBitcodeMarkerOnly() &&

          Version >= VersionTuple(278)) {

        CmdArgs.push_back("-bitcode_process_mode");

        CmdArgs.push_back("marker");

      }

    } else

      D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);

  }

  // If GlobalISel is enabled, pass it through to LLVM.

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

                               options::OPT_fno_global_isel)) {

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

      CmdArgs.push_back("-mllvm");

      CmdArgs.push_back("-global-isel");

      // Disable abort and fall back to SDAG silently.

      CmdArgs.push_back("-mllvm");

      CmdArgs.push_back("-global-isel-abort=0");

    }

  }

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

      Args.hasArg(options::OPT_fapple_kext) ||

      Args.hasArg(options::OPT_ffreestanding)) {

    CmdArgs.push_back("-mllvm");

    CmdArgs.push_back("-disable-atexit-based-global-dtor-lowering");

  }

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

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

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

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);

  Args.AddAllArgs(CmdArgs, options::OPT_sectorder);

  Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);

  Args.AddAllArgs(CmdArgs, options::OPT_segprot);

  Args.AddAllArgs(CmdArgs, options::OPT_segaddr);

  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);

  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);

  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);

  Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);

  Args.AddAllArgs(CmdArgs, options::OPT_sub__library);

  Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);

  // Give --sysroot= preference, over the Apple specific behavior to also use

  // --isysroot as the syslibroot.

  StringRef sysroot = C.getSysRoot();

  if (sysroot != "") {

    CmdArgs.push_back("-syslibroot");

    CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));

  } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {

    CmdArgs.push_back("-syslibroot");

    CmdArgs.push_back(A->getValue());

  }

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_umbrella);

  Args.AddAllArgs(CmdArgs, options::OPT_undefined);

  Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);

  Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);

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

  Args.AddAllArgs(CmdArgs, options::OPT_y);

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

  Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);

  Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_sectalign);

  Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);

  Args.AddAllArgs(CmdArgs, options::OPT_segcreate);

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

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

  Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);

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

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

  if (LinkerIsLLD) {

    if (auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args)) {

      SmallString<128> Path(CSPGOGenerateArg->getNumValues() == 0

                                ? ""

                                : CSPGOGenerateArg->getValue());

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

      CmdArgs.push_back("--cs-profile-generate");

      CmdArgs.push_back(Args.MakeArgString(Twine("--cs-profile-path=") + Path));

    } else if (auto *ProfileUseArg = getLastProfileUseArg(Args)) {

      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("--cs-profile-path=") + Path));

    }

  }

}

/// Determine whether we are linking the ObjC runtime.

static bool isObjCRuntimeLinked(const ArgList &Args) {

  if (isObjCAutoRefCount(Args)) {

    Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);

    return true;

  }

  return Args.hasArg(options::OPT_fobjc_link_runtime);

}

static bool checkRemarksOptions(const Driver &D, const ArgList &Args,

                                const llvm::Triple &Triple) {

  // When enabling remarks, we need to error if:

  // * The remark file is specified but we're targeting multiple architectures,

  // which means more than one remark file is being generated.

  bool hasMultipleInvocations =

      Args.getAllArgValues(options::OPT_arch).size() > 1;

  bool hasExplicitOutputFile =

      Args.getLastArg(options::OPT_foptimization_record_file_EQ);

  if (hasMultipleInvocations && hasExplicitOutputFile) {

    D.Diag(diag::err_drv_invalid_output_with_multiple_archs)

        << "-foptimization-record-file";

    return false;

  }

  return true;

}

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

                                 const llvm::Triple &Triple,

                                 const InputInfo &Output, const JobAction &JA) {

  StringRef Format = "yaml";

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

    Format = A->getValue();

  CmdArgs.push_back("-mllvm");

  CmdArgs.push_back("-lto-pass-remarks-output");

  CmdArgs.push_back("-mllvm");

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

  if (A) {

    CmdArgs.push_back(A->getValue());

  } else {

    assert(Output.isFilename() && "Unexpected ld output.");

    SmallString<128> F;

    F = Output.getFilename();

    F += ".opt.";

    F += Format;

    CmdArgs.push_back(Args.MakeArgString(F));

  }

  if (const Arg *A =

          Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {

    CmdArgs.push_back("-mllvm");

    std::string Passes =

        std::string("-lto-pass-remarks-filter=") + A->getValue();

    CmdArgs.push_back(Args.MakeArgString(Passes));

  }

  if (!Format.empty()) {

    CmdArgs.push_back("-mllvm");

    Twine FormatArg = Twine("-lto-pass-remarks-format=") + Format;

    CmdArgs.push_back(Args.MakeArgString(FormatArg));

  }

  if (getLastProfileUseArg(Args)) {

    CmdArgs.push_back("-mllvm");

    CmdArgs.push_back("-lto-pass-remarks-with-hotness");

    if (const Arg *A =

            Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {

      CmdArgs.push_back("-mllvm");

      std::string Opt =

          std::string("-lto-pass-remarks-hotness-threshold=") + A->getValue();

      CmdArgs.push_back(Args.MakeArgString(Opt));

    }

  }

}

static void AppendPlatformPrefix(SmallString<128> &Path, const llvm::Triple &T);

void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,

                                  const InputInfo &Output,

                                  const InputInfoList &Inputs,

                                  const ArgList &Args,

                                  const char *LinkingOutput) const {

  assert(Output.getType() == types::TY_Image && "Invalid linker output type.");

  // If the number of arguments surpasses the system limits, we will encode the

  // input files in a separate file, shortening the command line. To this end,

  // build a list of input file names that can be passed via a file with the

  // -filelist linker option.

  llvm::opt::ArgStringList InputFileList;

  // The logic here is derived from gcc's behavior; most of which

  // comes from specs (starting with link_command). Consult gcc for

  // more information.

  ArgStringList CmdArgs;

  /// Hack(tm) to ignore linking errors when we are doing ARC migration.

  if (Args.hasArg(options::OPT_ccc_arcmt_check,

                  options::OPT_ccc_arcmt_migrate)) {

    for (const auto &Arg : Args)

      Arg->claim();

    const char *Exec =

        Args.MakeArgString(getToolChain().GetProgramPath("touch"));

    CmdArgs.push_back(Output.getFilename());

    C.addCommand(std::make_unique<Command>(JA, *this,

                                           ResponseFileSupport::None(), Exec,

                                           CmdArgs, std::nullopt, Output));

    return;

  }

  VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);

  bool LinkerIsLLD;

  const char *Exec =

      Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));

  // I'm not sure why this particular decomposition exists in gcc, but

  // we follow suite for ease of comparison.

  AddLinkArgs(C, Args, CmdArgs, Inputs, Version, LinkerIsLLD);

  if (willEmitRemarks(Args) &&

      checkRemarksOptions(getToolChain().getDriver(), Args,

                          getToolChain().getTriple()))

    renderRemarksOptions(Args, CmdArgs, getToolChain().getTriple(), Output, JA);

  // Propagate the -moutline flag to the linker in LTO.

  if (Arg *A =

          Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {

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

      if (getMachOToolChain().getMachOArchName(Args) == "arm64") {

        CmdArgs.push_back("-mllvm");

        CmdArgs.push_back("-enable-machine-outliner");

      }

    } else {

      // Disable all outlining behaviour if we have mno-outline. We need to do

      // this explicitly, because targets which support default outlining will

      // try to do work if we don't.

      CmdArgs.push_back("-mllvm");

      CmdArgs.push_back("-enable-machine-outliner=never");

    }

  }

  // Outline from linkonceodr functions by default in LTO, whenever the outliner

  // is enabled.  Note that the target may enable the machine outliner

  // independently of -moutline.

  CmdArgs.push_back("-mllvm");

  CmdArgs.push_back("-enable-linkonceodr-outlining");

  // Setup statistics file output.

  SmallString<128> StatsFile =

      getStatsFileName(Args, Output, Inputs[0], getToolChain().getDriver());

  if (!StatsFile.empty()) {

    CmdArgs.push_back("-mllvm");

    CmdArgs.push_back(Args.MakeArgString("-lto-stats-file=" + StatsFile.str()));

  }

  // It seems that the 'e' option is completely ignored for dynamic executables

  // (the default), and with static executables, the last one wins, as expected.

  Args.addAllArgs(CmdArgs,

                  {options::OPT_d_Flag, options::OPT_s, options::OPT_t,

                   options::OPT_Z_Flag, options::OPT_u_Group, options::OPT_r});

  // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading

  // members of static archive libraries which implement Objective-C classes or

  // categories.

  if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))

    CmdArgs.push_back("-ObjC");

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))

    getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);

  Args.AddAllArgs(CmdArgs, options::OPT_L);

  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);

  // Build the input file for -filelist (list of linker input files) in case we

  // need it later

  for (const auto &II : Inputs) {

    if (!II.isFilename()) {

      // This is a linker input argument.

      // We cannot mix input arguments and file names in a -filelist input, thus

      // we prematurely stop our list (remaining files shall be passed as

      // arguments).

      if (InputFileList.size() > 0)

        break;

      continue;

    }

    InputFileList.push_back(II.getFilename());

  }

  // Additional linker set-up and flags for Fortran. This is required in order

  // to generate executables.

  if (getToolChain().getDriver().IsFlangMode()) {

    addFortranRuntimeLibraryPath(getToolChain(), Args, CmdArgs);

    addFortranRuntimeLibs(getToolChain(), Args, CmdArgs);

  }

  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))

    addOpenMPRuntime(CmdArgs, getToolChain(), Args);

  if (isObjCRuntimeLinked(Args) &&

      !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

    // We use arclite library for both ARC and subscripting support.

    getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);

    CmdArgs.push_back("-framework");

    CmdArgs.push_back("Foundation");

    // Link libobj.

    CmdArgs.push_back("-lobjc");

  }

  if (LinkingOutput) {

    CmdArgs.push_back("-arch_multiple");

    CmdArgs.push_back("-final_output");

    CmdArgs.push_back(LinkingOutput);

  }

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

    CmdArgs.push_back("-allow_stack_execute");

  getMachOToolChain().addProfileRTLibs(Args, CmdArgs);

  StringRef Parallelism = getLTOParallelism(Args, getToolChain().getDriver());

  if (!Parallelism.empty()) {

    CmdArgs.push_back("-mllvm");

    unsigned NumThreads =

        llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();

    CmdArgs.push_back(Args.MakeArgString("-threads=" + Twine(NumThreads)));

  }

  if (getToolChain().ShouldLinkCXXStdlib(Args))

    getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);

  bool NoStdOrDefaultLibs =

      Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);

  bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);

  if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {

    // link_ssp spec is empty.

    // If we have both -nostdlib/nodefaultlibs and -fapple-link-rtlib then

    // we just want to link the builtins, not the other libs like libSystem.

    if (NoStdOrDefaultLibs && ForceLinkBuiltins) {

      getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs, "builtins");

    } else {

      // Let the tool chain choose which runtime library to link.

      getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,

                                                ForceLinkBuiltins);

      // No need to do anything for pthreads. Claim argument to avoid warning.

      Args.ClaimAllArgs(options::OPT_pthread);

      Args.ClaimAllArgs(options::OPT_pthreads);

    }

  }

  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {

    // endfile_spec is empty.

  }

  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);

  Args.AddAllArgs(CmdArgs, options::OPT_F);

  // -iframework should be forwarded as -F.

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

    CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));

  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {

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

      if (A->getValue() == StringRef("Accelerate")) {

        CmdArgs.push_back("-framework");

        CmdArgs.push_back("Accelerate");

      }

    }

  }

  // Add non-standard, platform-specific search paths, e.g., for DriverKit:

  //  -L<sysroot>/System/DriverKit/usr/lib

  //  -F<sysroot>/System/DriverKit/System/Library/Framework

  {

    bool NonStandardSearchPath = false;

    const auto &Triple = getToolChain().getTriple();

    if (Triple.isDriverKit()) {

      // ld64 fixed the implicit -F and -L paths in ld64-605.1+.

      NonStandardSearchPath =

          Version.getMajor() < 605 ||

          (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);

    }

    if (NonStandardSearchPath) {

      if (auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {

        auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {

          SmallString<128> P(Sysroot->getValue());

          AppendPlatformPrefix(P, Triple);

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

          if (getToolChain().getVFS().exists(P)) {

            CmdArgs.push_back(Args.MakeArgString(Flag + P));

          }

        };

        AddSearchPath("-L", "/usr/lib");

        AddSearchPath("-F", "/System/Library/Frameworks");

      }

    }

  }

  ResponseFileSupport ResponseSupport;

  if (Version >= VersionTuple(705) || LinkerIsLLD) {

    ResponseSupport = ResponseFileSupport::AtFileUTF8();

  } else {

    // For older versions of the linker, use the legacy filelist method instead.

    ResponseSupport = {ResponseFileSupport::RF_FileList, llvm::sys::WEM_UTF8,

                       "-filelist"};

  }

  std::unique_ptr<Command> Cmd = std::make_unique<Command>(

      JA, *this, ResponseSupport, Exec, CmdArgs, Inputs, Output);

  Cmd->setInputFileList(std::move(InputFileList));

  C.addCommand(std::move(Cmd));

}

void darwin::StaticLibTool::ConstructJob(Compilation &C, const JobAction &JA,

                                         const InputInfo &Output,

                                         const InputInfoList &Inputs,

                                         const ArgList &Args,

                                         const char *LinkingOutput) const {

  const Driver &D = getToolChain().getDriver();

  // Silence warning for "clang -g foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_g_Group);

  // and "clang -emit-llvm foo.o -o foo"

  Args.ClaimAllArgs(options::OPT_emit_llvm);

  // and for "clang -w foo.o -o foo". Other warning options are already

  // handled somewhere else.

  Args.ClaimAllArgs(options::OPT_w);

  // Silence warnings when linking C code with a C++ '-stdlib' argument.

  Args.ClaimAllArgs(options::OPT_stdlib_EQ);

  // libtool <options> <output_file> <input_files>

  ArgStringList CmdArgs;

  // Create and insert file members with a deterministic index.

  CmdArgs.push_back("-static");

  CmdArgs.push_back("-D");

  CmdArgs.push_back("-no_warning_for_no_symbols");

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  for (const auto &II : Inputs) {

    if (II.isFilename()) {

      CmdArgs.push_back(II.getFilename());

    }

  }

  // Delete old output archive file if it already exists before generating a new

  // archive file.

  const auto *OutputFileName = Output.getFilename();

  if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {

    if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {

      D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();

      return;

    }

  }

  const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());

  C.addCommand(std::make_unique<Command>(JA, *this,

                                         ResponseFileSupport::AtFileUTF8(),

                                         Exec, CmdArgs, Inputs, Output));

}

void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,

                                const InputInfo &Output,

                                const InputInfoList &Inputs,

                                const ArgList &Args,

                                const char *LinkingOutput) const {

  ArgStringList CmdArgs;

  CmdArgs.push_back("-create");

  assert(Output.isFilename() && "Unexpected lipo output.");

  CmdArgs.push_back("-output");

  CmdArgs.push_back(Output.getFilename());

  for (const auto &II : Inputs) {

    assert(II.isFilename() && "Unexpected lipo input.");

    CmdArgs.push_back(II.getFilename());

  }

  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));

  C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),

                                         Exec, CmdArgs, Inputs, Output));

}

void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,

                                    const InputInfo &Output,

                                    const InputInfoList &Inputs,

                                    const ArgList &Args,

                                    const char *LinkingOutput) const {

  ArgStringList CmdArgs;

  CmdArgs.push_back("-o");

  CmdArgs.push_back(Output.getFilename());

  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");

  const InputInfo &Input = Inputs[0];

  assert(Input.isFilename() && "Unexpected dsymutil input.");

  CmdArgs.push_back(Input.getFilename());

  const char *Exec =

      Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));

  C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),