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