clang  16.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  UnwindTableLevel
258  getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override;
259 
262  }
263 
264  bool isPICDefault() const override;
265  bool isPIEDefault(const llvm::opt::ArgList &Args) const override;
266  bool isPICDefaultForced() const override;
267 
268  bool SupportsProfiling() const override;
269 
270  bool UseDwarfDebugFlags() const override;
271  std::string GetGlobalDebugPathRemapping() const override;
272 
273  llvm::ExceptionHandling
274  GetExceptionModel(const llvm::opt::ArgList &Args) const override {
276  }
277 
278  virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const {
279  return "";
280  }
281 
282  // Darwin toolchain uses legacy thin LTO API, which is not
283  // capable of unit splitting.
284  bool canSplitThinLTOUnit() const override { return false; }
285  /// }
286 };
287 
288 /// Darwin - The base Darwin tool chain.
289 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
290 public:
291  /// Whether the information on the target has been initialized.
292  //
293  // FIXME: This should be eliminated. What we want to do is make this part of
294  // the "default target for arguments" selection process, once we get out of
295  // the argument translation business.
296  mutable bool TargetInitialized;
297 
304  LastDarwinPlatform = DriverKit
305  };
310  };
311 
314 
315  /// The native OS version we are targeting.
316  mutable VersionTuple TargetVersion;
317  /// The OS version we are targeting as specified in the triple.
318  mutable VersionTuple OSTargetVersion;
319 
320  /// The information about the darwin SDK that was used.
322 
323  /// The target variant triple that was specified (if any).
325 
328 
329 private:
330  void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
331 
332 public:
333  Darwin(const Driver &D, const llvm::Triple &Triple,
334  const llvm::opt::ArgList &Args);
335  ~Darwin() override;
336 
337  std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
338  types::ID InputType) const override;
339 
340  /// @name Apple Specific Toolchain Implementation
341  /// {
342 
343  void addMinVersionArgs(const llvm::opt::ArgList &Args,
344  llvm::opt::ArgStringList &CmdArgs) const override;
345 
346  void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
347  llvm::opt::ArgStringList &CmdArgs) const override;
348 
349  void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
350  llvm::opt::ArgStringList &CmdArgs) const override;
351 
352  bool isKernelStatic() const override {
353  return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
354  !isTargetWatchOS() && !isTargetDriverKit());
355  }
356 
357  void addProfileRTLibs(const llvm::opt::ArgList &Args,
358  llvm::opt::ArgStringList &CmdArgs) const override;
359 
360 protected:
361  /// }
362  /// @name Darwin specific Toolchain functions
363  /// {
364 
365  // FIXME: Eliminate these ...Target functions and derive separate tool chains
366  // for these targets and put version in constructor.
368  unsigned Major, unsigned Minor, unsigned Micro,
369  VersionTuple NativeTargetVersion) const {
370  // FIXME: For now, allow reinitialization as long as values don't
371  // change. This will go away when we move away from argument translation.
372  if (TargetInitialized && TargetPlatform == Platform &&
373  TargetEnvironment == Environment &&
374  (Environment == MacCatalyst ? OSTargetVersion : TargetVersion) ==
375  VersionTuple(Major, Minor, Micro))
376  return;
377 
378  assert(!TargetInitialized && "Target already initialized!");
379  TargetInitialized = true;
380  TargetPlatform = Platform;
381  TargetEnvironment = Environment;
382  TargetVersion = VersionTuple(Major, Minor, Micro);
383  if (Environment == Simulator)
384  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::Simulator);
385  else if (Environment == MacCatalyst) {
386  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::MacABI);
387  TargetVersion = NativeTargetVersion;
388  OSTargetVersion = VersionTuple(Major, Minor, Micro);
389  }
390  }
391 
392 public:
393  bool isTargetIPhoneOS() const {
394  assert(TargetInitialized && "Target not initialized!");
395  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
396  TargetEnvironment == NativeEnvironment;
397  }
398 
399  bool isTargetIOSSimulator() const {
400  assert(TargetInitialized && "Target not initialized!");
401  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
402  TargetEnvironment == Simulator;
403  }
404 
405  bool isTargetIOSBased() const {
406  assert(TargetInitialized && "Target not initialized!");
407  return isTargetIPhoneOS() || isTargetIOSSimulator();
408  }
409 
410  bool isTargetTvOS() const {
411  assert(TargetInitialized && "Target not initialized!");
412  return TargetPlatform == TvOS && TargetEnvironment == NativeEnvironment;
413  }
414 
415  bool isTargetTvOSSimulator() const {
416  assert(TargetInitialized && "Target not initialized!");
417  return TargetPlatform == TvOS && TargetEnvironment == Simulator;
418  }
419 
420  bool isTargetTvOSBased() const {
421  assert(TargetInitialized && "Target not initialized!");
422  return TargetPlatform == TvOS;
423  }
424 
425  bool isTargetWatchOS() const {
426  assert(TargetInitialized && "Target not initialized!");
427  return TargetPlatform == WatchOS && TargetEnvironment == NativeEnvironment;
428  }
429 
431  assert(TargetInitialized && "Target not initialized!");
432  return TargetPlatform == WatchOS && TargetEnvironment == Simulator;
433  }
434 
435  bool isTargetWatchOSBased() const {
436  assert(TargetInitialized && "Target not initialized!");
437  return TargetPlatform == WatchOS;
438  }
439 
440  bool isTargetDriverKit() const {
441  assert(TargetInitialized && "Target not initialized!");
442  return TargetPlatform == DriverKit;
443  }
444 
445  bool isTargetMacCatalyst() const {
446  return TargetPlatform == IPhoneOS && TargetEnvironment == MacCatalyst;
447  }
448 
449  bool isTargetMacOS() const {
450  assert(TargetInitialized && "Target not initialized!");
451  return TargetPlatform == MacOS;
452  }
453 
454  bool isTargetMacOSBased() const {
455  assert(TargetInitialized && "Target not initialized!");
456  return TargetPlatform == MacOS || isTargetMacCatalyst();
457  }
458 
459  bool isTargetAppleSiliconMac() const {
460  assert(TargetInitialized && "Target not initialized!");
461  return isTargetMacOSBased() && getArch() == llvm::Triple::aarch64;
462  }
463 
464  bool isTargetInitialized() const { return TargetInitialized; }
465 
466  /// The version of the OS that's used by the OS specified in the target
467  /// triple. It might be different from the actual target OS on which the
468  /// program will run, e.g. MacCatalyst code runs on a macOS target, but its
469  /// target triple is iOS.
470  VersionTuple getTripleTargetVersion() const {
471  assert(TargetInitialized && "Target not initialized!");
472  return isTargetMacCatalyst() ? OSTargetVersion : TargetVersion;
473  }
474 
475  bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
476  unsigned V2 = 0) const {
477  assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
478  return TargetVersion < VersionTuple(V0, V1, V2);
479  }
480 
481  /// Returns true if the minimum supported macOS version for the slice that's
482  /// being built is less than the specified version. If there's no minimum
483  /// supported macOS version, the deployment target version is compared to the
484  /// specifed version instead.
485  bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
486  assert(isTargetMacOSBased() &&
487  (getTriple().isMacOSX() || getTriple().isMacCatalystEnvironment()) &&
488  "Unexpected call for non OS X target!");
489  // The effective triple might not be initialized yet, so construct a
490  // pseudo-effective triple to get the minimum supported OS version.
491  VersionTuple MinVers =
492  llvm::Triple(getTriple().getArchName(), "apple", "macos")
493  .getMinimumSupportedOSVersion();
494  return (!MinVers.empty() && MinVers > TargetVersion
495  ? MinVers
496  : TargetVersion) < VersionTuple(V0, V1, V2);
497  }
498 
499  /// Returns the darwin target variant triple, the variant of the deployment
500  /// target for which the code is being compiled.
502  return TargetVariantTriple;
503  }
504 
505 protected:
506  /// Return true if c++17 aligned allocation/deallocation functions are not
507  /// implemented in the c++ standard library of the deployment target we are
508  /// targeting.
509  bool isAlignedAllocationUnavailable() const;
510 
511  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
512  llvm::opt::ArgStringList &CC1Args,
513  Action::OffloadKind DeviceOffloadKind) const override;
514 
515  StringRef getPlatformFamily() const;
516  StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const override;
517 
518 public:
519  static StringRef getSDKName(StringRef isysroot);
520 
521  /// }
522  /// @name ToolChain Implementation
523  /// {
524 
525  // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
526  // most development is done against SDKs, so compiling for a different
527  // architecture should not get any special treatment.
528  bool isCrossCompiling() const override { return false; }
529 
530  llvm::opt::DerivedArgList *
531  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
532  Action::OffloadKind DeviceOffloadKind) const override;
533 
534  CXXStdlibType GetDefaultCXXStdlibType() const override;
535  ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
536  bool hasBlocksRuntime() const override;
537 
538  void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
539  llvm::opt::ArgStringList &CC1Args) const override;
540  void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
541  llvm::opt::ArgStringList &CC1Args) const override;
542 
543  bool UseObjCMixedDispatch() const override {
544  // This is only used with the non-fragile ABI and non-legacy dispatch.
545 
546  // Mixed dispatch is used everywhere except OS X before 10.6.
547  return !(isTargetMacOSBased() && isMacosxVersionLT(10, 6));
548  }
549 
551  GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
552  // Stack protectors default to on for user code on 10.5,
553  // and for everything in 10.6 and beyond
554  if (isTargetIOSBased() || isTargetWatchOSBased() || isTargetDriverKit())
555  return LangOptions::SSPOn;
556  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 6))
557  return LangOptions::SSPOn;
558  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
559  return LangOptions::SSPOn;
560 
561  return LangOptions::SSPOff;
562  }
563 
564  void CheckObjCARC() const override;
565 
566  llvm::ExceptionHandling GetExceptionModel(
567  const llvm::opt::ArgList &Args) const override;
568 
569  bool SupportsEmbeddedBitcode() const override;
570 
571  SanitizerMask getSupportedSanitizers() const override;
572 
573  void printVerboseInfo(raw_ostream &OS) const override;
574 };
575 
576 /// DarwinClang - The Darwin toolchain used by Clang.
577 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
578 public:
579  DarwinClang(const Driver &D, const llvm::Triple &Triple,
580  const llvm::opt::ArgList &Args);
581 
582  /// @name Apple ToolChain Implementation
583  /// {
584 
585  RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
586 
587  void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
588  llvm::opt::ArgStringList &CmdArgs,
589  bool ForceLinkBuiltinRT = false) const override;
590 
591  void AddClangCXXStdlibIncludeArgs(
592  const llvm::opt::ArgList &DriverArgs,
593  llvm::opt::ArgStringList &CC1Args) const override;
594 
595  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
596  llvm::opt::ArgStringList &CC1Args) const override;
597 
598  void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
599  llvm::opt::ArgStringList &CmdArgs) const override;
600 
601  void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
602  llvm::opt::ArgStringList &CmdArgs) const override;
603 
604  void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
605 
606  void AddLinkARCArgs(const llvm::opt::ArgList &Args,
607  llvm::opt::ArgStringList &CmdArgs) const override;
608 
609  unsigned GetDefaultDwarfVersion() const override;
610  // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
611  // Darwin defaults to standalone/full debug info.
612  bool GetDefaultStandaloneDebug() const override { return true; }
613  llvm::DebuggerKind getDefaultDebuggerTuning() const override {
614  return llvm::DebuggerKind::LLDB;
615  }
616 
617  /// }
618 
619 private:
620  void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
621  llvm::opt::ArgStringList &CmdArgs,
622  StringRef Sanitizer,
623  bool shared = true) const;
624 
625  bool AddGnuCPlusPlusIncludePaths(const llvm::opt::ArgList &DriverArgs,
626  llvm::opt::ArgStringList &CC1Args,
628  llvm::StringRef Version,
629  llvm::StringRef ArchDir,
630  llvm::StringRef BitDir) const;
631 
633  GetEffectiveSysroot(const llvm::opt::ArgList &DriverArgs) const;
634 };
635 
636 } // end namespace toolchains
637 } // end namespace driver
638 } // end namespace clang
639 
640 #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:551
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:459
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:543
clang::driver::toolchains::Darwin::isTargetWatchOSBased
bool isTargetWatchOSBased() const
Definition: Darwin.h:435
clang::driver::toolchains::Darwin::TargetVersion
VersionTuple TargetVersion
The native OS version we are targeting.
Definition: Darwin.h:316
clang::driver::toolchains::Darwin::isTargetDriverKit
bool isTargetDriverKit() const
Definition: Darwin.h:440
clang::driver::toolchains::Darwin::isTargetIPhoneOS
bool isTargetIPhoneOS() const
Definition: Darwin.h:393
llvm::Optional< VersionTuple >
clang::driver::toolchains::Darwin::WatchOS
@ WatchOS
Definition: Darwin.h:302
clang::driver::toolchains::Darwin::isTargetMacOSBased
bool isTargetMacOSBased() const
Definition: Darwin.h:454
clang::driver::toolchains::Darwin::isCrossCompiling
bool isCrossCompiling() const override
Returns true if the toolchain is targeting a non-native architecture.
Definition: Darwin.h:528
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:501
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:415
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:470
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:326
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:318
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:303
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:420
clang::driver::toolchains::Darwin::isTargetInitialized
bool isTargetInitialized() const
Definition: Darwin.h:464
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:321
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:475
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:289
clang::driver::toolchains::Darwin::isTargetMacCatalyst
bool isTargetMacCatalyst() const
Definition: Darwin.h:445
clang::driver::toolchains::DarwinClang::getDefaultDebuggerTuning
llvm::DebuggerKind getDefaultDebuggerTuning() const override
Definition: Darwin.h:613
clang::driver::toolchains::Darwin::RocmInstallation
RocmInstallationDetector RocmInstallation
Definition: Darwin.h:327
clang::driver::toolchains::Darwin::isTargetMacOS
bool isTargetMacOS() const
Definition: Darwin.h:449
clang::driver::toolchains::Darwin::TargetInitialized
bool TargetInitialized
Whether the information on the target has been initialized.
Definition: Darwin.h:296
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:284
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:312
clang::driver::toolchains::Darwin::setTarget
void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment, unsigned Major, unsigned Minor, unsigned Micro, VersionTuple NativeTargetVersion) const
Definition: Darwin.h:367
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:410
clang::driver::toolchains::Darwin::isTargetWatchOS
bool isTargetWatchOS() const
Definition: Darwin.h:425
clang::driver::toolchains::Darwin::IPhoneOS
@ IPhoneOS
Definition: Darwin.h:300
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:324
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:485
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:352
ROCm.h
clang::driver::toolchains::Darwin::isTargetWatchOSSimulator
bool isTargetWatchOSSimulator() const
Definition: Darwin.h:430
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:399
clang::driver::tools::darwin::StaticLibTool::isLinkJob
bool isLinkJob() const override
Definition: Darwin.h:87
clang::driver::toolchains::Darwin::TvOS
@ TvOS
Definition: Darwin.h:301
clang::driver::toolchains::MachO::getOSLibraryNameSuffix
virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim=false) const
Definition: Darwin.h:278
clang::driver::toolchains::Darwin::MacOS
@ MacOS
Definition: Darwin.h:299
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:405
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:307
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:274
clang::driver::toolchains::Darwin::Simulator
@ Simulator
Definition: Darwin.h:308
clang::driver::toolchains::DarwinClang::GetDefaultStandaloneDebug
bool GetDefaultStandaloneDebug() const override
Definition: Darwin.h:612
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:72
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:306
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:87
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:399
clang::driver::toolchains::MachO::GetDefaultRuntimeLibType
RuntimeLibType GetDefaultRuntimeLibType() const override
GetDefaultRuntimeLibType - Get the default runtime library variant to use.
Definition: Darwin.h:260
clang::driver::toolchains::Darwin::DarwinPlatformKind
DarwinPlatformKind
Definition: Darwin.h:298
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:577
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:313
clang::SanitizerMask
Definition: Sanitizers.h:30
Cuda.h
clang::driver::toolchains::Darwin::MacCatalyst
@ MacCatalyst
Definition: Darwin.h:309