clang  15.0.0git
Darwin.h
Go to the documentation of this file.
1 //===--- Darwin.h - Darwin ToolChain Implementations ------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H
10 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H
11 
12 #include "Cuda.h"
13 #include "ROCm.h"
16 #include "clang/Driver/Tool.h"
17 #include "clang/Driver/ToolChain.h"
18 #include "clang/Driver/XRayArgs.h"
19 
20 namespace clang {
21 namespace driver {
22 
23 namespace toolchains {
24 class MachO;
25 } // end namespace toolchains
26 
27 namespace tools {
28 
29 namespace darwin {
30 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str);
31 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str);
32 
33 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool {
34  virtual void anchor();
35 
36 protected:
37  void AddMachOArch(const llvm::opt::ArgList &Args,
38  llvm::opt::ArgStringList &CmdArgs) const;
39 
41  return reinterpret_cast<const toolchains::MachO &>(getToolChain());
42  }
43 
44 public:
45  MachOTool(const char *Name, const char *ShortName, const ToolChain &TC)
46  : Tool(Name, ShortName, TC) {}
47 };
48 
49 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool {
50 public:
51  Assembler(const ToolChain &TC)
52  : MachOTool("darwin::Assembler", "assembler", TC) {}
53 
54  bool hasIntegratedCPP() const override { return false; }
55 
56  void ConstructJob(Compilation &C, const JobAction &JA,
57  const InputInfo &Output, const InputInfoList &Inputs,
58  const llvm::opt::ArgList &TCArgs,
59  const char *LinkingOutput) const override;
60 };
61 
62 class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool {
63  bool NeedsTempPath(const InputInfoList &Inputs) const;
64  void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args,
65  llvm::opt::ArgStringList &CmdArgs,
66  const InputInfoList &Inputs, VersionTuple Version,
67  bool LinkerIsLLD) const;
68 
69 public:
70  Linker(const ToolChain &TC) : MachOTool("darwin::Linker", "linker", TC) {}
71 
72  bool hasIntegratedCPP() const override { return false; }
73  bool isLinkJob() const override { return true; }
74 
75  void ConstructJob(Compilation &C, const JobAction &JA,
76  const InputInfo &Output, const InputInfoList &Inputs,
77  const llvm::opt::ArgList &TCArgs,
78  const char *LinkingOutput) const override;
79 };
80 
81 class LLVM_LIBRARY_VISIBILITY StaticLibTool : public MachOTool {
82 public:
84  : MachOTool("darwin::StaticLibTool", "static-lib-linker", TC) {}
85 
86  bool hasIntegratedCPP() const override { return false; }
87  bool isLinkJob() const override { return true; }
88 
89  void ConstructJob(Compilation &C, const JobAction &JA,
90  const InputInfo &Output, const InputInfoList &Inputs,
91  const llvm::opt::ArgList &TCArgs,
92  const char *LinkingOutput) const override;
93 };
94 
95 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool {
96 public:
97  Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {}
98 
99  bool hasIntegratedCPP() const override { return false; }
100 
101  void ConstructJob(Compilation &C, const JobAction &JA,
102  const InputInfo &Output, const InputInfoList &Inputs,
103  const llvm::opt::ArgList &TCArgs,
104  const char *LinkingOutput) const override;
105 };
106 
107 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool {
108 public:
109  Dsymutil(const ToolChain &TC)
110  : MachOTool("darwin::Dsymutil", "dsymutil", TC) {}
111 
112  bool hasIntegratedCPP() const override { return false; }
113  bool isDsymutilJob() const override { return true; }
114 
115  void ConstructJob(Compilation &C, const JobAction &JA,
116  const InputInfo &Output, const InputInfoList &Inputs,
117  const llvm::opt::ArgList &TCArgs,
118  const char *LinkingOutput) const override;
119 };
120 
121 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool {
122 public:
124  : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {}
125 
126  bool hasIntegratedCPP() const override { return false; }
127 
128  void ConstructJob(Compilation &C, const JobAction &JA,
129  const InputInfo &Output, const InputInfoList &Inputs,
130  const llvm::opt::ArgList &TCArgs,
131  const char *LinkingOutput) const override;
132 };
133 } // end namespace darwin
134 } // end namespace tools
135 
136 namespace toolchains {
137 
138 class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain {
139 protected:
140  Tool *buildAssembler() const override;
141  Tool *buildLinker() const override;
142  Tool *buildStaticLibTool() const override;
143  Tool *getTool(Action::ActionClass AC) const override;
144 
145 private:
146  mutable std::unique_ptr<tools::darwin::Lipo> Lipo;
147  mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil;
148  mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug;
149 
150  /// The version of the linker known to be available in the tool chain.
151  mutable Optional<VersionTuple> LinkerVersion;
152 
153 public:
154  MachO(const Driver &D, const llvm::Triple &Triple,
155  const llvm::opt::ArgList &Args);
156  ~MachO() override;
157 
158  /// @name MachO specific toolchain API
159  /// {
160 
161  /// Get the "MachO" arch name for a particular compiler invocation. For
162  /// example, Apple treats different ARM variations as distinct architectures.
163  StringRef getMachOArchName(const llvm::opt::ArgList &Args) const;
164 
165  /// Get the version of the linker known to be available for a particular
166  /// compiler invocation (via the `-mlinker-version=` arg).
167  VersionTuple getLinkerVersion(const llvm::opt::ArgList &Args) const;
168 
169  /// Add the linker arguments to link the ARC runtime library.
170  virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
171  llvm::opt::ArgStringList &CmdArgs) const {}
172 
173  /// Add the linker arguments to link the compiler runtime library.
174  ///
175  /// FIXME: This API is intended for use with embedded libraries only, and is
176  /// misleadingly named.
177  virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
178  llvm::opt::ArgStringList &CmdArgs,
179  bool ForceLinkBuiltinRT = false) const;
180 
181  virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
182  llvm::opt::ArgStringList &CmdArgs) const {
183  }
184 
185  virtual void addMinVersionArgs(const llvm::opt::ArgList &Args,
186  llvm::opt::ArgStringList &CmdArgs) const {}
187 
188  virtual void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
189  llvm::opt::ArgStringList &CmdArgs) const {
190  }
191 
192  /// On some iOS platforms, kernel and kernel modules were built statically. Is
193  /// this such a target?
194  virtual bool isKernelStatic() const { return false; }
195 
196  /// Is the target either iOS or an iOS simulator?
197  bool isTargetIOSBased() const { return false; }
198 
199  /// Options to control how a runtime library is linked.
200  enum RuntimeLinkOptions : unsigned {
201  /// Link the library in even if it can't be found in the VFS.
202  RLO_AlwaysLink = 1 << 0,
203 
204  /// Use the embedded runtime from the macho_embedded directory.
205  RLO_IsEmbedded = 1 << 1,
206 
207  /// Emit rpaths for @executable_path as well as the resource directory.
208  RLO_AddRPath = 1 << 2,
209  };
210 
211  /// Add a runtime library to the list of items to link.
212  void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
213  llvm::opt::ArgStringList &CmdArgs, StringRef Component,
214  RuntimeLinkOptions Opts = RuntimeLinkOptions(),
215  bool IsShared = false) const;
216 
217  /// Add any profiling runtime libraries that are needed. This is essentially a
218  /// MachO specific version of addProfileRT in Tools.cpp.
219  void addProfileRTLibs(const llvm::opt::ArgList &Args,
220  llvm::opt::ArgStringList &CmdArgs) const override {
221  // There aren't any profiling libs for embedded targets currently.
222  }
223 
224  /// }
225  /// @name ToolChain Implementation
226  /// {
227 
228  types::ID LookupTypeForExtension(StringRef Ext) const override;
229 
230  bool HasNativeLLVMSupport() const override;
231 
232  llvm::opt::DerivedArgList *
233  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
234  Action::OffloadKind DeviceOffloadKind) const override;
235 
236  bool IsBlocksDefault() const override {
237  // Always allow blocks on Apple; users interested in versioning are
238  // expected to use /usr/include/Block.h.
239  return true;
240  }
241  bool IsIntegratedAssemblerDefault() const override {
242  // Default integrated assembler to on for Apple's MachO targets.
243  return true;
244  }
245 
246  bool IsMathErrnoDefault() const override { return false; }
247 
248  bool IsEncodeExtendedBlockSignatureDefault() const override { return true; }
249 
250  bool IsObjCNonFragileABIDefault() const override {
251  // Non-fragile ABI is default for everything but i386.
252  return getTriple().getArch() != llvm::Triple::x86;
253  }
254 
255  bool UseObjCMixedDispatch() const override { return true; }
256 
257  bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
258 
261  }
262 
263  bool isPICDefault() const override;
264  bool isPIEDefault(const llvm::opt::ArgList &Args) const override;
265  bool isPICDefaultForced() const override;
266 
267  bool SupportsProfiling() const override;
268 
269  bool UseDwarfDebugFlags() const override;
270  std::string GetGlobalDebugPathRemapping() const override;
271 
272  llvm::ExceptionHandling
273  GetExceptionModel(const llvm::opt::ArgList &Args) const override {
275  }
276 
277  virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const {
278  return "";
279  }
280 
281  // Darwin toolchain uses legacy thin LTO API, which is not
282  // capable of unit splitting.
283  bool canSplitThinLTOUnit() const override { return false; }
284  /// }
285 };
286 
287 /// Darwin - The base Darwin tool chain.
288 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
289 public:
290  /// Whether the information on the target has been initialized.
291  //
292  // FIXME: This should be eliminated. What we want to do is make this part of
293  // the "default target for arguments" selection process, once we get out of
294  // the argument translation business.
295  mutable bool TargetInitialized;
296 
303  LastDarwinPlatform = DriverKit
304  };
309  };
310 
313 
314  /// The native OS version we are targeting.
315  mutable VersionTuple TargetVersion;
316  /// The OS version we are targeting as specified in the triple.
317  mutable VersionTuple OSTargetVersion;
318 
319  /// The information about the darwin SDK that was used.
321 
322  /// The target variant triple that was specified (if any).
324 
327 
328 private:
329  void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
330 
331 public:
332  Darwin(const Driver &D, const llvm::Triple &Triple,
333  const llvm::opt::ArgList &Args);
334  ~Darwin() override;
335 
336  std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
337  types::ID InputType) const override;
338 
339  /// @name Apple Specific Toolchain Implementation
340  /// {
341 
342  void addMinVersionArgs(const llvm::opt::ArgList &Args,
343  llvm::opt::ArgStringList &CmdArgs) const override;
344 
345  void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
346  llvm::opt::ArgStringList &CmdArgs) const override;
347 
348  void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
349  llvm::opt::ArgStringList &CmdArgs) const override;
350 
351  bool isKernelStatic() const override {
352  return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
353  !isTargetWatchOS() && !isTargetDriverKit());
354  }
355 
356  void addProfileRTLibs(const llvm::opt::ArgList &Args,
357  llvm::opt::ArgStringList &CmdArgs) const override;
358 
359 protected:
360  /// }
361  /// @name Darwin specific Toolchain functions
362  /// {
363 
364  // FIXME: Eliminate these ...Target functions and derive separate tool chains
365  // for these targets and put version in constructor.
367  unsigned Major, unsigned Minor, unsigned Micro,
368  VersionTuple NativeTargetVersion) const {
369  // FIXME: For now, allow reinitialization as long as values don't
370  // change. This will go away when we move away from argument translation.
371  if (TargetInitialized && TargetPlatform == Platform &&
372  TargetEnvironment == Environment &&
373  (Environment == MacCatalyst ? OSTargetVersion : TargetVersion) ==
374  VersionTuple(Major, Minor, Micro))
375  return;
376 
377  assert(!TargetInitialized && "Target already initialized!");
378  TargetInitialized = true;
379  TargetPlatform = Platform;
380  TargetEnvironment = Environment;
381  TargetVersion = VersionTuple(Major, Minor, Micro);
382  if (Environment == Simulator)
383  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::Simulator);
384  else if (Environment == MacCatalyst) {
385  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::MacABI);
386  TargetVersion = NativeTargetVersion;
387  OSTargetVersion = VersionTuple(Major, Minor, Micro);
388  }
389  }
390 
391 public:
392  bool isTargetIPhoneOS() const {
393  assert(TargetInitialized && "Target not initialized!");
394  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
395  TargetEnvironment == NativeEnvironment;
396  }
397 
398  bool isTargetIOSSimulator() const {
399  assert(TargetInitialized && "Target not initialized!");
400  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
401  TargetEnvironment == Simulator;
402  }
403 
404  bool isTargetIOSBased() const {
405  assert(TargetInitialized && "Target not initialized!");
406  return isTargetIPhoneOS() || isTargetIOSSimulator();
407  }
408 
409  bool isTargetTvOS() const {
410  assert(TargetInitialized && "Target not initialized!");
411  return TargetPlatform == TvOS && TargetEnvironment == NativeEnvironment;
412  }
413 
414  bool isTargetTvOSSimulator() const {
415  assert(TargetInitialized && "Target not initialized!");
416  return TargetPlatform == TvOS && TargetEnvironment == Simulator;
417  }
418 
419  bool isTargetTvOSBased() const {
420  assert(TargetInitialized && "Target not initialized!");
421  return TargetPlatform == TvOS;
422  }
423 
424  bool isTargetWatchOS() const {
425  assert(TargetInitialized && "Target not initialized!");
426  return TargetPlatform == WatchOS && TargetEnvironment == NativeEnvironment;
427  }
428 
430  assert(TargetInitialized && "Target not initialized!");
431  return TargetPlatform == WatchOS && TargetEnvironment == Simulator;
432  }
433 
434  bool isTargetWatchOSBased() const {
435  assert(TargetInitialized && "Target not initialized!");
436  return TargetPlatform == WatchOS;
437  }
438 
439  bool isTargetDriverKit() const {
440  assert(TargetInitialized && "Target not initialized!");
441  return TargetPlatform == DriverKit;
442  }
443 
444  bool isTargetMacCatalyst() const {
445  return TargetPlatform == IPhoneOS && TargetEnvironment == MacCatalyst;
446  }
447 
448  bool isTargetMacOS() const {
449  assert(TargetInitialized && "Target not initialized!");
450  return TargetPlatform == MacOS;
451  }
452 
453  bool isTargetMacOSBased() const {
454  assert(TargetInitialized && "Target not initialized!");
455  return TargetPlatform == MacOS || isTargetMacCatalyst();
456  }
457 
458  bool isTargetAppleSiliconMac() const {
459  assert(TargetInitialized && "Target not initialized!");
460  return isTargetMacOSBased() && getArch() == llvm::Triple::aarch64;
461  }
462 
463  bool isTargetInitialized() const { return TargetInitialized; }
464 
465  /// The version of the OS that's used by the OS specified in the target
466  /// triple. It might be different from the actual target OS on which the
467  /// program will run, e.g. MacCatalyst code runs on a macOS target, but its
468  /// target triple is iOS.
469  VersionTuple getTripleTargetVersion() const {
470  assert(TargetInitialized && "Target not initialized!");
471  return isTargetMacCatalyst() ? OSTargetVersion : TargetVersion;
472  }
473 
474  bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
475  unsigned V2 = 0) const {
476  assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
477  return TargetVersion < VersionTuple(V0, V1, V2);
478  }
479 
480  /// Returns true if the minimum supported macOS version for the slice that's
481  /// being built is less than the specified version. If there's no minimum
482  /// supported macOS version, the deployment target version is compared to the
483  /// specifed version instead.
484  bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
485  assert(isTargetMacOSBased() &&
486  (getTriple().isMacOSX() || getTriple().isMacCatalystEnvironment()) &&
487  "Unexpected call for non OS X target!");
488  // The effective triple might not be initialized yet, so construct a
489  // pseudo-effective triple to get the minimum supported OS version.
490  VersionTuple MinVers =
491  llvm::Triple(getTriple().getArchName(), "apple", "macos")
492  .getMinimumSupportedOSVersion();
493  return (!MinVers.empty() && MinVers > TargetVersion
494  ? MinVers
495  : TargetVersion) < VersionTuple(V0, V1, V2);
496  }
497 
498  /// Returns the darwin target variant triple, the variant of the deployment
499  /// target for which the code is being compiled.
501  return TargetVariantTriple;
502  }
503 
504 protected:
505  /// Return true if c++17 aligned allocation/deallocation functions are not
506  /// implemented in the c++ standard library of the deployment target we are
507  /// targeting.
508  bool isAlignedAllocationUnavailable() const;
509 
510  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
511  llvm::opt::ArgStringList &CC1Args,
512  Action::OffloadKind DeviceOffloadKind) const override;
513 
514  StringRef getPlatformFamily() const;
515  StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const override;
516 
517 public:
518  static StringRef getSDKName(StringRef isysroot);
519 
520  /// }
521  /// @name ToolChain Implementation
522  /// {
523 
524  // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
525  // most development is done against SDKs, so compiling for a different
526  // architecture should not get any special treatment.
527  bool isCrossCompiling() const override { return false; }
528 
529  llvm::opt::DerivedArgList *
530  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
531  Action::OffloadKind DeviceOffloadKind) const override;
532 
533  CXXStdlibType GetDefaultCXXStdlibType() const override;
534  ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
535  bool hasBlocksRuntime() const override;
536 
537  void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
538  llvm::opt::ArgStringList &CC1Args) const override;
539  void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
540  llvm::opt::ArgStringList &CC1Args) const override;
541 
542  bool UseObjCMixedDispatch() const override {
543  // This is only used with the non-fragile ABI and non-legacy dispatch.
544 
545  // Mixed dispatch is used everywhere except OS X before 10.6.
546  return !(isTargetMacOSBased() && isMacosxVersionLT(10, 6));
547  }
548 
550  GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
551  // Stack protectors default to on for user code on 10.5,
552  // and for everything in 10.6 and beyond
553  if (isTargetIOSBased() || isTargetWatchOSBased() || isTargetDriverKit())
554  return LangOptions::SSPOn;
555  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 6))
556  return LangOptions::SSPOn;
557  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
558  return LangOptions::SSPOn;
559 
560  return LangOptions::SSPOff;
561  }
562 
563  void CheckObjCARC() const override;
564 
565  llvm::ExceptionHandling GetExceptionModel(
566  const llvm::opt::ArgList &Args) const override;
567 
568  bool SupportsEmbeddedBitcode() const override;
569 
570  SanitizerMask getSupportedSanitizers() const override;
571 
572  void printVerboseInfo(raw_ostream &OS) const override;
573 };
574 
575 /// DarwinClang - The Darwin toolchain used by Clang.
576 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
577 public:
578  DarwinClang(const Driver &D, const llvm::Triple &Triple,
579  const llvm::opt::ArgList &Args);
580 
581  /// @name Apple ToolChain Implementation
582  /// {
583 
584  RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
585 
586  void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
587  llvm::opt::ArgStringList &CmdArgs,
588  bool ForceLinkBuiltinRT = false) const override;
589 
590  void AddClangCXXStdlibIncludeArgs(
591  const llvm::opt::ArgList &DriverArgs,
592  llvm::opt::ArgStringList &CC1Args) const override;
593 
594  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
595  llvm::opt::ArgStringList &CC1Args) const override;
596 
597  void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
598  llvm::opt::ArgStringList &CmdArgs) const override;
599 
600  void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
601  llvm::opt::ArgStringList &CmdArgs) const override;
602 
603  void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
604 
605  void AddLinkARCArgs(const llvm::opt::ArgList &Args,
606  llvm::opt::ArgStringList &CmdArgs) const override;
607 
608  unsigned GetDefaultDwarfVersion() const override;
609  // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
610  // Darwin defaults to standalone/full debug info.
611  bool GetDefaultStandaloneDebug() const override { return true; }
612  llvm::DebuggerKind getDefaultDebuggerTuning() const override {
613  return llvm::DebuggerKind::LLDB;
614  }
615 
616  /// }
617 
618 private:
619  void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
620  llvm::opt::ArgStringList &CmdArgs,
621  StringRef Sanitizer,
622  bool shared = true) const;
623 
624  bool AddGnuCPlusPlusIncludePaths(const llvm::opt::ArgList &DriverArgs,
625  llvm::opt::ArgStringList &CC1Args,
627  llvm::StringRef Version,
628  llvm::StringRef ArchDir,
629  llvm::StringRef BitDir) const;
630 
631  llvm::StringRef GetHeaderSysroot(const llvm::opt::ArgList &DriverArgs) const;
632 };
633 
634 } // end namespace toolchains
635 } // end namespace driver
636 } // end namespace clang
637 
638 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_DARWIN_H
clang::driver::toolchains::Darwin::GetDefaultStackProtectorLevel
LangOptions::StackProtectorMode GetDefaultStackProtectorLevel(bool KernelOrKext) const override
GetDefaultStackProtectorLevel - Get the default stack protector level for this tool chain.
Definition: Darwin.h:550
clang::driver::tools::darwin::Dsymutil::isDsymutilJob
bool isDsymutilJob() const override
Definition: Darwin.h:113
clang::driver::toolchains::MachO::addPlatformVersionArgs
virtual void addPlatformVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:188
clang::driver::tools::darwin::MachOTool
Definition: Darwin.h:33
XRayArgs.h
clang::driver::toolchains::MachO::addStartObjectFileArgs
virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:181
clang::LangOptions::StackProtectorMode
StackProtectorMode
Definition: LangOptions.h:84
clang::driver::toolchains::Darwin::isTargetAppleSiliconMac
bool isTargetAppleSiliconMac() const
Definition: Darwin.h:458
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::tools::darwin::Assembler
Definition: Darwin.h:49
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::Action::ActionClass
ActionClass
Definition: Action.h:55
clang::driver::toolchains::Darwin::UseObjCMixedDispatch
bool UseObjCMixedDispatch() const override
UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the mixed dispatch method be use...
Definition: Darwin.h:542
clang::driver::toolchains::Darwin::isTargetWatchOSBased
bool isTargetWatchOSBased() const
Definition: Darwin.h:434
clang::driver::toolchains::Darwin::TargetVersion
VersionTuple TargetVersion
The native OS version we are targeting.
Definition: Darwin.h:315
clang::driver::toolchains::Darwin::isTargetDriverKit
bool isTargetDriverKit() const
Definition: Darwin.h:439
clang::driver::toolchains::Darwin::isTargetIPhoneOS
bool isTargetIPhoneOS() const
Definition: Darwin.h:392
llvm::Optional< VersionTuple >
clang::driver::toolchains::Darwin::WatchOS
@ WatchOS
Definition: Darwin.h:301
clang::driver::toolchains::Darwin::isTargetMacOSBased
bool isTargetMacOSBased() const
Definition: Darwin.h:453
clang::driver::toolchains::Darwin::isCrossCompiling
bool isCrossCompiling() const override
Returns true if the toolchain is targeting a non-native architecture.
Definition: Darwin.h:527
clang::driver::tools::darwin::getArchTypeForMachOArchName
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Darwin.cpp:41
clang::driver::toolchains::Darwin::getTargetVariantTriple
Optional< llvm::Triple > getTargetVariantTriple() const override
Returns the darwin target variant triple, the variant of the deployment target for which the code is ...
Definition: Darwin.h:500
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::toolchains::Darwin::isTargetTvOSSimulator
bool isTargetTvOSSimulator() const
Definition: Darwin.h:414
clang::driver::toolchains::Darwin::getTripleTargetVersion
VersionTuple getTripleTargetVersion() const
The version of the OS that's used by the OS specified in the target triple.
Definition: Darwin.h:469
clang::driver::tools::darwin::Linker
Definition: Darwin.h:62
clang::driver::ToolChain::RuntimeLibType
RuntimeLibType
Definition: ToolChain.h:100
clang::driver::tools::darwin::Dsymutil::Dsymutil
Dsymutil(const ToolChain &TC)
Definition: Darwin.h:109
clang::driver::tools::darwin::Assembler::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:54
clang::driver::toolchains::Darwin::CudaInstallation
CudaInstallationDetector CudaInstallation
Definition: Darwin.h:325
clang::driver::tools::darwin::Lipo::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:99
clang::driver::toolchains::Darwin::OSTargetVersion
VersionTuple OSTargetVersion
The OS version we are targeting as specified in the triple.
Definition: Darwin.h:317
clang::driver::tools::darwin::MachOTool::MachOTool
MachOTool(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Darwin.h:45
clang::LangOptions::SSPOff
@ SSPOff
Definition: LangOptions.h:84
clang::driver::toolchains::Darwin::DriverKit
@ DriverKit
Definition: Darwin.h:302
clang::driver::toolchains::MachO::RuntimeLinkOptions
RuntimeLinkOptions
Options to control how a runtime library is linked.
Definition: Darwin.h:200
clang::driver::toolchains::Darwin::isTargetTvOSBased
bool isTargetTvOSBased() const
Definition: Darwin.h:419
clang::driver::toolchains::Darwin::isTargetInitialized
bool isTargetInitialized() const
Definition: Darwin.h:463
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
clang::driver::toolchains::Darwin::SDKInfo
Optional< DarwinSDKInfo > SDKInfo
The information about the darwin SDK that was used.
Definition: Darwin.h:320
clang::driver::tools::darwin::Linker::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:72
clang::driver::toolchains::Darwin::isIPhoneOSVersionLT
bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Definition: Darwin.h:474
LangOptions.h
clang::driver::toolchains::MachO::IsIntegratedAssemblerDefault
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Definition: Darwin.h:241
clang::driver::toolchains::MachO::IsEncodeExtendedBlockSignatureDefault
bool IsEncodeExtendedBlockSignatureDefault() const override
IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable -fencode-extended-block-signature...
Definition: Darwin.h:248
clang::driver::toolchains::Darwin
Darwin - The base Darwin tool chain.
Definition: Darwin.h:288
clang::driver::toolchains::Darwin::isTargetMacCatalyst
bool isTargetMacCatalyst() const
Definition: Darwin.h:444
clang::driver::toolchains::DarwinClang::getDefaultDebuggerTuning
llvm::DebuggerKind getDefaultDebuggerTuning() const override
Definition: Darwin.h:612
clang::driver::toolchains::Darwin::RocmInstallation
RocmInstallationDetector RocmInstallation
Definition: Darwin.h:326
clang::driver::toolchains::Darwin::isTargetMacOS
bool isTargetMacOS() const
Definition: Darwin.h:448
clang::driver::toolchains::Darwin::TargetInitialized
bool TargetInitialized
Whether the information on the target has been initialized.
Definition: Darwin.h:295
Tool.h
llvm::SmallString< 128 >
clang::driver::tools::darwin::Assembler::Assembler
Assembler(const ToolChain &TC)
Definition: Darwin.h:51
clang::driver::toolchains::MachO::IsMathErrnoDefault
bool IsMathErrnoDefault() const override
IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
Definition: Darwin.h:246
clang::driver::toolchains::MachO::canSplitThinLTOUnit
bool canSplitThinLTOUnit() const override
Returns true when it's possible to split LTO unit to use whole program devirtualization and CFI santi...
Definition: Darwin.h:283
clang::driver::toolchains::MachO::isTargetIOSBased
bool isTargetIOSBased() const
Is the target either iOS or an iOS simulator?
Definition: Darwin.h:197
clang::driver::tools::darwin::Dsymutil::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:112
clang::driver::tools::darwin::Lipo
Definition: Darwin.h:95
clang::driver::toolchains::Darwin::TargetPlatform
DarwinPlatformKind TargetPlatform
Definition: Darwin.h:311
clang::driver::toolchains::Darwin::setTarget
void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment, unsigned Major, unsigned Minor, unsigned Micro, VersionTuple NativeTargetVersion) const
Definition: Darwin.h:366
clang::driver::toolchains::MachO::IsBlocksDefault
bool IsBlocksDefault() const override
IsBlocksDefault - Does this tool chain enable -fblocks by default.
Definition: Darwin.h:236
Base
clang::driver::tools::darwin::StaticLibTool::StaticLibTool
StaticLibTool(const ToolChain &TC)
Definition: Darwin.h:83
clang::driver::toolchains::Darwin::isTargetTvOS
bool isTargetTvOS() const
Definition: Darwin.h:409
clang::driver::toolchains::Darwin::isTargetWatchOS
bool isTargetWatchOS() const
Definition: Darwin.h:424
clang::driver::toolchains::Darwin::IPhoneOS
@ IPhoneOS
Definition: Darwin.h:299
clang::driver::tools::darwin::Dsymutil
Definition: Darwin.h:107
clang::driver::toolchains::MachO::isKernelStatic
virtual bool isKernelStatic() const
On some iOS platforms, kernel and kernel modules were built statically.
Definition: Darwin.h:194
clang::driver::toolchains::Darwin::TargetVariantTriple
Optional< llvm::Triple > TargetVariantTriple
The target variant triple that was specified (if any).
Definition: Darwin.h:323
clang::driver::toolchains::Darwin::isMacosxVersionLT
bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Returns true if the minimum supported macOS version for the slice that's being built is less than the...
Definition: Darwin.h:484
clang::driver::tools::darwin::Lipo::Lipo
Lipo(const ToolChain &TC)
Definition: Darwin.h:97
ToolChain.h
clang::driver::toolchains::Darwin::isKernelStatic
bool isKernelStatic() const override
On some iOS platforms, kernel and kernel modules were built statically.
Definition: Darwin.h:351
ROCm.h
clang::driver::toolchains::Darwin::isTargetWatchOSSimulator
bool isTargetWatchOSSimulator() const
Definition: Darwin.h:429
clang::driver::tools::darwin::StaticLibTool
Definition: Darwin.h:81
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
clang::driver::ToolChain::RLT_CompilerRT
@ RLT_CompilerRT
Definition: ToolChain.h:101
clang::driver::toolchains::Darwin::isTargetIOSSimulator
bool isTargetIOSSimulator() const
Definition: Darwin.h:398
clang::driver::tools::darwin::StaticLibTool::isLinkJob
bool isLinkJob() const override
Definition: Darwin.h:87
clang::driver::toolchains::Darwin::TvOS
@ TvOS
Definition: Darwin.h:300
clang::driver::toolchains::MachO::getOSLibraryNameSuffix
virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim=false) const
Definition: Darwin.h:277
clang::driver::toolchains::Darwin::MacOS
@ MacOS
Definition: Darwin.h:298
clang::LangOptions::SSPOn
@ SSPOn
Definition: LangOptions.h:84
clang::driver::tools::darwin::setTripleTypeForMachOArchName
void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str)
Definition: Darwin.cpp:77
clang::driver::toolchains::Darwin::isTargetIOSBased
bool isTargetIOSBased() const
Definition: Darwin.h:404
clang::driver::CudaInstallationDetector
A class to find a viable CUDA installation.
Definition: Cuda.h:28
clang::driver::types::ID
ID
Definition: Types.h:23
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::toolchains::Darwin::NativeEnvironment
@ NativeEnvironment
Definition: Darwin.h:306
clang::ObjCRuntime
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:28
clang::driver::RocmInstallationDetector
A class to find a viable ROCM installation TODO: Generalize to handle libclc.
Definition: ROCm.h:47
clang::driver::toolchains::MachO::GetExceptionModel
llvm::ExceptionHandling GetExceptionModel(const llvm::opt::ArgList &Args) const override
GetExceptionModel - Return the tool chain exception model.
Definition: Darwin.h:273
clang::driver::toolchains::Darwin::Simulator
@ Simulator
Definition: Darwin.h:307
clang::driver::toolchains::DarwinClang::GetDefaultStandaloneDebug
bool GetDefaultStandaloneDebug() const override
Definition: Darwin.h:611
clang::driver::toolchains::MachO::AddLinkARCArgs
virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Add the linker arguments to link the ARC runtime library.
Definition: Darwin.h:170
clang
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:71
clang::driver::toolchains::MachO::UseObjCMixedDispatch
bool UseObjCMixedDispatch() const override
UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the mixed dispatch method be use...
Definition: Darwin.h:255
clang::driver::toolchains::MachO::addProfileRTLibs
void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add any profiling runtime libraries that are needed.
Definition: Darwin.h:219
clang::driver::toolchains::MachO
Definition: Darwin.h:138
clang::driver::tools::darwin::VerifyDebug
Definition: Darwin.h:121
DarwinSDKInfo.h
clang::driver::toolchains::Darwin::DarwinEnvironmentKind
DarwinEnvironmentKind
Definition: Darwin.h:305
clang::driver::toolchains::MachO::addMinVersionArgs
virtual void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:185
clang::driver::toolchains::MachO::IsObjCNonFragileABIDefault
bool IsObjCNonFragileABIDefault() const override
IsObjCNonFragileABIDefault - Does this tool chain set -fobjc-nonfragile-abi by default.
Definition: Darwin.h:250
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:88
clang::driver::tools::darwin::VerifyDebug::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:126
clang::driver::tools::darwin::MachOTool::getMachOToolChain
const toolchains::MachO & getMachOToolChain() const
Definition: Darwin.h:40
clang::driver::tools::darwin::StaticLibTool::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Darwin.h:86
clang::driver::JobAction
Definition: Action.h:395
clang::driver::toolchains::MachO::GetDefaultRuntimeLibType
RuntimeLibType GetDefaultRuntimeLibType() const override
GetDefaultRuntimeLibType - Get the default runtime library variant to use.
Definition: Darwin.h:259
clang::driver::toolchains::Darwin::DarwinPlatformKind
DarwinPlatformKind
Definition: Darwin.h:297
clang::driver::tools::darwin::Linker::isLinkJob
bool isLinkJob() const override
Definition: Darwin.h:73
clang::driver::toolchains::DarwinClang
DarwinClang - The Darwin toolchain used by Clang.
Definition: Darwin.h:576
clang::driver::tools::darwin::VerifyDebug::VerifyDebug
VerifyDebug(const ToolChain &TC)
Definition: Darwin.h:123
clang::driver::tools::darwin::Linker::Linker
Linker(const ToolChain &TC)
Definition: Darwin.h:70
clang::driver::toolchains::Darwin::TargetEnvironment
DarwinEnvironmentKind TargetEnvironment
Definition: Darwin.h:312
clang::SanitizerMask
Definition: Sanitizers.h:30
Cuda.h
clang::driver::toolchains::Darwin::MacCatalyst
@ MacCatalyst
Definition: Darwin.h:308