contrib/llvm/tools/clang/lib/Driver/ToolChains/Darwin.cpp

   1 //===--- Darwin.cpp - Darwin Tool and ToolChain Implementations -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "Darwin.h"
  11 #include "Arch/ARM.h"
  12 #include "CommonArgs.h"
  13 #include "clang/Basic/ObjCRuntime.h"
  14 #include "clang/Basic/VirtualFileSystem.h"
  15 #include "clang/Driver/Compilation.h"
  16 #include "clang/Driver/Driver.h"
  17 #include "clang/Driver/DriverDiagnostic.h"
  18 #include "clang/Driver/Options.h"
  19 #include "clang/Driver/SanitizerArgs.h"
  20 #include "llvm/ADT/StringSwitch.h"
  21 #include "llvm/Option/ArgList.h"
  22 #include "llvm/Support/Path.h"
  23 #include "llvm/Support/ScopedPrinter.h"
  24 #include "llvm/Support/TargetParser.h"
  25 #include <cstdlib> // ::getenv
  26
  27 using namespace clang::driver;
  28 using namespace clang::driver::tools;
  29 using namespace clang::driver::toolchains;
  30 using namespace clang;
  31 using namespace llvm::opt;
  32
  33 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
  34   // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
  35   // archs which Darwin doesn't use.
  36
  37   // The matching this routine does is fairly pointless, since it is neither the
  38   // complete architecture list, nor a reasonable subset. The problem is that
  39   // historically the driver driver accepts this and also ties its -march=
  40   // handling to the architecture name, so we need to be careful before removing
  41   // support for it.
  42
  43   // This code must be kept in sync with Clang's Darwin specific argument
  44   // translation.
  45
  46   return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
  47       .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
  48       .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
  49       .Case("ppc64", llvm::Triple::ppc64)
  50       .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
  51       .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
  52              llvm::Triple::x86)
  53       .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
  54       // This is derived from the driver driver.
  55       .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
  56       .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
  57       .Cases("armv7s", "xscale", llvm::Triple::arm)
  58       .Case("arm64", llvm::Triple::aarch64)
  59       .Case("r600", llvm::Triple::r600)
  60       .Case("amdgcn", llvm::Triple::amdgcn)
  61       .Case("nvptx", llvm::Triple::nvptx)
  62       .Case("nvptx64", llvm::Triple::nvptx64)
  63       .Case("amdil", llvm::Triple::amdil)
  64       .Case("spir", llvm::Triple::spir)
  65       .Default(llvm::Triple::UnknownArch);
  66 }
  67
  68 void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
  69   const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
  70   unsigned ArchKind = llvm::ARM::parseArch(Str);
  71   T.setArch(Arch);
  72
  73   if (Str == "x86_64h")
  74     T.setArchName(Str);
  75   else if (ArchKind == llvm::ARM::AK_ARMV6M ||
  76            ArchKind == llvm::ARM::AK_ARMV7M ||
  77            ArchKind == llvm::ARM::AK_ARMV7EM) {
  78     T.setOS(llvm::Triple::UnknownOS);
  79     T.setObjectFormat(llvm::Triple::MachO);
  80   }
  81 }
  82
  83 void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
  84                                      const InputInfo &Output,
  85                                      const InputInfoList &Inputs,
  86                                      const ArgList &Args,
  87                                      const char *LinkingOutput) const {
  88   ArgStringList CmdArgs;
  89
  90   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
  91   const InputInfo &Input = Inputs[0];
  92
  93   // Determine the original source input.
  94   const Action *SourceAction = &JA;
  95   while (SourceAction->getKind() != Action::InputClass) {
  96     assert(!SourceAction->getInputs().empty() && "unexpected root action!");
  97     SourceAction = SourceAction->getInputs()[0];
  98   }
  99
 100   // If -fno-integrated-as is used add -Q to the darwin assember driver to make
 101   // sure it runs its system assembler not clang's integrated assembler.
 102   // Applicable to darwin11+ and Xcode 4+.  darwin<10 lacked integrated-as.
 103   // FIXME: at run-time detect assembler capabilities or rely on version
 104   // information forwarded by -target-assembler-version.
 105   if (Args.hasArg(options::OPT_fno_integrated_as)) {
 106     const llvm::Triple &T(getToolChain().getTriple());
 107     if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
 108       CmdArgs.push_back("-Q");
 109   }
 110
 111   // Forward -g, assuming we are dealing with an actual assembly file.
 112   if (SourceAction->getType() == types::TY_Asm ||
 113       SourceAction->getType() == types::TY_PP_Asm) {
 114     if (Args.hasArg(options::OPT_gstabs))
 115       CmdArgs.push_back("--gstabs");
 116     else if (Args.hasArg(options::OPT_g_Group))
 117       CmdArgs.push_back("-g");
 118   }
 119
 120   // Derived from asm spec.
 121   AddMachOArch(Args, CmdArgs);
 122
 123   // Use -force_cpusubtype_ALL on x86 by default.
 124   if (getToolChain().getArch() == llvm::Triple::x86 ||
 125       getToolChain().getArch() == llvm::Triple::x86_64 ||
 126       Args.hasArg(options::OPT_force__cpusubtype__ALL))
 127     CmdArgs.push_back("-force_cpusubtype_ALL");
 128
 129   if (getToolChain().getArch() != llvm::Triple::x86_64 &&
 130       (((Args.hasArg(options::OPT_mkernel) ||
 131          Args.hasArg(options::OPT_fapple_kext)) &&
 132         getMachOToolChain().isKernelStatic()) ||
 133        Args.hasArg(options::OPT_static)))
 134     CmdArgs.push_back("-static");
 135
 136   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 137
 138   assert(Output.isFilename() && "Unexpected lipo output.");
 139   CmdArgs.push_back("-o");
 140   CmdArgs.push_back(Output.getFilename());
 141
 142   assert(Input.isFilename() && "Invalid input.");
 143   CmdArgs.push_back(Input.getFilename());
 144
 145   // asm_final spec is empty.
 146
 147   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
 148   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 149 }
 150
 151 void darwin::MachOTool::anchor() {}
 152
 153 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
 154                                      ArgStringList &CmdArgs) const {
 155   StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
 156
 157   // Derived from darwin_arch spec.
 158   CmdArgs.push_back("-arch");
 159   CmdArgs.push_back(Args.MakeArgString(ArchName));
 160
 161   // FIXME: Is this needed anymore?
 162   if (ArchName == "arm")
 163     CmdArgs.push_back("-force_cpusubtype_ALL");
 164 }
 165
 166 bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
 167   // We only need to generate a temp path for LTO if we aren't compiling object
 168   // files. When compiling source files, we run 'dsymutil' after linking. We
 169   // don't run 'dsymutil' when compiling object files.
 170   for (const auto &Input : Inputs)
 171     if (Input.getType() != types::TY_Object)
 172       return true;
 173
 174   return false;
 175 }
 176
 177 /// \brief Pass -no_deduplicate to ld64 under certain conditions:
 178 ///
 179 /// - Either -O0 or -O1 is explicitly specified
 180 /// - No -O option is specified *and* this is a compile+link (implicit -O0)
 181 ///
 182 /// Also do *not* add -no_deduplicate when no -O option is specified and this
 183 /// is just a link (we can't imply -O0)
 184 static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) {
 185   if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
 186     if (A->getOption().matches(options::OPT_O0))
 187       return true;
 188     if (A->getOption().matches(options::OPT_O))
 189       return llvm::StringSwitch<bool>(A->getValue())
 190                     .Case("1", true)
 191                     .Default(false);
 192     return false; // OPT_Ofast & OPT_O4
 193   }
 194
 195   if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only.
 196     return true;
 197   return false;
 198 }
 199
 200 void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
 201                                  ArgStringList &CmdArgs,
 202                                  const InputInfoList &Inputs) const {
 203   const Driver &D = getToolChain().getDriver();
 204   const toolchains::MachO &MachOTC = getMachOToolChain();
 205
 206   unsigned Version[5] = {0, 0, 0, 0, 0};
 207   if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
 208     if (!Driver::GetReleaseVersion(A->getValue(), Version))
 209       D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
 210   }
 211
 212   // Newer linkers support -demangle. Pass it if supported and not disabled by
 213   // the user.
 214   if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
 215     CmdArgs.push_back("-demangle");
 216
 217   if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
 218     CmdArgs.push_back("-export_dynamic");
 219
 220   // If we are using App Extension restrictions, pass a flag to the linker
 221   // telling it that the compiled code has been audited.
 222   if (Args.hasFlag(options::OPT_fapplication_extension,
 223                    options::OPT_fno_application_extension, false))
 224     CmdArgs.push_back("-application_extension");
 225
 226   if (D.isUsingLTO()) {
 227     // If we are using LTO, then automatically create a temporary file path for
 228     // the linker to use, so that it's lifetime will extend past a possible
 229     // dsymutil step.
 230     if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
 231       const char *TmpPath = C.getArgs().MakeArgString(
 232           D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
 233       C.addTempFile(TmpPath);
 234       CmdArgs.push_back("-object_path_lto");
 235       CmdArgs.push_back(TmpPath);
 236     }
 237   }
 238
 239   // Use -lto_library option to specify the libLTO.dylib path. Try to find
 240   // it in clang installed libraries. ld64 will only look at this argument
 241   // when it actually uses LTO, so libLTO.dylib only needs to exist at link
 242   // time if ld64 decides that it needs to use LTO.
 243   // Since this is passed unconditionally, ld64 will never look for libLTO.dylib
 244   // next to it. That's ok since ld64 using a libLTO.dylib not matching the
 245   // clang version won't work anyways.
 246   if (Version[0] >= 133) {
 247     // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
 248     StringRef P = llvm::sys::path::parent_path(D.Dir);
 249     SmallString<128> LibLTOPath(P);
 250     llvm::sys::path::append(LibLTOPath, "lib");
 251     llvm::sys::path::append(LibLTOPath, "libLTO.dylib");
 252     CmdArgs.push_back("-lto_library");
 253     CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));
 254   }
 255
 256   // ld64 version 262 and above run the deduplicate pass by default.
 257   if (Version[0] >= 262 && shouldLinkerNotDedup(C.getJobs().empty(), Args))
 258     CmdArgs.push_back("-no_deduplicate");
 259
 260   // Derived from the "link" spec.
 261   Args.AddAllArgs(CmdArgs, options::OPT_static);
 262   if (!Args.hasArg(options::OPT_static))
 263     CmdArgs.push_back("-dynamic");
 264   if (Args.hasArg(options::OPT_fgnu_runtime)) {
 265     // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
 266     // here. How do we wish to handle such things?
 267   }
 268
 269   if (!Args.hasArg(options::OPT_dynamiclib)) {
 270     AddMachOArch(Args, CmdArgs);
 271     // FIXME: Why do this only on this path?
 272     Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
 273
 274     Args.AddLastArg(CmdArgs, options::OPT_bundle);
 275     Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
 276     Args.AddAllArgs(CmdArgs, options::OPT_client__name);
 277
 278     Arg *A;
 279     if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
 280         (A = Args.getLastArg(options::OPT_current__version)) ||
 281         (A = Args.getLastArg(options::OPT_install__name)))
 282       D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
 283                                                        << "-dynamiclib";
 284
 285     Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
 286     Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
 287     Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
 288   } else {
 289     CmdArgs.push_back("-dylib");
 290
 291     Arg *A;
 292     if ((A = Args.getLastArg(options::OPT_bundle)) ||
 293         (A = Args.getLastArg(options::OPT_bundle__loader)) ||
 294         (A = Args.getLastArg(options::OPT_client__name)) ||
 295         (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
 296         (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
 297         (A = Args.getLastArg(options::OPT_private__bundle)))
 298       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
 299                                                       << "-dynamiclib";
 300
 301     Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
 302                               "-dylib_compatibility_version");
 303     Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
 304                               "-dylib_current_version");
 305
 306     AddMachOArch(Args, CmdArgs);
 307
 308     Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
 309                               "-dylib_install_name");
 310   }
 311
 312   Args.AddLastArg(CmdArgs, options::OPT_all__load);
 313   Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
 314   Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
 315   if (MachOTC.isTargetIOSBased())
 316     Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
 317   Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
 318   Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
 319   Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
 320   Args.AddLastArg(CmdArgs, options::OPT_dynamic);
 321   Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
 322   Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
 323   Args.AddAllArgs(CmdArgs, options::OPT_force__load);
 324   Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
 325   Args.AddAllArgs(CmdArgs, options::OPT_image__base);
 326   Args.AddAllArgs(CmdArgs, options::OPT_init);
 327
 328   // Add the deployment target.
 329   MachOTC.addMinVersionArgs(Args, CmdArgs);
 330
 331   Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
 332   Args.AddLastArg(CmdArgs, options::OPT_multi__module);
 333   Args.AddLastArg(CmdArgs, options::OPT_single__module);
 334   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
 335   Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
 336
 337   if (const Arg *A =
 338           Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
 339                           options::OPT_fno_pie, options::OPT_fno_PIE)) {
 340     if (A->getOption().matches(options::OPT_fpie) ||
 341         A->getOption().matches(options::OPT_fPIE))
 342       CmdArgs.push_back("-pie");
 343     else
 344       CmdArgs.push_back("-no_pie");
 345   }
 346
 347   // for embed-bitcode, use -bitcode_bundle in linker command
 348   if (C.getDriver().embedBitcodeEnabled()) {
 349     // Check if the toolchain supports bitcode build flow.
 350     if (MachOTC.SupportsEmbeddedBitcode()) {
 351       CmdArgs.push_back("-bitcode_bundle");
 352       if (C.getDriver().embedBitcodeMarkerOnly() && Version[0] >= 278) {
 353         CmdArgs.push_back("-bitcode_process_mode");
 354         CmdArgs.push_back("marker");
 355       }
 356     } else
 357       D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
 358   }
 359
 360   Args.AddLastArg(CmdArgs, options::OPT_prebind);
 361   Args.AddLastArg(CmdArgs, options::OPT_noprebind);
 362   Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
 363   Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
 364   Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
 365   Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
 366   Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
 367   Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
 368   Args.AddAllArgs(CmdArgs, options::OPT_segprot);
 369   Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
 370   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
 371   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
 372   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
 373   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
 374   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
 375   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
 376
 377   // Give --sysroot= preference, over the Apple specific behavior to also use
 378   // --isysroot as the syslibroot.
 379   StringRef sysroot = C.getSysRoot();
 380   if (sysroot != "") {
 381     CmdArgs.push_back("-syslibroot");
 382     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
 383   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
 384     CmdArgs.push_back("-syslibroot");
 385     CmdArgs.push_back(A->getValue());
 386   }
 387
 388   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
 389   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
 390   Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
 391   Args.AddAllArgs(CmdArgs, options::OPT_undefined);
 392   Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
 393   Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
 394   Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
 395   Args.AddAllArgs(CmdArgs, options::OPT_y);
 396   Args.AddLastArg(CmdArgs, options::OPT_w);
 397   Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
 398   Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
 399   Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
 400   Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
 401   Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
 402   Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
 403   Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
 404   Args.AddLastArg(CmdArgs, options::OPT_whyload);
 405   Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
 406   Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
 407   Args.AddLastArg(CmdArgs, options::OPT_dylinker);
 408   Args.AddLastArg(CmdArgs, options::OPT_Mach);
 409 }
 410
 411 /// \brief Determine whether we are linking the ObjC runtime.
 412 static bool isObjCRuntimeLinked(const ArgList &Args) {
 413   if (isObjCAutoRefCount(Args)) {
 414     Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
 415     return true;
 416   }
 417   return Args.hasArg(options::OPT_fobjc_link_runtime);
 418 }
 419
 420 void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 421                                   const InputInfo &Output,
 422                                   const InputInfoList &Inputs,
 423                                   const ArgList &Args,
 424                                   const char *LinkingOutput) const {
 425   assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
 426
 427   // If the number of arguments surpasses the system limits, we will encode the
 428   // input files in a separate file, shortening the command line. To this end,
 429   // build a list of input file names that can be passed via a file with the
 430   // -filelist linker option.
 431   llvm::opt::ArgStringList InputFileList;
 432
 433   // The logic here is derived from gcc's behavior; most of which
 434   // comes from specs (starting with link_command). Consult gcc for
 435   // more information.
 436   ArgStringList CmdArgs;
 437
 438   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
 439   if (Args.hasArg(options::OPT_ccc_arcmt_check,
 440                   options::OPT_ccc_arcmt_migrate)) {
 441     for (const auto &Arg : Args)
 442       Arg->claim();
 443     const char *Exec =
 444         Args.MakeArgString(getToolChain().GetProgramPath("touch"));
 445     CmdArgs.push_back(Output.getFilename());
 446     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
 447     return;
 448   }
 449
 450   // I'm not sure why this particular decomposition exists in gcc, but
 451   // we follow suite for ease of comparison.
 452   AddLinkArgs(C, Args, CmdArgs, Inputs);
 453
 454   // For LTO, pass the name of the optimization record file.
 455   if (Args.hasFlag(options::OPT_fsave_optimization_record,
 456                    options::OPT_fno_save_optimization_record, false)) {
 457     CmdArgs.push_back("-mllvm");
 458     CmdArgs.push_back("-lto-pass-remarks-output");
 459     CmdArgs.push_back("-mllvm");
 460
 461     SmallString<128> F;
 462     F = Output.getFilename();
 463     F += ".opt.yaml";
 464     CmdArgs.push_back(Args.MakeArgString(F));
 465
 466     if (getLastProfileUseArg(Args)) {
 467       CmdArgs.push_back("-mllvm");
 468       CmdArgs.push_back("-lto-pass-remarks-with-hotness");
 469     }
 470   }
 471
 472   // It seems that the 'e' option is completely ignored for dynamic executables
 473   // (the default), and with static executables, the last one wins, as expected.
 474   Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
 475                             options::OPT_Z_Flag, options::OPT_u_Group,
 476                             options::OPT_e, options::OPT_r});
 477
 478   // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
 479   // members of static archive libraries which implement Objective-C classes or
 480   // categories.
 481   if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
 482     CmdArgs.push_back("-ObjC");
 483
 484   CmdArgs.push_back("-o");
 485   CmdArgs.push_back(Output.getFilename());
 486
 487   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
 488     getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
 489
 490   // SafeStack requires its own runtime libraries
 491   // These libraries should be linked first, to make sure the
 492   // __safestack_init constructor executes before everything else
 493   if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
 494     getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
 495                                           "libclang_rt.safestack_osx.a",
 496                                           /*AlwaysLink=*/true);
 497   }
 498
 499   Args.AddAllArgs(CmdArgs, options::OPT_L);
 500
 501   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
 502   // Build the input file for -filelist (list of linker input files) in case we
 503   // need it later
 504   for (const auto &II : Inputs) {
 505     if (!II.isFilename()) {
 506       // This is a linker input argument.
 507       // We cannot mix input arguments and file names in a -filelist input, thus
 508       // we prematurely stop our list (remaining files shall be passed as
 509       // arguments).
 510       if (InputFileList.size() > 0)
 511         break;
 512
 513       continue;
 514     }
 515
 516     InputFileList.push_back(II.getFilename());
 517   }
 518
 519   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
 520     addOpenMPRuntime(CmdArgs, getToolChain(), Args);
 521
 522   if (isObjCRuntimeLinked(Args) &&
 523       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 524     // We use arclite library for both ARC and subscripting support.
 525     getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
 526
 527     CmdArgs.push_back("-framework");
 528     CmdArgs.push_back("Foundation");
 529     // Link libobj.
 530     CmdArgs.push_back("-lobjc");
 531   }
 532
 533   if (LinkingOutput) {
 534     CmdArgs.push_back("-arch_multiple");
 535     CmdArgs.push_back("-final_output");
 536     CmdArgs.push_back(LinkingOutput);
 537   }
 538
 539   if (Args.hasArg(options::OPT_fnested_functions))
 540     CmdArgs.push_back("-allow_stack_execute");
 541
 542   getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
 543
 544   if (unsigned Parallelism =
 545           getLTOParallelism(Args, getToolChain().getDriver())) {
 546     CmdArgs.push_back("-mllvm");
 547     CmdArgs.push_back(
 548         Args.MakeArgString(Twine("-threads=") + llvm::to_string(Parallelism)));
 549   }
 550
 551   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 552     if (getToolChain().getDriver().CCCIsCXX())
 553       getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
 554
 555     // link_ssp spec is empty.
 556
 557     // Let the tool chain choose which runtime library to link.
 558     getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
 559
 560     // No need to do anything for pthreads. Claim argument to avoid warning.
 561     Args.ClaimAllArgs(options::OPT_pthread);
 562     Args.ClaimAllArgs(options::OPT_pthreads);
 563   }
 564
 565   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
 566     // endfile_spec is empty.
 567   }
 568
 569   Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
 570   Args.AddAllArgs(CmdArgs, options::OPT_F);
 571
 572   // -iframework should be forwarded as -F.
 573   for (const Arg *A : Args.filtered(options::OPT_iframework))
 574     CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
 575
 576   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 577     if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
 578       if (A->getValue() == StringRef("Accelerate")) {
 579         CmdArgs.push_back("-framework");
 580         CmdArgs.push_back("Accelerate");
 581       }
 582     }
 583   }
 584
 585   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
 586   std::unique_ptr<Command> Cmd =
 587       llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
 588   Cmd->setInputFileList(std::move(InputFileList));
 589   C.addCommand(std::move(Cmd));
 590 }
 591
 592 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
 593                                 const InputInfo &Output,
 594                                 const InputInfoList &Inputs,
 595                                 const ArgList &Args,
 596                                 const char *LinkingOutput) const {
 597   ArgStringList CmdArgs;
 598
 599   CmdArgs.push_back("-create");
 600   assert(Output.isFilename() && "Unexpected lipo output.");
 601
 602   CmdArgs.push_back("-output");
 603   CmdArgs.push_back(Output.getFilename());
 604
 605   for (const auto &II : Inputs) {
 606     assert(II.isFilename() && "Unexpected lipo input.");
 607     CmdArgs.push_back(II.getFilename());
 608   }
 609
 610   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
 611   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 612 }
 613
 614 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
 615                                     const InputInfo &Output,
 616                                     const InputInfoList &Inputs,
 617                                     const ArgList &Args,
 618                                     const char *LinkingOutput) const {
 619   ArgStringList CmdArgs;
 620
 621   CmdArgs.push_back("-o");
 622   CmdArgs.push_back(Output.getFilename());
 623
 624   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
 625   const InputInfo &Input = Inputs[0];
 626   assert(Input.isFilename() && "Unexpected dsymutil input.");
 627   CmdArgs.push_back(Input.getFilename());
 628
 629   const char *Exec =
 630       Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
 631   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 632 }
 633
 634 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
 635                                        const InputInfo &Output,
 636                                        const InputInfoList &Inputs,
 637                                        const ArgList &Args,
 638                                        const char *LinkingOutput) const {
 639   ArgStringList CmdArgs;
 640   CmdArgs.push_back("--verify");
 641   CmdArgs.push_back("--debug-info");
 642   CmdArgs.push_back("--eh-frame");
 643   CmdArgs.push_back("--quiet");
 644
 645   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
 646   const InputInfo &Input = Inputs[0];
 647   assert(Input.isFilename() && "Unexpected verify input");
 648
 649   // Grabbing the output of the earlier dsymutil run.
 650   CmdArgs.push_back(Input.getFilename());
 651
 652   const char *Exec =
 653       Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
 654   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 655 }
 656
 657 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
 658     : ToolChain(D, Triple, Args) {
 659   // We expect 'as', 'ld', etc. to be adjacent to our install dir.
 660   getProgramPaths().push_back(getDriver().getInstalledDir());
 661   if (getDriver().getInstalledDir() != getDriver().Dir)
 662     getProgramPaths().push_back(getDriver().Dir);
 663 }
 664
 665 /// Darwin - Darwin tool chain for i386 and x86_64.
 666 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
 667     : MachO(D, Triple, Args), TargetInitialized(false),
 668       CudaInstallation(D, Triple, Args) {}
 669
 670 types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
 671   types::ID Ty = types::lookupTypeForExtension(Ext);
 672
 673   // Darwin always preprocesses assembly files (unless -x is used explicitly).
 674   if (Ty == types::TY_PP_Asm)
 675     return types::TY_Asm;
 676
 677   return Ty;
 678 }
 679
 680 bool MachO::HasNativeLLVMSupport() const { return true; }
 681
 682 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
 683   // Default to use libc++ on OS X 10.9+ and iOS 7+.
 684   if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
 685        (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
 686        isTargetWatchOSBased())
 687     return ToolChain::CST_Libcxx;
 688
 689   return ToolChain::CST_Libstdcxx;
 690 }
 691
 692 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
 693 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
 694   if (isTargetWatchOSBased())
 695     return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
 696   if (isTargetIOSBased())
 697     return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
 698   if (isNonFragile)
 699     return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
 700   return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
 701 }
 702
 703 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
 704 bool Darwin::hasBlocksRuntime() const {
 705   if (isTargetWatchOSBased())
 706     return true;
 707   else if (isTargetIOSBased())
 708     return !isIPhoneOSVersionLT(3, 2);
 709   else {
 710     assert(isTargetMacOS() && "unexpected darwin target");
 711     return !isMacosxVersionLT(10, 6);
 712   }
 713 }
 714
 715 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
 716                                 ArgStringList &CC1Args) const {
 717   CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
 718 }
 719
 720 // This is just a MachO name translation routine and there's no
 721 // way to join this into ARMTargetParser without breaking all
 722 // other assumptions. Maybe MachO should consider standardising
 723 // their nomenclature.
 724 static const char *ArmMachOArchName(StringRef Arch) {
 725   return llvm::StringSwitch<const char *>(Arch)
 726       .Case("armv6k", "armv6")
 727       .Case("armv6m", "armv6m")
 728       .Case("armv5tej", "armv5")
 729       .Case("xscale", "xscale")
 730       .Case("armv4t", "armv4t")
 731       .Case("armv7", "armv7")
 732       .Cases("armv7a", "armv7-a", "armv7")
 733       .Cases("armv7r", "armv7-r", "armv7")
 734       .Cases("armv7em", "armv7e-m", "armv7em")
 735       .Cases("armv7k", "armv7-k", "armv7k")
 736       .Cases("armv7m", "armv7-m", "armv7m")
 737       .Cases("armv7s", "armv7-s", "armv7s")
 738       .Default(nullptr);
 739 }
 740
 741 static const char *ArmMachOArchNameCPU(StringRef CPU) {
 742   unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
 743   if (ArchKind == llvm::ARM::AK_INVALID)
 744     return nullptr;
 745   StringRef Arch = llvm::ARM::getArchName(ArchKind);
 746
 747   // FIXME: Make sure this MachO triple mangling is really necessary.
 748   // ARMv5* normalises to ARMv5.
 749   if (Arch.startswith("armv5"))
 750     Arch = Arch.substr(0, 5);
 751   // ARMv6*, except ARMv6M, normalises to ARMv6.
 752   else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
 753     Arch = Arch.substr(0, 5);
 754   // ARMv7A normalises to ARMv7.
 755   else if (Arch.endswith("v7a"))
 756     Arch = Arch.substr(0, 5);
 757   return Arch.data();
 758 }
 759
 760 StringRef MachO::getMachOArchName(const ArgList &Args) const {
 761   switch (getTriple().getArch()) {
 762   default:
 763     return getDefaultUniversalArchName();
 764
 765   case llvm::Triple::aarch64:
 766     return "arm64";
 767
 768   case llvm::Triple::thumb:
 769   case llvm::Triple::arm:
 770     if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
 771       if (const char *Arch = ArmMachOArchName(A->getValue()))
 772         return Arch;
 773
 774     if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
 775       if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
 776         return Arch;
 777
 778     return "arm";
 779   }
 780 }
 781
 782 Darwin::~Darwin() {}
 783
 784 MachO::~MachO() {}
 785
 786 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
 787                                                 types::ID InputType) const {
 788   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
 789
 790   // If the target isn't initialized (e.g., an unknown Darwin platform, return
 791   // the default triple).
 792   if (!isTargetInitialized())
 793     return Triple.getTriple();
 794
 795   SmallString<16> Str;
 796   if (isTargetWatchOSBased())
 797     Str += "watchos";
 798   else if (isTargetTvOSBased())
 799     Str += "tvos";
 800   else if (isTargetIOSBased())
 801     Str += "ios";
 802   else
 803     Str += "macosx";
 804   Str += getTargetVersion().getAsString();
 805   Triple.setOSName(Str);
 806
 807   return Triple.getTriple();
 808 }
 809
 810 Tool *MachO::getTool(Action::ActionClass AC) const {
 811   switch (AC) {
 812   case Action::LipoJobClass:
 813     if (!Lipo)
 814       Lipo.reset(new tools::darwin::Lipo(*this));
 815     return Lipo.get();
 816   case Action::DsymutilJobClass:
 817     if (!Dsymutil)
 818       Dsymutil.reset(new tools::darwin::Dsymutil(*this));
 819     return Dsymutil.get();
 820   case Action::VerifyDebugInfoJobClass:
 821     if (!VerifyDebug)
 822       VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
 823     return VerifyDebug.get();
 824   default:
 825     return ToolChain::getTool(AC);
 826   }
 827 }
 828
 829 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
 830
 831 Tool *MachO::buildAssembler() const {
 832   return new tools::darwin::Assembler(*this);
 833 }
 834
 835 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
 836                          const ArgList &Args)
 837     : Darwin(D, Triple, Args) {}
 838
 839 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
 840   // For modern targets, promote certain warnings to errors.
 841   if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
 842     // Always enable -Wdeprecated-objc-isa-usage and promote it
 843     // to an error.
 844     CC1Args.push_back("-Wdeprecated-objc-isa-usage");
 845     CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
 846
 847     // For iOS and watchOS, also error about implicit function declarations,
 848     // as that can impact calling conventions.
 849     if (!isTargetMacOS())
 850       CC1Args.push_back("-Werror=implicit-function-declaration");
 851   }
 852 }
 853
 854 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
 855                                  ArgStringList &CmdArgs) const {
 856   // Avoid linking compatibility stubs on i386 mac.
 857   if (isTargetMacOS() && getArch() == llvm::Triple::x86)
 858     return;
 859
 860   ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
 861
 862   if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
 863       runtime.hasSubscripting())
 864     return;
 865
 866   CmdArgs.push_back("-force_load");
 867   SmallString<128> P(getDriver().ClangExecutable);
 868   llvm::sys::path::remove_filename(P); // 'clang'
 869   llvm::sys::path::remove_filename(P); // 'bin'
 870   llvm::sys::path::append(P, "lib", "arc", "libarclite_");
 871   // Mash in the platform.
 872   if (isTargetWatchOSSimulator())
 873     P += "watchsimulator";
 874   else if (isTargetWatchOS())
 875     P += "watchos";
 876   else if (isTargetTvOSSimulator())
 877     P += "appletvsimulator";
 878   else if (isTargetTvOS())
 879     P += "appletvos";
 880   else if (isTargetIOSSimulator())
 881     P += "iphonesimulator";
 882   else if (isTargetIPhoneOS())
 883     P += "iphoneos";
 884   else
 885     P += "macosx";
 886   P += ".a";
 887
 888   CmdArgs.push_back(Args.MakeArgString(P));
 889 }
 890
 891 unsigned DarwinClang::GetDefaultDwarfVersion() const {
 892   // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
 893   if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
 894       (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
 895     return 2;
 896   return 4;
 897 }
 898
 899 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
 900                               StringRef DarwinLibName, bool AlwaysLink,
 901                               bool IsEmbedded, bool AddRPath) const {
 902   SmallString<128> Dir(getDriver().ResourceDir);
 903   llvm::sys::path::append(Dir, "lib", IsEmbedded ? "macho_embedded" : "darwin");
 904
 905   SmallString<128> P(Dir);
 906   llvm::sys::path::append(P, DarwinLibName);
 907
 908   // For now, allow missing resource libraries to support developers who may
 909   // not have compiler-rt checked out or integrated into their build (unless
 910   // we explicitly force linking with this library).
 911   if (AlwaysLink || getVFS().exists(P))
 912     CmdArgs.push_back(Args.MakeArgString(P));
 913
 914   // Adding the rpaths might negatively interact when other rpaths are involved,
 915   // so we should make sure we add the rpaths last, after all user-specified
 916   // rpaths. This is currently true from this place, but we need to be
 917   // careful if this function is ever called before user's rpaths are emitted.
 918   if (AddRPath) {
 919     assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
 920
 921     // Add @executable_path to rpath to support having the dylib copied with
 922     // the executable.
 923     CmdArgs.push_back("-rpath");
 924     CmdArgs.push_back("@executable_path");
 925
 926     // Add the path to the resource dir to rpath to support using the dylib
 927     // from the default location without copying.
 928     CmdArgs.push_back("-rpath");
 929     CmdArgs.push_back(Args.MakeArgString(Dir));
 930   }
 931 }
 932
 933 void MachO::AddFuzzerLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
 934
 935   // Go up one directory from Clang to find the libfuzzer archive file.
 936   StringRef ParentDir = llvm::sys::path::parent_path(getDriver().InstalledDir);
 937   SmallString<128> P(ParentDir);
 938   llvm::sys::path::append(P, "lib", "libLLVMFuzzer.a");
 939   CmdArgs.push_back(Args.MakeArgString(P));
 940
 941   // Libfuzzer is written in C++ and requires libcxx.
 942   AddCXXStdlibLibArgs(Args, CmdArgs);
 943 }
 944
 945 StringRef Darwin::getPlatformFamily() const {
 946   switch (TargetPlatform) {
 947     case DarwinPlatformKind::MacOS:
 948       return "MacOSX";
 949     case DarwinPlatformKind::IPhoneOS:
 950     case DarwinPlatformKind::IPhoneOSSimulator:
 951       return "iPhone";
 952     case DarwinPlatformKind::TvOS:
 953     case DarwinPlatformKind::TvOSSimulator:
 954       return "AppleTV";
 955     case DarwinPlatformKind::WatchOS:
 956     case DarwinPlatformKind::WatchOSSimulator:
 957       return "Watch";
 958   }
 959   llvm_unreachable("Unsupported platform");
 960 }
 961
 962 StringRef Darwin::getSDKName(StringRef isysroot) {
 963   // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
 964   llvm::sys::path::const_iterator SDKDir;
 965   auto BeginSDK = llvm::sys::path::begin(isysroot);
 966   auto EndSDK = llvm::sys::path::end(isysroot);
 967   for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
 968     StringRef SDK = *IT;
 969     if (SDK.endswith(".sdk"))
 970       return SDK.slice(0, SDK.size() - 4);
 971   }
 972   return "";
 973 }
 974
 975 StringRef Darwin::getOSLibraryNameSuffix() const {
 976   switch(TargetPlatform) {
 977   case DarwinPlatformKind::MacOS:
 978     return "osx";
 979   case DarwinPlatformKind::IPhoneOS:
 980     return "ios";
 981   case DarwinPlatformKind::IPhoneOSSimulator:
 982     return "iossim";
 983   case DarwinPlatformKind::TvOS:
 984     return "tvos";
 985   case DarwinPlatformKind::TvOSSimulator:
 986     return "tvossim";
 987   case DarwinPlatformKind::WatchOS:
 988     return "watchos";
 989   case DarwinPlatformKind::WatchOSSimulator:
 990     return "watchossim";
 991   }
 992   llvm_unreachable("Unsupported platform");
 993 }
 994
 995 void Darwin::addProfileRTLibs(const ArgList &Args,
 996                               ArgStringList &CmdArgs) const {
 997   if (!needsProfileRT(Args)) return;
 998
 999   AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") +
1000        getOSLibraryNameSuffix() + ".a").str(),
1001                     /*AlwaysLink*/ true);
1002 }
1003
1004 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1005                                           ArgStringList &CmdArgs,
1006                                           StringRef Sanitizer) const {
1007   AddLinkRuntimeLib(
1008       Args, CmdArgs,
1009       (Twine("libclang_rt.") + Sanitizer + "_" +
1010        getOSLibraryNameSuffix() + "_dynamic.dylib").str(),
1011       /*AlwaysLink*/ true, /*IsEmbedded*/ false,
1012       /*AddRPath*/ true);
1013 }
1014
1015 ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType(
1016     const ArgList &Args) const {
1017   if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1018     StringRef Value = A->getValue();
1019     if (Value != "compiler-rt")
1020       getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1021           << Value << "darwin";
1022   }
1023
1024   return ToolChain::RLT_CompilerRT;
1025 }
1026
1027 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1028                                         ArgStringList &CmdArgs) const {
1029   // Call once to ensure diagnostic is printed if wrong value was specified
1030   GetRuntimeLibType(Args);
1031
1032   // Darwin doesn't support real static executables, don't link any runtime
1033   // libraries with -static.
1034   if (Args.hasArg(options::OPT_static) ||
1035       Args.hasArg(options::OPT_fapple_kext) ||
1036       Args.hasArg(options::OPT_mkernel))
1037     return;
1038
1039   // Reject -static-libgcc for now, we can deal with this when and if someone
1040   // cares. This is useful in situations where someone wants to statically link
1041   // something like libstdc++, and needs its runtime support routines.
1042   if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1043     getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1044     return;
1045   }
1046
1047   const SanitizerArgs &Sanitize = getSanitizerArgs();
1048   if (Sanitize.needsAsanRt())
1049     AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1050   if (Sanitize.needsLsanRt())
1051     AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1052   if (Sanitize.needsUbsanRt())
1053     AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
1054   if (Sanitize.needsTsanRt())
1055     AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1056   if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib))
1057     AddFuzzerLinkArgs(Args, CmdArgs);
1058   if (Sanitize.needsStatsRt()) {
1059     StringRef OS = isTargetMacOS() ? "osx" : "iossim";
1060     AddLinkRuntimeLib(Args, CmdArgs,
1061                       (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
1062                       /*AlwaysLink=*/true);
1063     AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1064   }
1065   if (Sanitize.needsEsanRt())
1066     AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
1067
1068   // Otherwise link libSystem, then the dynamic runtime library, and finally any
1069   // target specific static runtime library.
1070   CmdArgs.push_back("-lSystem");
1071
1072   // Select the dynamic runtime library and the target specific static library.
1073   if (isTargetWatchOSBased()) {
1074     // We currently always need a static runtime library for watchOS.
1075     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
1076   } else if (isTargetTvOSBased()) {
1077     // We currently always need a static runtime library for tvOS.
1078     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
1079   } else if (isTargetIOSBased()) {
1080     // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1081     // it never went into the SDK.
1082     // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1083     if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1084         getTriple().getArch() != llvm::Triple::aarch64)
1085       CmdArgs.push_back("-lgcc_s.1");
1086
1087     // We currently always need a static runtime library for iOS.
1088     AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
1089   } else {
1090     assert(isTargetMacOS() && "unexpected non MacOS platform");
1091     // The dynamic runtime library was merged with libSystem for 10.6 and
1092     // beyond; only 10.4 and 10.5 need an additional runtime library.
1093     if (isMacosxVersionLT(10, 5))
1094       CmdArgs.push_back("-lgcc_s.10.4");
1095     else if (isMacosxVersionLT(10, 6))
1096       CmdArgs.push_back("-lgcc_s.10.5");
1097
1098     // Originally for OS X, we thought we would only need a static runtime
1099     // library when targeting 10.4, to provide versions of the static functions
1100     // which were omitted from 10.4.dylib. This led to the creation of the 10.4
1101     // builtins library.
1102     //
1103     // Unfortunately, that turned out to not be true, because Darwin system
1104     // headers can still use eprintf on i386, and it is not exported from
1105     // libSystem. Therefore, we still must provide a runtime library just for
1106     // the tiny tiny handful of projects that *might* use that symbol.
1107     //
1108     // Then over time, we figured out it was useful to add more things to the
1109     // runtime so we created libclang_rt.osx.a to provide new functions when
1110     // deploying to old OS builds, and for a long time we had both eprintf and
1111     // osx builtin libraries. Which just seems excessive. So with PR 28855, we
1112     // are removing the eprintf library and expecting eprintf to be provided by
1113     // the OS X builtins library.
1114     if (isMacosxVersionLT(10, 5))
1115       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
1116     else
1117       AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
1118   }
1119 }
1120
1121 /// Returns the most appropriate macOS target version for the current process.
1122 ///
1123 /// If the macOS SDK version is the same or earlier than the system version,
1124 /// then the SDK version is returned. Otherwise the system version is returned.
1125 static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
1126   unsigned Major, Minor, Micro;
1127   llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1128   if (!SystemTriple.isMacOSX())
1129     return MacOSSDKVersion;
1130   SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1131   VersionTuple SystemVersion(Major, Minor, Micro);
1132   bool HadExtra;
1133   if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1134                                  HadExtra))
1135     return MacOSSDKVersion;
1136   VersionTuple SDKVersion(Major, Minor, Micro);
1137   if (SDKVersion > SystemVersion)
1138     return SystemVersion.getAsString();
1139   return MacOSSDKVersion;
1140 }
1141
1142 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
1143   const OptTable &Opts = getDriver().getOpts();
1144
1145   // Support allowing the SDKROOT environment variable used by xcrun and other
1146   // Xcode tools to define the default sysroot, by making it the default for
1147   // isysroot.
1148   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1149     // Warn if the path does not exist.
1150     if (!getVFS().exists(A->getValue()))
1151       getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1152   } else {
1153     if (char *env = ::getenv("SDKROOT")) {
1154       // We only use this value as the default if it is an absolute path,
1155       // exists, and it is not the root path.
1156       if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
1157           StringRef(env) != "/") {
1158         Args.append(Args.MakeSeparateArg(
1159             nullptr, Opts.getOption(options::OPT_isysroot), env));
1160       }
1161     }
1162   }
1163
1164   Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1165   Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1166                                     options::OPT_mios_simulator_version_min_EQ);
1167   Arg *TvOSVersion =
1168       Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1169                       options::OPT_mtvos_simulator_version_min_EQ);
1170   Arg *WatchOSVersion =
1171       Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1172                       options::OPT_mwatchos_simulator_version_min_EQ);
1173
1174   unsigned Major, Minor, Micro;
1175   bool HadExtra;
1176
1177   // The iOS deployment target that is explicitly specified via a command line
1178   // option or an environment variable.
1179   std::string ExplicitIOSDeploymentTargetStr;
1180
1181   if (iOSVersion)
1182     ExplicitIOSDeploymentTargetStr = iOSVersion->getAsString(Args);
1183
1184   // Add a macro to differentiate between m(iphone|tv|watch)os-version-min=X.Y and
1185   // -m(iphone|tv|watch)simulator-version-min=X.Y.
1186   if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ) ||
1187       Args.hasArg(options::OPT_mtvos_simulator_version_min_EQ) ||
1188       Args.hasArg(options::OPT_mwatchos_simulator_version_min_EQ))
1189     Args.append(Args.MakeSeparateArg(nullptr, Opts.getOption(options::OPT_D),
1190                                      " __APPLE_EMBEDDED_SIMULATOR__=1"));
1191
1192   if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
1193     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1194         << OSXVersion->getAsString(Args)
1195         << (iOSVersion ? iOSVersion :
1196             TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1197     iOSVersion = TvOSVersion = WatchOSVersion = nullptr;
1198   } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
1199     getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1200         << iOSVersion->getAsString(Args)
1201         << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1202     TvOSVersion = WatchOSVersion = nullptr;
1203   } else if (TvOSVersion && WatchOSVersion) {
1204      getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1205         << TvOSVersion->getAsString(Args)
1206         << WatchOSVersion->getAsString(Args);
1207     WatchOSVersion = nullptr;
1208   } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
1209     // If no deployment target was specified on the command line, check for
1210     // environment defines.
1211     std::string OSXTarget;
1212     std::string iOSTarget;
1213     std::string TvOSTarget;
1214     std::string WatchOSTarget;
1215
1216     if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
1217       OSXTarget = env;
1218     if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
1219       iOSTarget = env;
1220     if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET"))
1221       TvOSTarget = env;
1222     if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET"))
1223       WatchOSTarget = env;
1224
1225     if (!iOSTarget.empty())
1226       ExplicitIOSDeploymentTargetStr =
1227           std::string("IPHONEOS_DEPLOYMENT_TARGET=") + iOSTarget;
1228
1229     // If there is no command-line argument to specify the Target version and
1230     // no environment variable defined, see if we can set the default based
1231     // on -isysroot.
1232     if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
1233         TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
1234       if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1235         StringRef isysroot = A->getValue();
1236         StringRef SDK = getSDKName(isysroot);
1237         if (SDK.size() > 0) {
1238           // Slice the version number out.
1239           // Version number is between the first and the last number.
1240           size_t StartVer = SDK.find_first_of("0123456789");
1241           size_t EndVer = SDK.find_last_of("0123456789");
1242           if (StartVer != StringRef::npos && EndVer > StartVer) {
1243             StringRef Version = SDK.slice(StartVer, EndVer + 1);
1244             if (SDK.startswith("iPhoneOS") ||
1245                 SDK.startswith("iPhoneSimulator"))
1246               iOSTarget = Version;
1247             else if (SDK.startswith("MacOSX"))
1248               OSXTarget = getSystemOrSDKMacOSVersion(Version);
1249             else if (SDK.startswith("WatchOS") ||
1250                      SDK.startswith("WatchSimulator"))
1251               WatchOSTarget = Version;
1252             else if (SDK.startswith("AppleTVOS") ||
1253                      SDK.startswith("AppleTVSimulator"))
1254               TvOSTarget = Version;
1255           }
1256         }
1257       }
1258     }
1259
1260     // If no OS targets have been specified, try to guess platform from -target
1261     // or arch name and compute the version from the triple.
1262     if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
1263         WatchOSTarget.empty()) {
1264       llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1265
1266       // Set the OSTy based on -target if -arch isn't present.
1267       if (Args.hasArg(options::OPT_target) && !Args.hasArg(options::OPT_arch)) {
1268         OSTy = getTriple().getOS();
1269       } else {
1270         StringRef MachOArchName = getMachOArchName(Args);
1271         if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
1272             MachOArchName == "arm64")
1273           OSTy = llvm::Triple::IOS;
1274         else if (MachOArchName == "armv7k")
1275           OSTy = llvm::Triple::WatchOS;
1276         else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
1277                  MachOArchName != "armv7em")
1278           OSTy = llvm::Triple::MacOSX;
1279       }
1280
1281
1282       if (OSTy != llvm::Triple::UnknownOS) {
1283         unsigned Major, Minor, Micro;
1284         std::string *OSTarget;
1285
1286         switch (OSTy) {
1287         case llvm::Triple::Darwin:
1288         case llvm::Triple::MacOSX:
1289           if (!getTriple().getMacOSXVersion(Major, Minor, Micro))
1290             getDriver().Diag(diag::err_drv_invalid_darwin_version)
1291                 << getTriple().getOSName();
1292           OSTarget = &OSXTarget;
1293           break;
1294         case llvm::Triple::IOS:
1295           getTriple().getiOSVersion(Major, Minor, Micro);
1296           OSTarget = &iOSTarget;
1297           break;
1298         case llvm::Triple::TvOS:
1299           getTriple().getOSVersion(Major, Minor, Micro);
1300           OSTarget = &TvOSTarget;
1301           break;
1302         case llvm::Triple::WatchOS:
1303           getTriple().getWatchOSVersion(Major, Minor, Micro);
1304           OSTarget = &WatchOSTarget;
1305           break;
1306         default:
1307           llvm_unreachable("Unexpected OS type");
1308           break;
1309         }
1310
1311         llvm::raw_string_ostream(*OSTarget) << Major << '.' << Minor << '.'
1312                                             << Micro;
1313       }
1314     }
1315
1316     // Do not allow conflicts with the watchOS target.
1317     if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
1318       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
1319         << "WATCHOS_DEPLOYMENT_TARGET"
1320         << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" :
1321             "TVOS_DEPLOYMENT_TARGET");
1322     }
1323
1324     // Do not allow conflicts with the tvOS target.
1325     if (!TvOSTarget.empty() && !iOSTarget.empty()) {
1326       getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
1327         << "TVOS_DEPLOYMENT_TARGET"
1328         << "IPHONEOS_DEPLOYMENT_TARGET";
1329     }
1330
1331     // Allow conflicts among OSX and iOS for historical reasons, but choose the
1332     // default platform.
1333     if (!OSXTarget.empty() && (!iOSTarget.empty() ||
1334                                !WatchOSTarget.empty() ||
1335                                !TvOSTarget.empty())) {
1336       if (getTriple().getArch() == llvm::Triple::arm ||
1337           getTriple().getArch() == llvm::Triple::aarch64 ||
1338           getTriple().getArch() == llvm::Triple::thumb)
1339         OSXTarget = "";
1340       else
1341         iOSTarget = WatchOSTarget = TvOSTarget = "";
1342     }
1343
1344     if (!OSXTarget.empty()) {
1345       const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
1346       OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
1347       Args.append(OSXVersion);
1348     } else if (!iOSTarget.empty()) {
1349       const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
1350       iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
1351       Args.append(iOSVersion);
1352     } else if (!TvOSTarget.empty()) {
1353       const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
1354       TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget);
1355       Args.append(TvOSVersion);
1356     } else if (!WatchOSTarget.empty()) {
1357       const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
1358       WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget);
1359       Args.append(WatchOSVersion);
1360     }
1361   }
1362
1363   DarwinPlatformKind Platform;
1364   if (OSXVersion)
1365     Platform = MacOS;
1366   else if (iOSVersion)
1367     Platform = IPhoneOS;
1368   else if (TvOSVersion)
1369     Platform = TvOS;
1370   else if (WatchOSVersion)
1371     Platform = WatchOS;
1372   else
1373     llvm_unreachable("Unable to infer Darwin variant");
1374
1375   // Set the tool chain target information.
1376   if (Platform == MacOS) {
1377     assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
1378            "Unknown target platform!");
1379     if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
1380                                    HadExtra) ||
1381         HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1382       getDriver().Diag(diag::err_drv_invalid_version_number)
1383           << OSXVersion->getAsString(Args);
1384   } else if (Platform == IPhoneOS) {
1385     assert(iOSVersion && "Unknown target platform!");
1386     if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
1387                                    HadExtra) ||
1388         HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1389       getDriver().Diag(diag::err_drv_invalid_version_number)
1390           << iOSVersion->getAsString(Args);
1391     // For 32-bit targets, the deployment target for iOS has to be earlier than
1392     // iOS 11.
1393     if (getTriple().isArch32Bit() && Major >= 11) {
1394       // If the deployment target is explicitly specified, print a diagnostic.
1395       if (!ExplicitIOSDeploymentTargetStr.empty()) {
1396         getDriver().Diag(diag::warn_invalid_ios_deployment_target)
1397             << ExplicitIOSDeploymentTargetStr;
1398       // Otherwise, set it to 10.99.99.
1399       } else {
1400         Major = 10;
1401         Minor = 99;
1402         Micro = 99;
1403       }
1404     }
1405   } else if (Platform == TvOS) {
1406     if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
1407                                    Micro, HadExtra) || HadExtra ||
1408         Major >= 100 || Minor >= 100 || Micro >= 100)
1409       getDriver().Diag(diag::err_drv_invalid_version_number)
1410           << TvOSVersion->getAsString(Args);
1411   } else if (Platform == WatchOS) {
1412     if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
1413                                    Micro, HadExtra) || HadExtra ||
1414         Major >= 10 || Minor >= 100 || Micro >= 100)
1415       getDriver().Diag(diag::err_drv_invalid_version_number)
1416           << WatchOSVersion->getAsString(Args);
1417   } else
1418     llvm_unreachable("unknown kind of Darwin platform");
1419
1420   // Recognize iOS targets with an x86 architecture as the iOS simulator.
1421   if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1422                      getTriple().getArch() == llvm::Triple::x86_64))
1423     Platform = IPhoneOSSimulator;
1424   if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1425                       getTriple().getArch() == llvm::Triple::x86_64))
1426     Platform = TvOSSimulator;
1427   if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1428                          getTriple().getArch() == llvm::Triple::x86_64))
1429     Platform = WatchOSSimulator;
1430
1431   setTarget(Platform, Major, Minor, Micro);
1432
1433   if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1434     StringRef SDK = getSDKName(A->getValue());
1435     if (SDK.size() > 0) {
1436       size_t StartVer = SDK.find_first_of("0123456789");
1437       StringRef SDKName = SDK.slice(0, StartVer);
1438       if (!SDKName.startswith(getPlatformFamily()))
1439         getDriver().Diag(diag::warn_incompatible_sysroot)
1440             << SDKName << getPlatformFamily();
1441     }
1442   }
1443 }
1444
1445 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
1446                                       ArgStringList &CmdArgs) const {
1447   CXXStdlibType Type = GetCXXStdlibType(Args);
1448
1449   switch (Type) {
1450   case ToolChain::CST_Libcxx:
1451     CmdArgs.push_back("-lc++");
1452     break;
1453
1454   case ToolChain::CST_Libstdcxx:
1455     // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
1456     // it was previously found in the gcc lib dir. However, for all the Darwin
1457     // platforms we care about it was -lstdc++.6, so we search for that
1458     // explicitly if we can't see an obvious -lstdc++ candidate.
1459
1460     // Check in the sysroot first.
1461     if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1462       SmallString<128> P(A->getValue());
1463       llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
1464
1465       if (!getVFS().exists(P)) {
1466         llvm::sys::path::remove_filename(P);
1467         llvm::sys::path::append(P, "libstdc++.6.dylib");
1468         if (getVFS().exists(P)) {
1469           CmdArgs.push_back(Args.MakeArgString(P));
1470           return;
1471         }
1472       }
1473     }
1474
1475     // Otherwise, look in the root.
1476     // FIXME: This should be removed someday when we don't have to care about
1477     // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
1478     if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
1479         getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
1480       CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
1481       return;
1482     }
1483
1484     // Otherwise, let the linker search.
1485     CmdArgs.push_back("-lstdc++");
1486     break;
1487   }
1488 }
1489
1490 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
1491                                    ArgStringList &CmdArgs) const {
1492   // For Darwin platforms, use the compiler-rt-based support library
1493   // instead of the gcc-provided one (which is also incidentally
1494   // only present in the gcc lib dir, which makes it hard to find).
1495
1496   SmallString<128> P(getDriver().ResourceDir);
1497   llvm::sys::path::append(P, "lib", "darwin");
1498
1499   // Use the newer cc_kext for iOS ARM after 6.0.
1500   if (isTargetWatchOS()) {
1501     llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
1502   } else if (isTargetTvOS()) {
1503     llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
1504   } else if (isTargetIPhoneOS()) {
1505     llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
1506   } else {
1507     llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
1508   }
1509
1510   // For now, allow missing resource libraries to support developers who may
1511   // not have compiler-rt checked out or integrated into their build.
1512   if (getVFS().exists(P))
1513     CmdArgs.push_back(Args.MakeArgString(P));
1514 }
1515
1516 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
1517                                      StringRef BoundArch,
1518                                      Action::OffloadKind) const {
1519   DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1520   const OptTable &Opts = getDriver().getOpts();
1521
1522   // FIXME: We really want to get out of the tool chain level argument
1523   // translation business, as it makes the driver functionality much
1524   // more opaque. For now, we follow gcc closely solely for the
1525   // purpose of easily achieving feature parity & testability. Once we
1526   // have something that works, we should reevaluate each translation
1527   // and try to push it down into tool specific logic.
1528
1529   for (Arg *A : Args) {
1530     if (A->getOption().matches(options::OPT_Xarch__)) {
1531       // Skip this argument unless the architecture matches either the toolchain
1532       // triple arch, or the arch being bound.
1533       llvm::Triple::ArchType XarchArch =
1534           tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
1535       if (!(XarchArch == getArch() ||
1536             (!BoundArch.empty() &&
1537              XarchArch ==
1538                  tools::darwin::getArchTypeForMachOArchName(BoundArch))))
1539         continue;
1540
1541       Arg *OriginalArg = A;
1542       unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1543       unsigned Prev = Index;
1544       std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1545
1546       // If the argument parsing failed or more than one argument was
1547       // consumed, the -Xarch_ argument's parameter tried to consume
1548       // extra arguments. Emit an error and ignore.
1549       //
1550       // We also want to disallow any options which would alter the
1551       // driver behavior; that isn't going to work in our model. We
1552       // use isDriverOption() as an approximation, although things
1553       // like -O4 are going to slip through.
1554       if (!XarchArg || Index > Prev + 1) {
1555         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1556             << A->getAsString(Args);
1557         continue;
1558       } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
1559         getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1560             << A->getAsString(Args);
1561         continue;
1562       }
1563
1564       XarchArg->setBaseArg(A);
1565
1566       A = XarchArg.release();
1567       DAL->AddSynthesizedArg(A);
1568
1569       // Linker input arguments require custom handling. The problem is that we
1570       // have already constructed the phase actions, so we can not treat them as
1571       // "input arguments".
1572       if (A->getOption().hasFlag(options::LinkerInput)) {
1573         // Convert the argument into individual Zlinker_input_args.
1574         for (const char *Value : A->getValues()) {
1575           DAL->AddSeparateArg(
1576               OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
1577         }
1578         continue;
1579       }
1580     }
1581
1582     // Sob. These is strictly gcc compatible for the time being. Apple
1583     // gcc translates options twice, which means that self-expanding
1584     // options add duplicates.
1585     switch ((options::ID)A->getOption().getID()) {
1586     default:
1587       DAL->append(A);
1588       break;
1589
1590     case options::OPT_mkernel:
1591     case options::OPT_fapple_kext:
1592       DAL->append(A);
1593       DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1594       break;
1595
1596     case options::OPT_dependency_file:
1597       DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1598       break;
1599
1600     case options::OPT_gfull:
1601       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1602       DAL->AddFlagArg(
1603           A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1604       break;
1605
1606     case options::OPT_gused:
1607       DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1608       DAL->AddFlagArg(
1609           A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1610       break;
1611
1612     case options::OPT_shared:
1613       DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1614       break;
1615
1616     case options::OPT_fconstant_cfstrings:
1617       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1618       break;
1619
1620     case options::OPT_fno_constant_cfstrings:
1621       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1622       break;
1623
1624     case options::OPT_Wnonportable_cfstrings:
1625       DAL->AddFlagArg(A,
1626                       Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1627       break;
1628
1629     case options::OPT_Wno_nonportable_cfstrings:
1630       DAL->AddFlagArg(
1631           A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1632       break;
1633
1634     case options::OPT_fpascal_strings:
1635       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1636       break;
1637
1638     case options::OPT_fno_pascal_strings:
1639       DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1640       break;
1641     }
1642   }
1643
1644   if (getTriple().getArch() == llvm::Triple::x86 ||
1645       getTriple().getArch() == llvm::Triple::x86_64)
1646     if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1647       DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
1648                         "core2");
1649
1650   // Add the arch options based on the particular spelling of -arch, to match
1651   // how the driver driver works.
1652   if (!BoundArch.empty()) {
1653     StringRef Name = BoundArch;
1654     const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1655     const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1656
1657     // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
1658     // which defines the list of which architectures we accept.
1659     if (Name == "ppc")
1660       ;
1661     else if (Name == "ppc601")
1662       DAL->AddJoinedArg(nullptr, MCpu, "601");
1663     else if (Name == "ppc603")
1664       DAL->AddJoinedArg(nullptr, MCpu, "603");
1665     else if (Name == "ppc604")
1666       DAL->AddJoinedArg(nullptr, MCpu, "604");
1667     else if (Name == "ppc604e")
1668       DAL->AddJoinedArg(nullptr, MCpu, "604e");
1669     else if (Name == "ppc750")
1670       DAL->AddJoinedArg(nullptr, MCpu, "750");
1671     else if (Name == "ppc7400")
1672       DAL->AddJoinedArg(nullptr, MCpu, "7400");
1673     else if (Name == "ppc7450")
1674       DAL->AddJoinedArg(nullptr, MCpu, "7450");
1675     else if (Name == "ppc970")
1676       DAL->AddJoinedArg(nullptr, MCpu, "970");
1677
1678     else if (Name == "ppc64" || Name == "ppc64le")
1679       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1680
1681     else if (Name == "i386")
1682       ;
1683     else if (Name == "i486")
1684       DAL->AddJoinedArg(nullptr, MArch, "i486");
1685     else if (Name == "i586")
1686       DAL->AddJoinedArg(nullptr, MArch, "i586");
1687     else if (Name == "i686")
1688       DAL->AddJoinedArg(nullptr, MArch, "i686");
1689     else if (Name == "pentium")
1690       DAL->AddJoinedArg(nullptr, MArch, "pentium");
1691     else if (Name == "pentium2")
1692       DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1693     else if (Name == "pentpro")
1694       DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
1695     else if (Name == "pentIIm3")
1696       DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1697
1698     else if (Name == "x86_64")
1699       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1700     else if (Name == "x86_64h") {
1701       DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1702       DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
1703     }
1704
1705     else if (Name == "arm")
1706       DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1707     else if (Name == "armv4t")
1708       DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1709     else if (Name == "armv5")
1710       DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
1711     else if (Name == "xscale")
1712       DAL->AddJoinedArg(nullptr, MArch, "xscale");
1713     else if (Name == "armv6")
1714       DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1715     else if (Name == "armv6m")
1716       DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1717     else if (Name == "armv7")
1718       DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1719     else if (Name == "armv7em")
1720       DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1721     else if (Name == "armv7k")
1722       DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1723     else if (Name == "armv7m")
1724       DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1725     else if (Name == "armv7s")
1726       DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1727   }
1728
1729   return DAL;
1730 }
1731
1732 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1733                                   ArgStringList &CmdArgs) const {
1734   // Embedded targets are simple at the moment, not supporting sanitizers and
1735   // with different libraries for each member of the product { static, PIC } x
1736   // { hard-float, soft-float }
1737   llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1738   CompilerRT +=
1739       (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
1740           ? "hard"
1741           : "soft";
1742   CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1743
1744   AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
1745 }
1746
1747 bool Darwin::isAlignedAllocationUnavailable() const {
1748   switch (TargetPlatform) {
1749   case MacOS: // Earlier than 10.13.
1750     return TargetVersion < VersionTuple(10U, 13U, 0U);
1751   case IPhoneOS:
1752   case IPhoneOSSimulator:
1753   case TvOS:
1754   case TvOSSimulator: // Earlier than 11.0.
1755     return TargetVersion < VersionTuple(11U, 0U, 0U);
1756   case WatchOS:
1757   case WatchOSSimulator: // Earlier than 4.0.
1758     return TargetVersion < VersionTuple(4U, 0U, 0U);
1759   }
1760   llvm_unreachable("Unsupported platform");
1761 }
1762
1763 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1764                                    llvm::opt::ArgStringList &CC1Args,
1765                                    Action::OffloadKind DeviceOffloadKind) const {
1766   if (isAlignedAllocationUnavailable())
1767     CC1Args.push_back("-faligned-alloc-unavailable");
1768 }
1769
1770 DerivedArgList *
1771 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
1772                       Action::OffloadKind DeviceOffloadKind) const {
1773   // First get the generic Apple args, before moving onto Darwin-specific ones.
1774   DerivedArgList *DAL =
1775       MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
1776   const OptTable &Opts = getDriver().getOpts();
1777
1778   // If no architecture is bound, none of the translations here are relevant.
1779   if (BoundArch.empty())
1780     return DAL;
1781
1782   // Add an explicit version min argument for the deployment target. We do this
1783   // after argument translation because -Xarch_ arguments may add a version min
1784   // argument.
1785   AddDeploymentTarget(*DAL);
1786
1787   // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1788   // FIXME: It would be far better to avoid inserting those -static arguments,
1789   // but we can't check the deployment target in the translation code until
1790   // it is set here.
1791   if (isTargetWatchOSBased() ||
1792       (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1793     for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1794       Arg *A = *it;
1795       ++it;
1796       if (A->getOption().getID() != options::OPT_mkernel &&
1797           A->getOption().getID() != options::OPT_fapple_kext)
1798         continue;
1799       assert(it != ie && "unexpected argument translation");
1800       A = *it;
1801       assert(A->getOption().getID() == options::OPT_static &&
1802              "missing expected -static argument");
1803       *it = nullptr;
1804       ++it;
1805     }
1806   }
1807
1808   if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1809       GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
1810     DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1811                       "libc++");
1812
1813   // Validate the C++ standard library choice.
1814   CXXStdlibType Type = GetCXXStdlibType(*DAL);
1815   if (Type == ToolChain::CST_Libcxx) {
1816     // Check whether the target provides libc++.
1817     StringRef where;
1818
1819     // Complain about targeting iOS < 5.0 in any way.
1820     if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1821       where = "iOS 5.0";
1822
1823     if (where != StringRef()) {
1824       getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1825     }
1826   }
1827
1828   auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
1829   if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
1830     if (Args.hasFlag(options::OPT_fomit_frame_pointer,
1831                      options::OPT_fno_omit_frame_pointer, false))
1832       getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
1833           << "-fomit-frame-pointer" << BoundArch;
1834   }
1835
1836   return DAL;
1837 }
1838
1839 bool MachO::IsUnwindTablesDefault(const ArgList &Args) const {
1840   // Unwind tables are not emitted if -fno-exceptions is supplied (except when
1841   // targeting x86_64).
1842   return getArch() == llvm::Triple::x86_64 ||
1843          (!UseSjLjExceptions(Args) &&
1844           Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
1845                        true));
1846 }
1847
1848 bool MachO::UseDwarfDebugFlags() const {
1849   if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1850     return S[0] != '\0';
1851   return false;
1852 }
1853
1854 bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
1855   // Darwin uses SjLj exceptions on ARM.
1856   if (getTriple().getArch() != llvm::Triple::arm &&
1857       getTriple().getArch() != llvm::Triple::thumb)
1858     return false;
1859
1860   // Only watchOS uses the new DWARF/Compact unwinding method.
1861   llvm::Triple Triple(ComputeLLVMTriple(Args));
1862   return !Triple.isWatchABI();
1863 }
1864
1865 bool Darwin::SupportsEmbeddedBitcode() const {
1866   assert(TargetInitialized && "Target not initialized!");
1867   if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
1868     return false;
1869   return true;
1870 }
1871
1872 bool MachO::isPICDefault() const { return true; }
1873
1874 bool MachO::isPIEDefault() const { return false; }
1875
1876 bool MachO::isPICDefaultForced() const {
1877   return (getArch() == llvm::Triple::x86_64 ||
1878           getArch() == llvm::Triple::aarch64);
1879 }
1880
1881 bool MachO::SupportsProfiling() const {
1882   // Profiling instrumentation is only supported on x86.
1883   return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
1884 }
1885
1886 void Darwin::addMinVersionArgs(const ArgList &Args,
1887                                ArgStringList &CmdArgs) const {
1888   VersionTuple TargetVersion = getTargetVersion();
1889
1890   if (isTargetWatchOS())
1891     CmdArgs.push_back("-watchos_version_min");
1892   else if (isTargetWatchOSSimulator())
1893     CmdArgs.push_back("-watchos_simulator_version_min");
1894   else if (isTargetTvOS())
1895     CmdArgs.push_back("-tvos_version_min");
1896   else if (isTargetTvOSSimulator())
1897     CmdArgs.push_back("-tvos_simulator_version_min");
1898   else if (isTargetIOSSimulator())
1899     CmdArgs.push_back("-ios_simulator_version_min");
1900   else if (isTargetIOSBased())
1901     CmdArgs.push_back("-iphoneos_version_min");
1902   else {
1903     assert(isTargetMacOS() && "unexpected target");
1904     CmdArgs.push_back("-macosx_version_min");
1905   }
1906
1907   CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
1908 }
1909
1910 void Darwin::addStartObjectFileArgs(const ArgList &Args,
1911                                     ArgStringList &CmdArgs) const {
1912   // Derived from startfile spec.
1913   if (Args.hasArg(options::OPT_dynamiclib)) {
1914     // Derived from darwin_dylib1 spec.
1915     if (isTargetWatchOSBased()) {
1916       ; // watchOS does not need dylib1.o.
1917     } else if (isTargetIOSSimulator()) {
1918       ; // iOS simulator does not need dylib1.o.
1919     } else if (isTargetIPhoneOS()) {
1920       if (isIPhoneOSVersionLT(3, 1))
1921         CmdArgs.push_back("-ldylib1.o");
1922     } else {
1923       if (isMacosxVersionLT(10, 5))
1924         CmdArgs.push_back("-ldylib1.o");
1925       else if (isMacosxVersionLT(10, 6))
1926         CmdArgs.push_back("-ldylib1.10.5.o");
1927     }
1928   } else {
1929     if (Args.hasArg(options::OPT_bundle)) {
1930       if (!Args.hasArg(options::OPT_static)) {
1931         // Derived from darwin_bundle1 spec.
1932         if (isTargetWatchOSBased()) {
1933           ; // watchOS does not need bundle1.o.
1934         } else if (isTargetIOSSimulator()) {
1935           ; // iOS simulator does not need bundle1.o.
1936         } else if (isTargetIPhoneOS()) {
1937           if (isIPhoneOSVersionLT(3, 1))
1938             CmdArgs.push_back("-lbundle1.o");
1939         } else {
1940           if (isMacosxVersionLT(10, 6))
1941             CmdArgs.push_back("-lbundle1.o");
1942         }
1943       }
1944     } else {
1945       if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
1946         if (Args.hasArg(options::OPT_static) ||
1947             Args.hasArg(options::OPT_object) ||
1948             Args.hasArg(options::OPT_preload)) {
1949           CmdArgs.push_back("-lgcrt0.o");
1950         } else {
1951           CmdArgs.push_back("-lgcrt1.o");
1952
1953           // darwin_crt2 spec is empty.
1954         }
1955         // By default on OS X 10.8 and later, we don't link with a crt1.o
1956         // file and the linker knows to use _main as the entry point.  But,
1957         // when compiling with -pg, we need to link with the gcrt1.o file,
1958         // so pass the -no_new_main option to tell the linker to use the
1959         // "start" symbol as the entry point.
1960         if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1961           CmdArgs.push_back("-no_new_main");
1962       } else {
1963         if (Args.hasArg(options::OPT_static) ||
1964             Args.hasArg(options::OPT_object) ||
1965             Args.hasArg(options::OPT_preload)) {
1966           CmdArgs.push_back("-lcrt0.o");
1967         } else {
1968           // Derived from darwin_crt1 spec.
1969           if (isTargetWatchOSBased()) {
1970             ; // watchOS does not need crt1.o.
1971           } else if (isTargetIOSSimulator()) {
1972             ; // iOS simulator does not need crt1.o.
1973           } else if (isTargetIPhoneOS()) {
1974             if (getArch() == llvm::Triple::aarch64)
1975               ; // iOS does not need any crt1 files for arm64
1976             else if (isIPhoneOSVersionLT(3, 1))
1977               CmdArgs.push_back("-lcrt1.o");
1978             else if (isIPhoneOSVersionLT(6, 0))
1979               CmdArgs.push_back("-lcrt1.3.1.o");
1980           } else {
1981             if (isMacosxVersionLT(10, 5))
1982               CmdArgs.push_back("-lcrt1.o");
1983             else if (isMacosxVersionLT(10, 6))
1984               CmdArgs.push_back("-lcrt1.10.5.o");
1985             else if (isMacosxVersionLT(10, 8))
1986               CmdArgs.push_back("-lcrt1.10.6.o");
1987
1988             // darwin_crt2 spec is empty.
1989           }
1990         }
1991       }
1992     }
1993   }
1994
1995   if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1996       !isTargetWatchOS() &&
1997       isMacosxVersionLT(10, 5)) {
1998     const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1999     CmdArgs.push_back(Str);
2000   }
2001 }
2002
2003 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
2004
2005 void Darwin::CheckObjCARC() const {
2006   if (isTargetIOSBased() || isTargetWatchOSBased() ||
2007       (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
2008     return;
2009   getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
2010 }
2011
2012 SanitizerMask Darwin::getSupportedSanitizers() const {
2013   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2014   SanitizerMask Res = ToolChain::getSupportedSanitizers();
2015   Res |= SanitizerKind::Address;
2016   Res |= SanitizerKind::Leak;
2017   Res |= SanitizerKind::Fuzzer;
2018   if (isTargetMacOS()) {
2019     if (!isMacosxVersionLT(10, 9))
2020       Res |= SanitizerKind::Vptr;
2021     Res |= SanitizerKind::SafeStack;
2022     if (IsX86_64)
2023       Res |= SanitizerKind::Thread;
2024   } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
2025     if (IsX86_64)
2026       Res |= SanitizerKind::Thread;
2027   }
2028   return Res;
2029 }
2030
2031 void Darwin::printVerboseInfo(raw_ostream &OS) const {
2032   CudaInstallation.print(OS);
2033 }