clang  6.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(
549  Args.MakeArgString(Twine("-threads=") + llvm::to_string(Parallelism)));
550  }
551 
552  if (getToolChain().ShouldLinkCXXStdlib(Args))
553  getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
554  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
555  // link_ssp spec is empty.
556 
557  // Let the tool chain choose which runtime library to link.
558  getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
559 
560  // No need to do anything for pthreads. Claim argument to avoid warning.
561  Args.ClaimAllArgs(options::OPT_pthread);
562  Args.ClaimAllArgs(options::OPT_pthreads);
563  }
564 
565  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
566  // endfile_spec is empty.
567  }
568 
569  Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
570  Args.AddAllArgs(CmdArgs, options::OPT_F);
571 
572  // -iframework should be forwarded as -F.
573  for (const Arg *A : Args.filtered(options::OPT_iframework))
574  CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
575 
576  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
577  if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
578  if (A->getValue() == StringRef("Accelerate")) {
579  CmdArgs.push_back("-framework");
580  CmdArgs.push_back("Accelerate");
581  }
582  }
583  }
584 
585  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
586  std::unique_ptr<Command> Cmd =
587  llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
588  Cmd->setInputFileList(std::move(InputFileList));
589  C.addCommand(std::move(Cmd));
590 }
591 
593  const InputInfo &Output,
594  const InputInfoList &Inputs,
595  const ArgList &Args,
596  const char *LinkingOutput) const {
597  ArgStringList CmdArgs;
598 
599  CmdArgs.push_back("-create");
600  assert(Output.isFilename() && "Unexpected lipo output.");
601 
602  CmdArgs.push_back("-output");
603  CmdArgs.push_back(Output.getFilename());
604 
605  for (const auto &II : Inputs) {
606  assert(II.isFilename() && "Unexpected lipo input.");
607  CmdArgs.push_back(II.getFilename());
608  }
609 
610  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
611  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
612 }
613 
615  const InputInfo &Output,
616  const InputInfoList &Inputs,
617  const ArgList &Args,
618  const char *LinkingOutput) const {
619  ArgStringList CmdArgs;
620 
621  CmdArgs.push_back("-o");
622  CmdArgs.push_back(Output.getFilename());
623 
624  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
625  const InputInfo &Input = Inputs[0];
626  assert(Input.isFilename() && "Unexpected dsymutil input.");
627  CmdArgs.push_back(Input.getFilename());
628 
629  const char *Exec =
630  Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
631  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
632 }
633 
635  const InputInfo &Output,
636  const InputInfoList &Inputs,
637  const ArgList &Args,
638  const char *LinkingOutput) const {
639  ArgStringList CmdArgs;
640  CmdArgs.push_back("--verify");
641  CmdArgs.push_back("--debug-info");
642  CmdArgs.push_back("--eh-frame");
643  CmdArgs.push_back("--quiet");
644 
645  assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
646  const InputInfo &Input = Inputs[0];
647  assert(Input.isFilename() && "Unexpected verify input");
648 
649  // Grabbing the output of the earlier dsymutil run.
650  CmdArgs.push_back(Input.getFilename());
651 
652  const char *Exec =
653  Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
654  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
655 }
656 
657 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
658  : ToolChain(D, Triple, Args) {
659  // We expect 'as', 'ld', etc. to be adjacent to our install dir.
660  getProgramPaths().push_back(getDriver().getInstalledDir());
661  if (getDriver().getInstalledDir() != getDriver().Dir)
662  getProgramPaths().push_back(getDriver().Dir);
663 }
664 
665 /// Darwin - Darwin tool chain for i386 and x86_64.
666 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
667  : MachO(D, Triple, Args), TargetInitialized(false),
668  CudaInstallation(D, Triple, Args) {}
669 
672 
673  // Darwin always preprocesses assembly files (unless -x is used explicitly).
674  if (Ty == types::TY_PP_Asm)
675  return types::TY_Asm;
676 
677  return Ty;
678 }
679 
680 bool MachO::HasNativeLLVMSupport() const { return true; }
681 
683  // Default to use libc++ on OS X 10.9+ and iOS 7+.
684  if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
685  (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
687  return ToolChain::CST_Libcxx;
688 
690 }
691 
692 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
693 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
694  if (isTargetWatchOSBased())
696  if (isTargetIOSBased())
698  if (isNonFragile)
701 }
702 
703 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
705  if (isTargetWatchOSBased())
706  return true;
707  else if (isTargetIOSBased())
708  return !isIPhoneOSVersionLT(3, 2);
709  else {
710  assert(isTargetMacOS() && "unexpected darwin target");
711  return !isMacosxVersionLT(10, 6);
712  }
713 }
714 
715 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
716  ArgStringList &CC1Args) const {
717  CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
718 }
719 
720 // This is just a MachO name translation routine and there's no
721 // way to join this into ARMTargetParser without breaking all
722 // other assumptions. Maybe MachO should consider standardising
723 // their nomenclature.
724 static const char *ArmMachOArchName(StringRef Arch) {
725  return llvm::StringSwitch<const char *>(Arch)
726  .Case("armv6k", "armv6")
727  .Case("armv6m", "armv6m")
728  .Case("armv5tej", "armv5")
729  .Case("xscale", "xscale")
730  .Case("armv4t", "armv4t")
731  .Case("armv7", "armv7")
732  .Cases("armv7a", "armv7-a", "armv7")
733  .Cases("armv7r", "armv7-r", "armv7")
734  .Cases("armv7em", "armv7e-m", "armv7em")
735  .Cases("armv7k", "armv7-k", "armv7k")
736  .Cases("armv7m", "armv7-m", "armv7m")
737  .Cases("armv7s", "armv7-s", "armv7s")
738  .Default(nullptr);
739 }
740 
741 static const char *ArmMachOArchNameCPU(StringRef CPU) {
742  llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
743  if (ArchKind == llvm::ARM::ArchKind::INVALID)
744  return nullptr;
745  StringRef Arch = llvm::ARM::getArchName(ArchKind);
746 
747  // FIXME: Make sure this MachO triple mangling is really necessary.
748  // ARMv5* normalises to ARMv5.
749  if (Arch.startswith("armv5"))
750  Arch = Arch.substr(0, 5);
751  // ARMv6*, except ARMv6M, normalises to ARMv6.
752  else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
753  Arch = Arch.substr(0, 5);
754  // ARMv7A normalises to ARMv7.
755  else if (Arch.endswith("v7a"))
756  Arch = Arch.substr(0, 5);
757  return Arch.data();
758 }
759 
760 StringRef MachO::getMachOArchName(const ArgList &Args) const {
761  switch (getTriple().getArch()) {
762  default:
764 
765  case llvm::Triple::aarch64:
766  return "arm64";
767 
768  case llvm::Triple::thumb:
769  case llvm::Triple::arm:
770  if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
771  if (const char *Arch = ArmMachOArchName(A->getValue()))
772  return Arch;
773 
774  if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
775  if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
776  return Arch;
777 
778  return "arm";
779  }
780 }
781 
783 
785 
786 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
787  types::ID InputType) const {
788  llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
789 
790  // If the target isn't initialized (e.g., an unknown Darwin platform, return
791  // the default triple).
792  if (!isTargetInitialized())
793  return Triple.getTriple();
794 
795  SmallString<16> Str;
796  if (isTargetWatchOSBased())
797  Str += "watchos";
798  else if (isTargetTvOSBased())
799  Str += "tvos";
800  else if (isTargetIOSBased())
801  Str += "ios";
802  else
803  Str += "macosx";
804  Str += getTargetVersion().getAsString();
805  Triple.setOSName(Str);
806 
807  return Triple.getTriple();
808 }
809 
811  switch (AC) {
813  if (!Lipo)
814  Lipo.reset(new tools::darwin::Lipo(*this));
815  return Lipo.get();
817  if (!Dsymutil)
818  Dsymutil.reset(new tools::darwin::Dsymutil(*this));
819  return Dsymutil.get();
821  if (!VerifyDebug)
822  VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
823  return VerifyDebug.get();
824  default:
825  return ToolChain::getTool(AC);
826  }
827 }
828 
829 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
830 
832  return new tools::darwin::Assembler(*this);
833 }
834 
835 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
836  const ArgList &Args)
837  : Darwin(D, Triple, Args) {}
838 
839 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
840  // For modern targets, promote certain warnings to errors.
841  if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
842  // Always enable -Wdeprecated-objc-isa-usage and promote it
843  // to an error.
844  CC1Args.push_back("-Wdeprecated-objc-isa-usage");
845  CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
846 
847  // For iOS and watchOS, also error about implicit function declarations,
848  // as that can impact calling conventions.
849  if (!isTargetMacOS())
850  CC1Args.push_back("-Werror=implicit-function-declaration");
851  }
852 }
853 
854 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
855  ArgStringList &CmdArgs) const {
856  // Avoid linking compatibility stubs on i386 mac.
857  if (isTargetMacOS() && getArch() == llvm::Triple::x86)
858  return;
859 
860  ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
861 
862  if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
863  runtime.hasSubscripting())
864  return;
865 
866  CmdArgs.push_back("-force_load");
867  SmallString<128> P(getDriver().ClangExecutable);
868  llvm::sys::path::remove_filename(P); // 'clang'
869  llvm::sys::path::remove_filename(P); // 'bin'
870  llvm::sys::path::append(P, "lib", "arc", "libarclite_");
871  // Mash in the platform.
873  P += "watchsimulator";
874  else if (isTargetWatchOS())
875  P += "watchos";
876  else if (isTargetTvOSSimulator())
877  P += "appletvsimulator";
878  else if (isTargetTvOS())
879  P += "appletvos";
880  else if (isTargetIOSSimulator())
881  P += "iphonesimulator";
882  else if (isTargetIPhoneOS())
883  P += "iphoneos";
884  else
885  P += "macosx";
886  P += ".a";
887 
888  CmdArgs.push_back(Args.MakeArgString(P));
889 }
890 
892  // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
893  if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
895  return 2;
896  return 4;
897 }
898 
899 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
900  StringRef DarwinLibName,
901  RuntimeLinkOptions Opts) const {
902  SmallString<128> Dir(getDriver().ResourceDir);
903  llvm::sys::path::append(
904  Dir, "lib", (Opts & RLO_IsEmbedded) ? "macho_embedded" : "darwin");
905 
906  SmallString<128> P(Dir);
907  llvm::sys::path::append(P, DarwinLibName);
908 
909  // For now, allow missing resource libraries to support developers who may
910  // not have compiler-rt checked out or integrated into their build (unless
911  // we explicitly force linking with this library).
912  if ((Opts & RLO_AlwaysLink) || getVFS().exists(P)) {
913  const char *LibArg = Args.MakeArgString(P);
914  if (Opts & RLO_FirstLink)
915  CmdArgs.insert(CmdArgs.begin(), LibArg);
916  else
917  CmdArgs.push_back(LibArg);
918  }
919 
920  // Adding the rpaths might negatively interact when other rpaths are involved,
921  // so we should make sure we add the rpaths last, after all user-specified
922  // rpaths. This is currently true from this place, but we need to be
923  // careful if this function is ever called before user's rpaths are emitted.
924  if (Opts & RLO_AddRPath) {
925  assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
926 
927  // Add @executable_path to rpath to support having the dylib copied with
928  // the executable.
929  CmdArgs.push_back("-rpath");
930  CmdArgs.push_back("@executable_path");
931 
932  // Add the path to the resource dir to rpath to support using the dylib
933  // from the default location without copying.
934  CmdArgs.push_back("-rpath");
935  CmdArgs.push_back(Args.MakeArgString(Dir));
936  }
937 }
938 
939 StringRef Darwin::getPlatformFamily() const {
940  switch (TargetPlatform) {
941  case DarwinPlatformKind::MacOS:
942  return "MacOSX";
943  case DarwinPlatformKind::IPhoneOS:
944  return "iPhone";
945  case DarwinPlatformKind::TvOS:
946  return "AppleTV";
947  case DarwinPlatformKind::WatchOS:
948  return "Watch";
949  }
950  llvm_unreachable("Unsupported platform");
951 }
952 
953 StringRef Darwin::getSDKName(StringRef isysroot) {
954  // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
955  llvm::sys::path::const_iterator SDKDir;
956  auto BeginSDK = llvm::sys::path::begin(isysroot);
957  auto EndSDK = llvm::sys::path::end(isysroot);
958  for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
959  StringRef SDK = *IT;
960  if (SDK.endswith(".sdk"))
961  return SDK.slice(0, SDK.size() - 4);
962  }
963  return "";
964 }
965 
967  switch(TargetPlatform) {
968  case DarwinPlatformKind::MacOS:
969  return "osx";
970  case DarwinPlatformKind::IPhoneOS:
971  return TargetEnvironment == NativeEnvironment ? "ios" : "iossim";
972  case DarwinPlatformKind::TvOS:
973  return TargetEnvironment == NativeEnvironment ? "tvos" : "tvossim";
974  case DarwinPlatformKind::WatchOS:
975  return TargetEnvironment == NativeEnvironment ? "watchos" : "watchossim";
976  }
977  llvm_unreachable("Unsupported platform");
978 }
979 
980 /// Check if the link command contains a symbol export directive.
981 static bool hasExportSymbolDirective(const ArgList &Args) {
982  for (Arg *A : Args) {
983  if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
984  !A->getOption().matches(options::OPT_Xlinker))
985  continue;
986  if (A->containsValue("-exported_symbols_list") ||
987  A->containsValue("-exported_symbol"))
988  return true;
989  }
990  return false;
991 }
992 
993 /// Add an export directive for \p Symbol to the link command.
994 static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol) {
995  CmdArgs.push_back("-exported_symbol");
996  CmdArgs.push_back(Symbol);
997 }
998 
999 void Darwin::addProfileRTLibs(const ArgList &Args,
1000  ArgStringList &CmdArgs) const {
1001  if (!needsProfileRT(Args)) return;
1002 
1004  Args, CmdArgs,
1005  (Twine("libclang_rt.profile_") + getOSLibraryNameSuffix() + ".a").str(),
1007 
1008  // If we have a symbol export directive and we're linking in the profile
1009  // runtime, automatically export symbols necessary to implement some of the
1010  // runtime's functionality.
1011  if (hasExportSymbolDirective(Args)) {
1012  addExportedSymbol(CmdArgs, "_VPMergeHook");
1013  addExportedSymbol(CmdArgs, "___llvm_profile_filename");
1014  addExportedSymbol(CmdArgs, "___llvm_profile_raw_version");
1015  addExportedSymbol(CmdArgs, "_lprofCurFilename");
1016  }
1017 }
1018 
1019 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1020  ArgStringList &CmdArgs,
1021  StringRef Sanitizer,
1022  bool Shared) const {
1023  auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
1024  AddLinkRuntimeLib(Args, CmdArgs,
1025  (Twine("libclang_rt.") + Sanitizer + "_" +
1027  (Shared ? "_dynamic.dylib" : ".a"))
1028  .str(),
1029  RLO);
1030 }
1031 
1033  const ArgList &Args) const {
1034  if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1035  StringRef Value = A->getValue();
1036  if (Value != "compiler-rt")
1037  getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1038  << Value << "darwin";
1039  }
1040 
1042 }
1043 
1044 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1045  ArgStringList &CmdArgs) const {
1046  // Call once to ensure diagnostic is printed if wrong value was specified
1047  GetRuntimeLibType(Args);
1048 
1049  // Darwin doesn't support real static executables, don't link any runtime
1050  // libraries with -static.
1051  if (Args.hasArg(options::OPT_static) ||
1052  Args.hasArg(options::OPT_fapple_kext) ||
1053  Args.hasArg(options::OPT_mkernel))
1054  return;
1055 
1056  // Reject -static-libgcc for now, we can deal with this when and if someone
1057  // cares. This is useful in situations where someone wants to statically link
1058  // something like libstdc++, and needs its runtime support routines.
1059  if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1060  getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1061  return;
1062  }
1063 
1064  const SanitizerArgs &Sanitize = getSanitizerArgs();
1065  if (Sanitize.needsAsanRt())
1066  AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1067  if (Sanitize.needsLsanRt())
1068  AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1069  if (Sanitize.needsUbsanRt())
1070  AddLinkSanitizerLibArgs(Args, CmdArgs,
1071  Sanitize.requiresMinimalRuntime() ? "ubsan_minimal"
1072  : "ubsan",
1073  Sanitize.needsSharedRt());
1074  if (Sanitize.needsTsanRt())
1075  AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1076  if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1077  AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", /*shared=*/false);
1078 
1079  // Libfuzzer is written in C++ and requires libcxx.
1080  AddCXXStdlibLibArgs(Args, CmdArgs);
1081  }
1082  if (Sanitize.needsStatsRt()) {
1083  StringRef OS = isTargetMacOS() ? "osx" : "iossim";
1084  AddLinkRuntimeLib(Args, CmdArgs,
1085  (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
1086  RLO_AlwaysLink);
1087  AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1088  }
1089  if (Sanitize.needsEsanRt())
1090  AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
1091 
1092  // Otherwise link libSystem, then the dynamic runtime library, and finally any
1093  // target specific static runtime library.
1094  CmdArgs.push_back("-lSystem");
1095 
1096  // Select the dynamic runtime library and the target specific static library.
1097  if (isTargetWatchOSBased()) {
1098  // We currently always need a static runtime library for watchOS.
1099  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
1100  } else if (isTargetTvOSBased()) {
1101  // We currently always need a static runtime library for tvOS.
1102  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
1103  } else if (isTargetIOSBased()) {
1104  // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1105  // it never went into the SDK.
1106  // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1107  if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1108  getTriple().getArch() != llvm::Triple::aarch64)
1109  CmdArgs.push_back("-lgcc_s.1");
1110 
1111  // We currently always need a static runtime library for iOS.
1112  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
1113  } else {
1114  assert(isTargetMacOS() && "unexpected non MacOS platform");
1115  // The dynamic runtime library was merged with libSystem for 10.6 and
1116  // beyond; only 10.4 and 10.5 need an additional runtime library.
1117  if (isMacosxVersionLT(10, 5))
1118  CmdArgs.push_back("-lgcc_s.10.4");
1119  else if (isMacosxVersionLT(10, 6))
1120  CmdArgs.push_back("-lgcc_s.10.5");
1121 
1122  // Originally for OS X, we thought we would only need a static runtime
1123  // library when targeting 10.4, to provide versions of the static functions
1124  // which were omitted from 10.4.dylib. This led to the creation of the 10.4
1125  // builtins library.
1126  //
1127  // Unfortunately, that turned out to not be true, because Darwin system
1128  // headers can still use eprintf on i386, and it is not exported from
1129  // libSystem. Therefore, we still must provide a runtime library just for
1130  // the tiny tiny handful of projects that *might* use that symbol.
1131  //
1132  // Then over time, we figured out it was useful to add more things to the
1133  // runtime so we created libclang_rt.osx.a to provide new functions when
1134  // deploying to old OS builds, and for a long time we had both eprintf and
1135  // osx builtin libraries. Which just seems excessive. So with PR 28855, we
1136  // are removing the eprintf library and expecting eprintf to be provided by
1137  // the OS X builtins library.
1138  if (isMacosxVersionLT(10, 5))
1139  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
1140  else
1141  AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
1142  }
1143 }
1144 
1145 /// Returns the most appropriate macOS target version for the current process.
1146 ///
1147 /// If the macOS SDK version is the same or earlier than the system version,
1148 /// then the SDK version is returned. Otherwise the system version is returned.
1149 static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
1150  unsigned Major, Minor, Micro;
1151  llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1152  if (!SystemTriple.isMacOSX())
1153  return MacOSSDKVersion;
1154  SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1155  VersionTuple SystemVersion(Major, Minor, Micro);
1156  bool HadExtra;
1157  if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1158  HadExtra))
1159  return MacOSSDKVersion;
1160  VersionTuple SDKVersion(Major, Minor, Micro);
1161  if (SDKVersion > SystemVersion)
1162  return SystemVersion.getAsString();
1163  return MacOSSDKVersion;
1164 }
1165 
1166 namespace {
1167 
1168 /// The Darwin OS that was selected or inferred from arguments / environment.
1169 struct DarwinPlatform {
1170  enum SourceKind {
1171  /// The OS was specified using the -target argument.
1172  TargetArg,
1173  /// The OS was specified using the -m<os>-version-min argument.
1174  OSVersionArg,
1175  /// The OS was specified using the OS_DEPLOYMENT_TARGET environment.
1176  DeploymentTargetEnv,
1177  /// The OS was inferred from the SDK.
1178  InferredFromSDK,
1179  /// The OS was inferred from the -arch.
1180  InferredFromArch
1181  };
1182 
1184 
1185  DarwinPlatformKind getPlatform() const { return Platform; }
1186 
1187  StringRef getOSVersion() const {
1188  if (Kind == OSVersionArg)
1189  return Argument->getValue();
1190  return OSVersion;
1191  }
1192 
1193  /// Returns true if the target OS was explicitly specified.
1194  bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
1195 
1196  /// Adds the -m<os>-version-min argument to the compiler invocation.
1197  void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
1198  if (Argument)
1199  return;
1200  assert(Kind != TargetArg && Kind != OSVersionArg && "Invalid kind");
1201  options::ID Opt;
1202  switch (Platform) {
1203  case DarwinPlatformKind::MacOS:
1204  Opt = options::OPT_mmacosx_version_min_EQ;
1205  break;
1206  case DarwinPlatformKind::IPhoneOS:
1207  Opt = options::OPT_miphoneos_version_min_EQ;
1208  break;
1209  case DarwinPlatformKind::TvOS:
1210  Opt = options::OPT_mtvos_version_min_EQ;
1211  break;
1212  case DarwinPlatformKind::WatchOS:
1213  Opt = options::OPT_mwatchos_version_min_EQ;
1214  break;
1215  }
1216  Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
1217  Args.append(Argument);
1218  }
1219 
1220  /// Returns the OS version with the argument / environment variable that
1221  /// specified it.
1222  std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
1223  switch (Kind) {
1224  case TargetArg:
1225  case OSVersionArg:
1226  case InferredFromSDK:
1227  case InferredFromArch:
1228  assert(Argument && "OS version argument not yet inferred");
1229  return Argument->getAsString(Args);
1230  case DeploymentTargetEnv:
1231  return (llvm::Twine(EnvVarName) + "=" + OSVersion).str();
1232  }
1233  llvm_unreachable("Unsupported Darwin Source Kind");
1234  }
1235 
1236  static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform,
1237  Arg *A) {
1238  return DarwinPlatform(OSVersionArg, Platform, A);
1239  }
1240  static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1241  StringRef EnvVarName,
1242  StringRef Value) {
1243  DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1244  Result.EnvVarName = EnvVarName;
1245  return Result;
1246  }
1247  static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1248  StringRef Value) {
1249  return DarwinPlatform(InferredFromSDK, Platform, Value);
1250  }
1251  static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1252  StringRef Value) {
1253  DarwinPlatformKind Platform;
1254  switch (OS) {
1255  case llvm::Triple::Darwin:
1256  case llvm::Triple::MacOSX:
1257  Platform = DarwinPlatformKind::MacOS;
1258  break;
1259  case llvm::Triple::IOS:
1260  Platform = DarwinPlatformKind::IPhoneOS;
1261  break;
1262  case llvm::Triple::TvOS:
1263  Platform = DarwinPlatformKind::TvOS;
1264  break;
1265  case llvm::Triple::WatchOS:
1266  Platform = DarwinPlatformKind::WatchOS;
1267  break;
1268  default:
1269  llvm_unreachable("Unable to infer Darwin variant");
1270  }
1271  return DarwinPlatform(InferredFromArch, Platform, Value);
1272  }
1273 
1274 private:
1275  DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1276  : Kind(Kind), Platform(Platform), Argument(Argument) {}
1277  DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef Value)
1278  : Kind(Kind), Platform(Platform), OSVersion(Value), Argument(nullptr) {}
1279 
1280  SourceKind Kind;
1281  DarwinPlatformKind Platform;
1282  std::string OSVersion;
1283  Arg *Argument;
1284  StringRef EnvVarName;
1285 };
1286 
1287 /// Returns the deployment target that's specified using the -m<os>-version-min
1288 /// argument.
1290 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1291  const Driver &TheDriver) {
1292  Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1293  Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1294  options::OPT_mios_simulator_version_min_EQ);
1295  Arg *TvOSVersion =
1296  Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1297  options::OPT_mtvos_simulator_version_min_EQ);
1298  Arg *WatchOSVersion =
1299  Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1300  options::OPT_mwatchos_simulator_version_min_EQ);
1301  if (OSXVersion) {
1302  if (iOSVersion || TvOSVersion || WatchOSVersion) {
1303  TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1304  << OSXVersion->getAsString(Args)
1305  << (iOSVersion ? iOSVersion
1306  : TvOSVersion ? TvOSVersion : WatchOSVersion)
1307  ->getAsString(Args);
1308  }
1309  return DarwinPlatform::createOSVersionArg(Darwin::MacOS, OSXVersion);
1310  } else if (iOSVersion) {
1311  if (TvOSVersion || WatchOSVersion) {
1312  TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1313  << iOSVersion->getAsString(Args)
1314  << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1315  }
1316  return DarwinPlatform::createOSVersionArg(Darwin::IPhoneOS, iOSVersion);
1317  } else if (TvOSVersion) {
1318  if (WatchOSVersion) {
1319  TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1320  << TvOSVersion->getAsString(Args)
1321  << WatchOSVersion->getAsString(Args);
1322  }
1323  return DarwinPlatform::createOSVersionArg(Darwin::TvOS, TvOSVersion);
1324  } else if (WatchOSVersion)
1325  return DarwinPlatform::createOSVersionArg(Darwin::WatchOS, WatchOSVersion);
1326  return None;
1327 }
1328 
1329 /// Returns the deployment target that's specified using the
1330 /// OS_DEPLOYMENT_TARGET environment variable.
1332 getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
1333  const llvm::Triple &Triple) {
1334  std::string Targets[Darwin::LastDarwinPlatform + 1];
1335  const char *EnvVars[] = {
1336  "MACOSX_DEPLOYMENT_TARGET",
1337  "IPHONEOS_DEPLOYMENT_TARGET",
1338  "TVOS_DEPLOYMENT_TARGET",
1339  "WATCHOS_DEPLOYMENT_TARGET",
1340  };
1341  static_assert(llvm::array_lengthof(EnvVars) == Darwin::LastDarwinPlatform + 1,
1342  "Missing platform");
1343  for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1344  if (char *Env = ::getenv(I.value()))
1345  Targets[I.index()] = Env;
1346  }
1347 
1348  // Do not allow conflicts with the watchOS target.
1349  if (!Targets[Darwin::WatchOS].empty() &&
1350  (!Targets[Darwin::IPhoneOS].empty() || !Targets[Darwin::TvOS].empty())) {
1351  TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1352  << "WATCHOS_DEPLOYMENT_TARGET"
1353  << (!Targets[Darwin::IPhoneOS].empty() ? "IPHONEOS_DEPLOYMENT_TARGET"
1354  : "TVOS_DEPLOYMENT_TARGET");
1355  }
1356 
1357  // Do not allow conflicts with the tvOS target.
1358  if (!Targets[Darwin::TvOS].empty() && !Targets[Darwin::IPhoneOS].empty()) {
1359  TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1360  << "TVOS_DEPLOYMENT_TARGET"
1361  << "IPHONEOS_DEPLOYMENT_TARGET";
1362  }
1363 
1364  // Allow conflicts among OSX and iOS for historical reasons, but choose the
1365  // default platform.
1366  if (!Targets[Darwin::MacOS].empty() &&
1367  (!Targets[Darwin::IPhoneOS].empty() ||
1368  !Targets[Darwin::WatchOS].empty() || !Targets[Darwin::TvOS].empty())) {
1369  if (Triple.getArch() == llvm::Triple::arm ||
1370  Triple.getArch() == llvm::Triple::aarch64 ||
1371  Triple.getArch() == llvm::Triple::thumb)
1372  Targets[Darwin::MacOS] = "";
1373  else
1374  Targets[Darwin::IPhoneOS] = Targets[Darwin::WatchOS] =
1375  Targets[Darwin::TvOS] = "";
1376  }
1377 
1378  for (const auto &Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1379  if (!Target.value().empty())
1380  return DarwinPlatform::createDeploymentTargetEnv(
1381  (Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
1382  Target.value());
1383  }
1384  return None;
1385 }
1386 
1387 /// Tries to infer the deployment target from the SDK specified by -isysroot
1388 /// (or SDKROOT).
1389 Optional<DarwinPlatform> inferDeploymentTargetFromSDK(DerivedArgList &Args) {
1390  const Arg *A = Args.getLastArg(options::OPT_isysroot);
1391  if (!A)
1392  return None;
1393  StringRef isysroot = A->getValue();
1394  StringRef SDK = Darwin::getSDKName(isysroot);
1395  if (!SDK.size())
1396  return None;
1397  // Slice the version number out.
1398  // Version number is between the first and the last number.
1399  size_t StartVer = SDK.find_first_of("0123456789");
1400  size_t EndVer = SDK.find_last_of("0123456789");
1401  if (StartVer != StringRef::npos && EndVer > StartVer) {
1402  StringRef Version = SDK.slice(StartVer, EndVer + 1);
1403  if (SDK.startswith("iPhoneOS") || SDK.startswith("iPhoneSimulator"))
1404  return DarwinPlatform::createFromSDK(Darwin::IPhoneOS, Version);
1405  else if (SDK.startswith("MacOSX"))
1406  return DarwinPlatform::createFromSDK(Darwin::MacOS,
1407  getSystemOrSDKMacOSVersion(Version));
1408  else if (SDK.startswith("WatchOS") || SDK.startswith("WatchSimulator"))
1409  return DarwinPlatform::createFromSDK(Darwin::WatchOS, Version);
1410  else if (SDK.startswith("AppleTVOS") || SDK.startswith("AppleTVSimulator"))
1411  return DarwinPlatform::createFromSDK(Darwin::TvOS, Version);
1412  }
1413  return None;
1414 }
1415 
1416 std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
1417  const Driver &TheDriver) {
1418  unsigned Major, Minor, Micro;
1419  switch (OS) {
1420  case llvm::Triple::Darwin:
1421  case llvm::Triple::MacOSX:
1422  if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1423  TheDriver.Diag(diag::err_drv_invalid_darwin_version)
1424  << Triple.getOSName();
1425  break;
1426  case llvm::Triple::IOS:
1427  Triple.getiOSVersion(Major, Minor, Micro);
1428  break;
1429  case llvm::Triple::TvOS:
1430  Triple.getOSVersion(Major, Minor, Micro);
1431  break;
1432  case llvm::Triple::WatchOS:
1433  Triple.getWatchOSVersion(Major, Minor, Micro);
1434  break;
1435  default:
1436  llvm_unreachable("Unexpected OS type");
1437  break;
1438  }
1439 
1440  std::string OSVersion;
1441  llvm::raw_string_ostream(OSVersion) << Major << '.' << Minor << '.' << Micro;
1442  return OSVersion;
1443 }
1444 
1445 /// Tries to infer the target OS from the -arch.
1447 inferDeploymentTargetFromArch(DerivedArgList &Args, const Darwin &Toolchain,
1448  const llvm::Triple &Triple,
1449  const Driver &TheDriver) {
1450  llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1451 
1452  // Set the OSTy based on -target if -arch isn't present.
1453  if (Args.hasArg(options::OPT_target) && !Args.hasArg(options::OPT_arch)) {
1454  OSTy = Triple.getOS();
1455  } else {
1456  StringRef MachOArchName = Toolchain.getMachOArchName(Args);
1457  if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
1458  MachOArchName == "arm64")
1459  OSTy = llvm::Triple::IOS;
1460  else if (MachOArchName == "armv7k")
1461  OSTy = llvm::Triple::WatchOS;
1462  else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
1463  MachOArchName != "armv7em")
1464  OSTy = llvm::Triple::MacOSX;
1465  }
1466 
1467  if (OSTy == llvm::Triple::UnknownOS)
1468  return None;
1469  return DarwinPlatform::createFromArch(OSTy,
1470  getOSVersion(OSTy, Triple, TheDriver));
1471 }
1472 
1473 } // namespace
1474 
1475 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
1476  const OptTable &Opts = getDriver().getOpts();
1477 
1478  // Support allowing the SDKROOT environment variable used by xcrun and other
1479  // Xcode tools to define the default sysroot, by making it the default for
1480  // isysroot.
1481  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1482  // Warn if the path does not exist.
1483  if (!getVFS().exists(A->getValue()))
1484  getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1485  } else {
1486  if (char *env = ::getenv("SDKROOT")) {
1487  // We only use this value as the default if it is an absolute path,
1488  // exists, and it is not the root path.
1489  if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
1490  StringRef(env) != "/") {
1491  Args.append(Args.MakeSeparateArg(
1492  nullptr, Opts.getOption(options::OPT_isysroot), env));
1493  }
1494  }
1495  }
1496 
1497  // The OS target can be specified using the -m<os>version-min argument.
1498  Optional<DarwinPlatform> OSTarget =
1499  getDeploymentTargetFromOSVersionArg(Args, getDriver());
1500  // If no deployment target was specified on the command line, check for
1501  // environment defines.
1502  if (!OSTarget)
1503  OSTarget =
1504  getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
1505  // If there is no command-line argument to specify the Target version and
1506  // no environment variable defined, see if we can set the default based
1507  // on -isysroot.
1508  if (!OSTarget)
1509  OSTarget = inferDeploymentTargetFromSDK(Args);
1510  // If no OS targets have been specified, try to guess platform from -target
1511  // or arch name and compute the version from the triple.
1512  if (!OSTarget)
1513  OSTarget =
1514  inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
1515 
1516  assert(OSTarget && "Unable to infer Darwin variant");
1517  OSTarget->addOSVersionMinArgument(Args, Opts);
1518  DarwinPlatformKind Platform = OSTarget->getPlatform();
1519 
1520  unsigned Major, Minor, Micro;
1521  bool HadExtra;
1522  // Set the tool chain target information.
1523  if (Platform == MacOS) {
1524  if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1525  Micro, HadExtra) ||
1526  HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1527  getDriver().Diag(diag::err_drv_invalid_version_number)
1528  << OSTarget->getAsString(Args, Opts);
1529  } else if (Platform == IPhoneOS) {
1530  if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1531  Micro, HadExtra) ||
1532  HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1533  getDriver().Diag(diag::err_drv_invalid_version_number)
1534  << OSTarget->getAsString(Args, Opts);
1535  ;
1536  // For 32-bit targets, the deployment target for iOS has to be earlier than
1537  // iOS 11.
1538  if (getTriple().isArch32Bit() && Major >= 11) {
1539  // If the deployment target is explicitly specified, print a diagnostic.
1540  if (OSTarget->isExplicitlySpecified()) {
1541  getDriver().Diag(diag::warn_invalid_ios_deployment_target)
1542  << OSTarget->getAsString(Args, Opts);
1543  // Otherwise, set it to 10.99.99.
1544  } else {
1545  Major = 10;
1546  Minor = 99;
1547  Micro = 99;
1548  }
1549  }
1550  } else if (Platform == TvOS) {
1551  if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1552  Micro, HadExtra) ||
1553  HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1554  getDriver().Diag(diag::err_drv_invalid_version_number)
1555  << OSTarget->getAsString(Args, Opts);
1556  } else if (Platform == WatchOS) {
1557  if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1558  Micro, HadExtra) ||
1559  HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1560  getDriver().Diag(diag::err_drv_invalid_version_number)
1561  << OSTarget->getAsString(Args, Opts);
1562  } else
1563  llvm_unreachable("unknown kind of Darwin platform");
1564 
1566  // Recognize iOS targets with an x86 architecture as the iOS simulator.
1567  if (Platform != MacOS && (getTriple().getArch() == llvm::Triple::x86 ||
1568  getTriple().getArch() == llvm::Triple::x86_64))
1569  Environment = Simulator;
1570 
1571  setTarget(Platform, Environment, Major, Minor, Micro);
1572 
1573  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1574  StringRef SDK = getSDKName(A->getValue());
1575  if (SDK.size() > 0) {
1576  size_t StartVer = SDK.find_first_of("0123456789");
1577  StringRef SDKName = SDK.slice(0, StartVer);
1578  if (!SDKName.startswith(getPlatformFamily()))
1579  getDriver().Diag(diag::warn_incompatible_sysroot)
1580  << SDKName << getPlatformFamily();
1581  }
1582  }
1583 }
1584 
1585 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
1586  ArgStringList &CmdArgs) const {
1588 
1589  switch (Type) {
1590  case ToolChain::CST_Libcxx:
1591  CmdArgs.push_back("-lc++");
1592  break;
1593 
1595  // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
1596  // it was previously found in the gcc lib dir. However, for all the Darwin
1597  // platforms we care about it was -lstdc++.6, so we search for that
1598  // explicitly if we can't see an obvious -lstdc++ candidate.
1599 
1600  // Check in the sysroot first.
1601  if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1602  SmallString<128> P(A->getValue());
1603  llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
1604 
1605  if (!getVFS().exists(P)) {
1606  llvm::sys::path::remove_filename(P);
1607  llvm::sys::path::append(P, "libstdc++.6.dylib");
1608  if (getVFS().exists(P)) {
1609  CmdArgs.push_back(Args.MakeArgString(P));
1610  return;
1611  }
1612  }
1613  }
1614 
1615  // Otherwise, look in the root.
1616  // FIXME: This should be removed someday when we don't have to care about
1617  // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
1618  if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
1619  getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
1620  CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
1621  return;
1622  }
1623 
1624  // Otherwise, let the linker search.
1625  CmdArgs.push_back("-lstdc++");
1626  break;
1627  }
1628 }
1629 
1630 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
1631  ArgStringList &CmdArgs) const {
1632  // For Darwin platforms, use the compiler-rt-based support library
1633  // instead of the gcc-provided one (which is also incidentally
1634  // only present in the gcc lib dir, which makes it hard to find).
1635 
1636  SmallString<128> P(getDriver().ResourceDir);
1637  llvm::sys::path::append(P, "lib", "darwin");
1638 
1639  // Use the newer cc_kext for iOS ARM after 6.0.
1640  if (isTargetWatchOS()) {
1641  llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
1642  } else if (isTargetTvOS()) {
1643  llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
1644  } else if (isTargetIPhoneOS()) {
1645  llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
1646  } else {
1647  llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
1648  }
1649 
1650  // For now, allow missing resource libraries to support developers who may
1651  // not have compiler-rt checked out or integrated into their build.
1652  if (getVFS().exists(P))
1653  CmdArgs.push_back(Args.MakeArgString(P));
1654 }
1655 
1656 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
1657  StringRef BoundArch,
1658  Action::OffloadKind) const {
1659  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1660  const OptTable &Opts = getDriver().getOpts();
1661 
1662  // FIXME: We really want to get out of the tool chain level argument
1663  // translation business, as it makes the driver functionality much
1664  // more opaque. For now, we follow gcc closely solely for the
1665  // purpose of easily achieving feature parity & testability. Once we
1666  // have something that works, we should reevaluate each translation
1667  // and try to push it down into tool specific logic.
1668 
1669  for (Arg *A : Args) {
1670  if (A->getOption().matches(options::OPT_Xarch__)) {
1671  // Skip this argument unless the architecture matches either the toolchain
1672  // triple arch, or the arch being bound.
1673  llvm::Triple::ArchType XarchArch =
1675  if (!(XarchArch == getArch() ||
1676  (!BoundArch.empty() &&
1677  XarchArch ==
1679  continue;
1680 
1681  Arg *OriginalArg = A;
1682  unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1683  unsigned Prev = Index;
1684  std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1685 
1686  // If the argument parsing failed or more than one argument was
1687  // consumed, the -Xarch_ argument's parameter tried to consume
1688  // extra arguments. Emit an error and ignore.
1689  //
1690  // We also want to disallow any options which would alter the
1691  // driver behavior; that isn't going to work in our model. We
1692  // use isDriverOption() as an approximation, although things
1693  // like -O4 are going to slip through.
1694  if (!XarchArg || Index > Prev + 1) {
1695  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1696  << A->getAsString(Args);
1697  continue;
1698  } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
1699  getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1700  << A->getAsString(Args);
1701  continue;
1702  }
1703 
1704  XarchArg->setBaseArg(A);
1705 
1706  A = XarchArg.release();
1707  DAL->AddSynthesizedArg(A);
1708 
1709  // Linker input arguments require custom handling. The problem is that we
1710  // have already constructed the phase actions, so we can not treat them as
1711  // "input arguments".
1712  if (A->getOption().hasFlag(options::LinkerInput)) {
1713  // Convert the argument into individual Zlinker_input_args.
1714  for (const char *Value : A->getValues()) {
1715  DAL->AddSeparateArg(
1716  OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
1717  }
1718  continue;
1719  }
1720  }
1721 
1722  // Sob. These is strictly gcc compatible for the time being. Apple
1723  // gcc translates options twice, which means that self-expanding
1724  // options add duplicates.
1725  switch ((options::ID)A->getOption().getID()) {
1726  default:
1727  DAL->append(A);
1728  break;
1729 
1730  case options::OPT_mkernel:
1731  case options::OPT_fapple_kext:
1732  DAL->append(A);
1733  DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1734  break;
1735 
1736  case options::OPT_dependency_file:
1737  DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1738  break;
1739 
1740  case options::OPT_gfull:
1741  DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1742  DAL->AddFlagArg(
1743  A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1744  break;
1745 
1746  case options::OPT_gused:
1747  DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1748  DAL->AddFlagArg(
1749  A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1750  break;
1751 
1752  case options::OPT_shared:
1753  DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1754  break;
1755 
1756  case options::OPT_fconstant_cfstrings:
1757  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1758  break;
1759 
1760  case options::OPT_fno_constant_cfstrings:
1761  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1762  break;
1763 
1764  case options::OPT_Wnonportable_cfstrings:
1765  DAL->AddFlagArg(A,
1766  Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1767  break;
1768 
1769  case options::OPT_Wno_nonportable_cfstrings:
1770  DAL->AddFlagArg(
1771  A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1772  break;
1773 
1774  case options::OPT_fpascal_strings:
1775  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1776  break;
1777 
1778  case options::OPT_fno_pascal_strings:
1779  DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1780  break;
1781  }
1782  }
1783 
1784  if (getTriple().getArch() == llvm::Triple::x86 ||
1785  getTriple().getArch() == llvm::Triple::x86_64)
1786  if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1787  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
1788  "core2");
1789 
1790  // Add the arch options based on the particular spelling of -arch, to match
1791  // how the driver driver works.
1792  if (!BoundArch.empty()) {
1793  StringRef Name = BoundArch;
1794  const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1795  const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1796 
1797  // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
1798  // which defines the list of which architectures we accept.
1799  if (Name == "ppc")
1800  ;
1801  else if (Name == "ppc601")
1802  DAL->AddJoinedArg(nullptr, MCpu, "601");
1803  else if (Name == "ppc603")
1804  DAL->AddJoinedArg(nullptr, MCpu, "603");
1805  else if (Name == "ppc604")
1806  DAL->AddJoinedArg(nullptr, MCpu, "604");
1807  else if (Name == "ppc604e")
1808  DAL->AddJoinedArg(nullptr, MCpu, "604e");
1809  else if (Name == "ppc750")
1810  DAL->AddJoinedArg(nullptr, MCpu, "750");
1811  else if (Name == "ppc7400")
1812  DAL->AddJoinedArg(nullptr, MCpu, "7400");
1813  else if (Name == "ppc7450")
1814  DAL->AddJoinedArg(nullptr, MCpu, "7450");
1815  else if (Name == "ppc970")
1816  DAL->AddJoinedArg(nullptr, MCpu, "970");
1817 
1818  else if (Name == "ppc64" || Name == "ppc64le")
1819  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1820 
1821  else if (Name == "i386")
1822  ;
1823  else if (Name == "i486")
1824  DAL->AddJoinedArg(nullptr, MArch, "i486");
1825  else if (Name == "i586")
1826  DAL->AddJoinedArg(nullptr, MArch, "i586");
1827  else if (Name == "i686")
1828  DAL->AddJoinedArg(nullptr, MArch, "i686");
1829  else if (Name == "pentium")
1830  DAL->AddJoinedArg(nullptr, MArch, "pentium");
1831  else if (Name == "pentium2")
1832  DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1833  else if (Name == "pentpro")
1834  DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
1835  else if (Name == "pentIIm3")
1836  DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1837 
1838  else if (Name == "x86_64")
1839  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1840  else if (Name == "x86_64h") {
1841  DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1842  DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
1843  }
1844 
1845  else if (Name == "arm")
1846  DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1847  else if (Name == "armv4t")
1848  DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1849  else if (Name == "armv5")
1850  DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
1851  else if (Name == "xscale")
1852  DAL->AddJoinedArg(nullptr, MArch, "xscale");
1853  else if (Name == "armv6")
1854  DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1855  else if (Name == "armv6m")
1856  DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1857  else if (Name == "armv7")
1858  DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1859  else if (Name == "armv7em")
1860  DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1861  else if (Name == "armv7k")
1862  DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1863  else if (Name == "armv7m")
1864  DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1865  else if (Name == "armv7s")
1866  DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1867  }
1868 
1869  return DAL;
1870 }
1871 
1872 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1873  ArgStringList &CmdArgs) const {
1874  // Embedded targets are simple at the moment, not supporting sanitizers and
1875  // with different libraries for each member of the product { static, PIC } x
1876  // { hard-float, soft-float }
1877  llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1878  CompilerRT +=
1880  ? "hard"
1881  : "soft";
1882  CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1883 
1884  AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
1885 }
1886 
1888  llvm::Triple::OSType OS;
1889 
1890  switch (TargetPlatform) {
1891  case MacOS: // Earlier than 10.13.
1892  OS = llvm::Triple::MacOSX;
1893  break;
1894  case IPhoneOS:
1895  OS = llvm::Triple::IOS;
1896  break;
1897  case TvOS: // Earlier than 11.0.
1898  OS = llvm::Triple::TvOS;
1899  break;
1900  case WatchOS: // Earlier than 4.0.
1901  OS = llvm::Triple::WatchOS;
1902  break;
1903  }
1904 
1906 }
1907 
1908 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1909  llvm::opt::ArgStringList &CC1Args,
1910  Action::OffloadKind DeviceOffloadKind) const {
1912  CC1Args.push_back("-faligned-alloc-unavailable");
1913 }
1914 
1915 DerivedArgList *
1916 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
1917  Action::OffloadKind DeviceOffloadKind) const {
1918  // First get the generic Apple args, before moving onto Darwin-specific ones.
1919  DerivedArgList *DAL =
1920  MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
1921  const OptTable &Opts = getDriver().getOpts();
1922 
1923  // If no architecture is bound, none of the translations here are relevant.
1924  if (BoundArch.empty())
1925  return DAL;
1926 
1927  // Add an explicit version min argument for the deployment target. We do this
1928  // after argument translation because -Xarch_ arguments may add a version min
1929  // argument.
1930  AddDeploymentTarget(*DAL);
1931 
1932  // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1933  // FIXME: It would be far better to avoid inserting those -static arguments,
1934  // but we can't check the deployment target in the translation code until
1935  // it is set here.
1936  if (isTargetWatchOSBased() ||
1937  (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1938  for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1939  Arg *A = *it;
1940  ++it;
1941  if (A->getOption().getID() != options::OPT_mkernel &&
1942  A->getOption().getID() != options::OPT_fapple_kext)
1943  continue;
1944  assert(it != ie && "unexpected argument translation");
1945  A = *it;
1946  assert(A->getOption().getID() == options::OPT_static &&
1947  "missing expected -static argument");
1948  *it = nullptr;
1949  ++it;
1950  }
1951  }
1952 
1953  if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1955  DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1956  "libc++");
1957 
1958  // Validate the C++ standard library choice.
1960  if (Type == ToolChain::CST_Libcxx) {
1961  // Check whether the target provides libc++.
1962  StringRef where;
1963 
1964  // Complain about targeting iOS < 5.0 in any way.
1965  if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1966  where = "iOS 5.0";
1967 
1968  if (where != StringRef()) {
1969  getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1970  }
1971  }
1972 
1973  auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
1974  if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
1975  if (Args.hasFlag(options::OPT_fomit_frame_pointer,
1976  options::OPT_fno_omit_frame_pointer, false))
1977  getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
1978  << "-fomit-frame-pointer" << BoundArch;
1979  }
1980 
1981  return DAL;
1982 }
1983 
1984 bool MachO::IsUnwindTablesDefault(const ArgList &Args) const {
1985  // Unwind tables are not emitted if -fno-exceptions is supplied (except when
1986  // targeting x86_64).
1987  return getArch() == llvm::Triple::x86_64 ||
1988  (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
1989  Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
1990  true));
1991 }
1992 
1994  if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1995  return S[0] != '\0';
1996  return false;
1997 }
1998 
1999 llvm::ExceptionHandling Darwin::GetExceptionModel(const ArgList &Args) const {
2000  // Darwin uses SjLj exceptions on ARM.
2001  if (getTriple().getArch() != llvm::Triple::arm &&
2002  getTriple().getArch() != llvm::Triple::thumb)
2004 
2005  // Only watchOS uses the new DWARF/Compact unwinding method.
2006  llvm::Triple Triple(ComputeLLVMTriple(Args));
2007  if(Triple.isWatchABI())
2008  return llvm::ExceptionHandling::DwarfCFI;
2009 
2010  return llvm::ExceptionHandling::SjLj;
2011 }
2012 
2014  assert(TargetInitialized && "Target not initialized!");
2015  if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
2016  return false;
2017  return true;
2018 }
2019 
2020 bool MachO::isPICDefault() const { return true; }
2021 
2022 bool MachO::isPIEDefault() const { return false; }
2023 
2025  return (getArch() == llvm::Triple::x86_64 ||
2026  getArch() == llvm::Triple::aarch64);
2027 }
2028 
2030  // Profiling instrumentation is only supported on x86.
2031  return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
2032 }
2033 
2034 void Darwin::addMinVersionArgs(const ArgList &Args,
2035  ArgStringList &CmdArgs) const {
2037 
2038  if (isTargetWatchOS())
2039  CmdArgs.push_back("-watchos_version_min");
2040  else if (isTargetWatchOSSimulator())
2041  CmdArgs.push_back("-watchos_simulator_version_min");
2042  else if (isTargetTvOS())
2043  CmdArgs.push_back("-tvos_version_min");
2044  else if (isTargetTvOSSimulator())
2045  CmdArgs.push_back("-tvos_simulator_version_min");
2046  else if (isTargetIOSSimulator())
2047  CmdArgs.push_back("-ios_simulator_version_min");
2048  else if (isTargetIOSBased())
2049  CmdArgs.push_back("-iphoneos_version_min");
2050  else {
2051  assert(isTargetMacOS() && "unexpected target");
2052  CmdArgs.push_back("-macosx_version_min");
2053  }
2054 
2055  CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2056 }
2057 
2058 void Darwin::addStartObjectFileArgs(const ArgList &Args,
2059  ArgStringList &CmdArgs) const {
2060  // Derived from startfile spec.
2061  if (Args.hasArg(options::OPT_dynamiclib)) {
2062  // Derived from darwin_dylib1 spec.
2063  if (isTargetWatchOSBased()) {
2064  ; // watchOS does not need dylib1.o.
2065  } else if (isTargetIOSSimulator()) {
2066  ; // iOS simulator does not need dylib1.o.
2067  } else if (isTargetIPhoneOS()) {
2068  if (isIPhoneOSVersionLT(3, 1))
2069  CmdArgs.push_back("-ldylib1.o");
2070  } else {
2071  if (isMacosxVersionLT(10, 5))
2072  CmdArgs.push_back("-ldylib1.o");
2073  else if (isMacosxVersionLT(10, 6))
2074  CmdArgs.push_back("-ldylib1.10.5.o");
2075  }
2076  } else {
2077  if (Args.hasArg(options::OPT_bundle)) {
2078  if (!Args.hasArg(options::OPT_static)) {
2079  // Derived from darwin_bundle1 spec.
2080  if (isTargetWatchOSBased()) {
2081  ; // watchOS does not need bundle1.o.
2082  } else if (isTargetIOSSimulator()) {
2083  ; // iOS simulator does not need bundle1.o.
2084  } else if (isTargetIPhoneOS()) {
2085  if (isIPhoneOSVersionLT(3, 1))
2086  CmdArgs.push_back("-lbundle1.o");
2087  } else {
2088  if (isMacosxVersionLT(10, 6))
2089  CmdArgs.push_back("-lbundle1.o");
2090  }
2091  }
2092  } else {
2093  if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
2094  if (Args.hasArg(options::OPT_static) ||
2095  Args.hasArg(options::OPT_object) ||
2096  Args.hasArg(options::OPT_preload)) {
2097  CmdArgs.push_back("-lgcrt0.o");
2098  } else {
2099  CmdArgs.push_back("-lgcrt1.o");
2100 
2101  // darwin_crt2 spec is empty.
2102  }
2103  // By default on OS X 10.8 and later, we don't link with a crt1.o
2104  // file and the linker knows to use _main as the entry point. But,
2105  // when compiling with -pg, we need to link with the gcrt1.o file,
2106  // so pass the -no_new_main option to tell the linker to use the
2107  // "start" symbol as the entry point.
2108  if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
2109  CmdArgs.push_back("-no_new_main");
2110  } else {
2111  if (Args.hasArg(options::OPT_static) ||
2112  Args.hasArg(options::OPT_object) ||
2113  Args.hasArg(options::OPT_preload)) {
2114  CmdArgs.push_back("-lcrt0.o");
2115  } else {
2116  // Derived from darwin_crt1 spec.
2117  if (isTargetWatchOSBased()) {
2118  ; // watchOS does not need crt1.o.
2119  } else if (isTargetIOSSimulator()) {
2120  ; // iOS simulator does not need crt1.o.
2121  } else if (isTargetIPhoneOS()) {
2122  if (getArch() == llvm::Triple::aarch64)
2123  ; // iOS does not need any crt1 files for arm64
2124  else if (isIPhoneOSVersionLT(3, 1))
2125  CmdArgs.push_back("-lcrt1.o");
2126  else if (isIPhoneOSVersionLT(6, 0))
2127  CmdArgs.push_back("-lcrt1.3.1.o");
2128  } else {
2129  if (isMacosxVersionLT(10, 5))
2130  CmdArgs.push_back("-lcrt1.o");
2131  else if (isMacosxVersionLT(10, 6))
2132  CmdArgs.push_back("-lcrt1.10.5.o");
2133  else if (isMacosxVersionLT(10, 8))
2134  CmdArgs.push_back("-lcrt1.10.6.o");
2135 
2136  // darwin_crt2 spec is empty.
2137  }
2138  }
2139  }
2140  }
2141  }
2142 
2143  if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
2144  !isTargetWatchOS() &&
2145  isMacosxVersionLT(10, 5)) {
2146  const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
2147  CmdArgs.push_back(Str);
2148  }
2149 }
2150 
2151 void Darwin::CheckObjCARC() const {
2153  (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
2154  return;
2155  getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
2156 }
2157 
2159  const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2161  Res |= SanitizerKind::Address;
2162  Res |= SanitizerKind::Leak;
2163  Res |= SanitizerKind::Fuzzer;
2164  Res |= SanitizerKind::FuzzerNoLink;
2165  Res |= SanitizerKind::Function;
2166  if (isTargetMacOS()) {
2167  if (!isMacosxVersionLT(10, 9))
2168  Res |= SanitizerKind::Vptr;
2169  Res |= SanitizerKind::SafeStack;
2170  if (IsX86_64)
2171  Res |= SanitizerKind::Thread;
2172  } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
2173  if (IsX86_64)
2174  Res |= SanitizerKind::Thread;
2175  }
2176  return Res;
2177 }
2178 
2179 void Darwin::printVerboseInfo(raw_ostream &OS) const {
2180  CudaInstallation.print(OS);
2181 }
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:3971
StringRef getMachOArchName(const llvm::opt::ArgList &Args) const
Get the "MachO" arch name for a particular compiler invocation.
Definition: Darwin.cpp:760
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:482
bool SupportsEmbeddedBitcode() const override
SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
Definition: Darwin.cpp:2013
bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Definition: Darwin.h:406
Tool * buildAssembler() const override
Definition: Darwin.cpp:831
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:3775
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:1993
StringRef P
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Definition: Driver.h:490
Defines types useful for describing an Objective-C runtime.
CXXStdlibType GetDefaultCXXStdlibType() const override
Definition: Darwin.cpp:682
The base class of the type hierarchy.
Definition: Type.h:1353
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
Definition: Darwin.cpp:680
bool embedBitcodeEnabled() const
Definition: Driver.h:313
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:116
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:999
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:228
bool hasBlocksRuntime() const override
Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
Definition: Darwin.cpp:704
types::ID LookupTypeForExtension(StringRef Ext) const override
LookupTypeForExtension - Return the default language type to use for the given extension.
Definition: Darwin.cpp:670
&#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:2022
bool embedBitcodeMarkerOnly() const
Definition: Driver.h:315
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:1984
StringRef getPlatformFamily() const
Definition: Darwin.cpp:939
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:127
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:1044
ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override
Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
Definition: Darwin.cpp:693
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: Darwin.cpp:2020
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:369
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:1656
Tool * getTool(Action::ActionClass AC) const override
Definition: Darwin.cpp:810
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:981
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:391
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:65
types::ID getType() const
Definition: InputInfo.h:78
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: Darwin.cpp:2158
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:2024
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:1999
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:666
&#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:2179
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:1908
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:994
const FunctionProtoType * T
virtual bool SupportsEmbeddedBitcode() const
SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
Definition: ToolChain.h:407
VersionTuple TargetVersion
The OS version we are targeting.
Definition: Darwin.h:284
static const char * ArmMachOArchNameCPU(StringRef CPU)
Definition: Darwin.cpp:741
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:715
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:891
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:185
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:1149
#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:1916
bool SupportsProfiling() const override
SupportsProfiling - Does this tool chain support -pg.
Definition: Darwin.cpp:2029
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:899
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:786
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:835
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:2058
static const char * ArmMachOArchName(StringRef Arch)
Definition: Darwin.cpp:724
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:854
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:634
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:614
static StringRef getSDKName(StringRef isysroot)
Definition: Darwin.cpp:953
void CheckObjCARC() const override
Complain if this tool chain doesn&#39;t support Objective-C ARC.
Definition: Darwin.cpp:2151
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:966
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:1872
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:2034
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:1585
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:829
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:776
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:839
bool isTargetWatchOSSimulator() const
Definition: Darwin.h:378
bool isFilename() const
Definition: InputInfo.h:76
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:280
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:645
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:1032
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:592
bool isAlignedAllocationUnavailable() const
Return true if c++17 aligned allocation/deallocation functions are not implemented in the c++ standar...
Definition: Darwin.cpp:1887
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:1630
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:73