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