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