clang  14.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, unsigned Version[5],
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 public:
151  MachO(const Driver &D, const llvm::Triple &Triple,
152  const llvm::opt::ArgList &Args);
153  ~MachO() override;
154 
155  /// @name MachO specific toolchain API
156  /// {
157 
158  /// Get the "MachO" arch name for a particular compiler invocation. For
159  /// example, Apple treats different ARM variations as distinct architectures.
160  StringRef getMachOArchName(const llvm::opt::ArgList &Args) const;
161 
162  /// Add the linker arguments to link the ARC runtime library.
163  virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args,
164  llvm::opt::ArgStringList &CmdArgs) const {}
165 
166  /// Add the linker arguments to link the compiler runtime library.
167  ///
168  /// FIXME: This API is intended for use with embedded libraries only, and is
169  /// misleadingly named.
170  virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
171  llvm::opt::ArgStringList &CmdArgs,
172  bool ForceLinkBuiltinRT = false) const;
173 
174  virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
175  llvm::opt::ArgStringList &CmdArgs) const {
176  }
177 
178  virtual void addMinVersionArgs(const llvm::opt::ArgList &Args,
179  llvm::opt::ArgStringList &CmdArgs) const {}
180 
181  virtual void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
182  llvm::opt::ArgStringList &CmdArgs) const {
183  }
184 
185  /// On some iOS platforms, kernel and kernel modules were built statically. Is
186  /// this such a target?
187  virtual bool isKernelStatic() const { return false; }
188 
189  /// Is the target either iOS or an iOS simulator?
190  bool isTargetIOSBased() const { return false; }
191 
192  /// Options to control how a runtime library is linked.
193  enum RuntimeLinkOptions : unsigned {
194  /// Link the library in even if it can't be found in the VFS.
195  RLO_AlwaysLink = 1 << 0,
196 
197  /// Use the embedded runtime from the macho_embedded directory.
198  RLO_IsEmbedded = 1 << 1,
199 
200  /// Emit rpaths for @executable_path as well as the resource directory.
201  RLO_AddRPath = 1 << 2,
202  };
203 
204  /// Add a runtime library to the list of items to link.
205  void AddLinkRuntimeLib(const llvm::opt::ArgList &Args,
206  llvm::opt::ArgStringList &CmdArgs, StringRef Component,
207  RuntimeLinkOptions Opts = RuntimeLinkOptions(),
208  bool IsShared = false) const;
209 
210  /// Add any profiling runtime libraries that are needed. This is essentially a
211  /// MachO specific version of addProfileRT in Tools.cpp.
212  void addProfileRTLibs(const llvm::opt::ArgList &Args,
213  llvm::opt::ArgStringList &CmdArgs) const override {
214  // There aren't any profiling libs for embedded targets currently.
215  }
216 
217  /// }
218  /// @name ToolChain Implementation
219  /// {
220 
221  types::ID LookupTypeForExtension(StringRef Ext) const override;
222 
223  bool HasNativeLLVMSupport() const override;
224 
225  llvm::opt::DerivedArgList *
226  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
227  Action::OffloadKind DeviceOffloadKind) const override;
228 
229  bool IsBlocksDefault() const override {
230  // Always allow blocks on Apple; users interested in versioning are
231  // expected to use /usr/include/Block.h.
232  return true;
233  }
234  bool IsIntegratedAssemblerDefault() const override {
235  // Default integrated assembler to on for Apple's MachO targets.
236  return true;
237  }
238 
239  bool IsMathErrnoDefault() const override { return false; }
240 
241  bool IsEncodeExtendedBlockSignatureDefault() const override { return true; }
242 
243  bool IsObjCNonFragileABIDefault() const override {
244  // Non-fragile ABI is default for everything but i386.
245  return getTriple().getArch() != llvm::Triple::x86;
246  }
247 
248  bool UseObjCMixedDispatch() const override { return true; }
249 
250  bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
251 
254  }
255 
256  bool isPICDefault() const override;
257  bool isPIEDefault(const llvm::opt::ArgList &Args) const override;
258  bool isPICDefaultForced() const override;
259 
260  bool SupportsProfiling() const override;
261 
262  bool UseDwarfDebugFlags() const override;
263 
264  llvm::ExceptionHandling
265  GetExceptionModel(const llvm::opt::ArgList &Args) const override {
267  }
268 
269  virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const {
270  return "";
271  }
272 
273  // Darwin toolchain uses legacy thin LTO API, which is not
274  // capable of unit splitting.
275  bool canSplitThinLTOUnit() const override { return false; }
276  /// }
277 };
278 
279 /// Darwin - The base Darwin tool chain.
280 class LLVM_LIBRARY_VISIBILITY Darwin : public MachO {
281 public:
282  /// Whether the information on the target has been initialized.
283  //
284  // FIXME: This should be eliminated. What we want to do is make this part of
285  // the "default target for arguments" selection process, once we get out of
286  // the argument translation business.
287  mutable bool TargetInitialized;
288 
294  LastDarwinPlatform = WatchOS
295  };
300  };
301 
304 
305  /// The native OS version we are targeting.
306  mutable VersionTuple TargetVersion;
307  /// The OS version we are targeting as specified in the triple.
308  mutable VersionTuple OSTargetVersion;
309 
310  /// The information about the darwin SDK that was used.
312 
315 
316 private:
317  void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const;
318 
319 public:
320  Darwin(const Driver &D, const llvm::Triple &Triple,
321  const llvm::opt::ArgList &Args);
322  ~Darwin() override;
323 
324  std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
325  types::ID InputType) const override;
326 
327  /// @name Apple Specific Toolchain Implementation
328  /// {
329 
330  void addMinVersionArgs(const llvm::opt::ArgList &Args,
331  llvm::opt::ArgStringList &CmdArgs) const override;
332 
333  void addPlatformVersionArgs(const llvm::opt::ArgList &Args,
334  llvm::opt::ArgStringList &CmdArgs) const override;
335 
336  void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
337  llvm::opt::ArgStringList &CmdArgs) const override;
338 
339  bool isKernelStatic() const override {
340  return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) &&
341  !isTargetWatchOS());
342  }
343 
344  void addProfileRTLibs(const llvm::opt::ArgList &Args,
345  llvm::opt::ArgStringList &CmdArgs) const override;
346 
347 protected:
348  /// }
349  /// @name Darwin specific Toolchain functions
350  /// {
351 
352  // FIXME: Eliminate these ...Target functions and derive separate tool chains
353  // for these targets and put version in constructor.
355  unsigned Major, unsigned Minor, unsigned Micro,
356  VersionTuple NativeTargetVersion) const {
357  // FIXME: For now, allow reinitialization as long as values don't
358  // change. This will go away when we move away from argument translation.
359  if (TargetInitialized && TargetPlatform == Platform &&
360  TargetEnvironment == Environment &&
361  (Environment == MacCatalyst ? OSTargetVersion : TargetVersion) ==
362  VersionTuple(Major, Minor, Micro))
363  return;
364 
365  assert(!TargetInitialized && "Target already initialized!");
366  TargetInitialized = true;
367  TargetPlatform = Platform;
368  TargetEnvironment = Environment;
369  TargetVersion = VersionTuple(Major, Minor, Micro);
370  if (Environment == Simulator)
371  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::Simulator);
372  else if (Environment == MacCatalyst) {
373  const_cast<Darwin *>(this)->setTripleEnvironment(llvm::Triple::MacABI);
374  TargetVersion = NativeTargetVersion;
375  OSTargetVersion = VersionTuple(Major, Minor, Micro);
376  }
377  }
378 
379 public:
380  bool isTargetIPhoneOS() const {
381  assert(TargetInitialized && "Target not initialized!");
382  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
383  TargetEnvironment == NativeEnvironment;
384  }
385 
386  bool isTargetIOSSimulator() const {
387  assert(TargetInitialized && "Target not initialized!");
388  return (TargetPlatform == IPhoneOS || TargetPlatform == TvOS) &&
389  TargetEnvironment == Simulator;
390  }
391 
392  bool isTargetIOSBased() const {
393  assert(TargetInitialized && "Target not initialized!");
394  return isTargetIPhoneOS() || isTargetIOSSimulator();
395  }
396 
397  bool isTargetTvOS() const {
398  assert(TargetInitialized && "Target not initialized!");
399  return TargetPlatform == TvOS && TargetEnvironment == NativeEnvironment;
400  }
401 
402  bool isTargetTvOSSimulator() const {
403  assert(TargetInitialized && "Target not initialized!");
404  return TargetPlatform == TvOS && TargetEnvironment == Simulator;
405  }
406 
407  bool isTargetTvOSBased() const {
408  assert(TargetInitialized && "Target not initialized!");
409  return TargetPlatform == TvOS;
410  }
411 
412  bool isTargetWatchOS() const {
413  assert(TargetInitialized && "Target not initialized!");
414  return TargetPlatform == WatchOS && TargetEnvironment == NativeEnvironment;
415  }
416 
418  assert(TargetInitialized && "Target not initialized!");
419  return TargetPlatform == WatchOS && TargetEnvironment == Simulator;
420  }
421 
422  bool isTargetWatchOSBased() const {
423  assert(TargetInitialized && "Target not initialized!");
424  return TargetPlatform == WatchOS;
425  }
426 
427  bool isTargetMacCatalyst() const {
428  return TargetPlatform == IPhoneOS && TargetEnvironment == MacCatalyst;
429  }
430 
431  bool isTargetMacOS() const {
432  assert(TargetInitialized && "Target not initialized!");
433  return TargetPlatform == MacOS;
434  }
435 
436  bool isTargetMacOSBased() const {
437  assert(TargetInitialized && "Target not initialized!");
438  return TargetPlatform == MacOS || isTargetMacCatalyst();
439  }
440 
441  bool isTargetAppleSiliconMac() const {
442  assert(TargetInitialized && "Target not initialized!");
443  return isTargetMacOSBased() && getArch() == llvm::Triple::aarch64;
444  }
445 
446  bool isTargetInitialized() const { return TargetInitialized; }
447 
448  /// The version of the OS that's used by the OS specified in the target
449  /// triple. It might be different from the actual target OS on which the
450  /// program will run, e.g. MacCatalyst code runs on a macOS target, but its
451  /// target triple is iOS.
452  VersionTuple getTripleTargetVersion() const {
453  assert(TargetInitialized && "Target not initialized!");
454  return isTargetMacCatalyst() ? OSTargetVersion : TargetVersion;
455  }
456 
457  bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0,
458  unsigned V2 = 0) const {
459  assert(isTargetIOSBased() && "Unexpected call for non iOS target!");
460  return TargetVersion < VersionTuple(V0, V1, V2);
461  }
462 
463  /// Returns true if the minimum supported macOS version for the slice that's
464  /// being built is less than the specified version. If there's no minimum
465  /// supported macOS version, the deployment target version is compared to the
466  /// specifed version instead.
467  bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const {
468  assert(isTargetMacOSBased() &&
469  (getTriple().isMacOSX() || getTriple().isMacCatalystEnvironment()) &&
470  "Unexpected call for non OS X target!");
471  // The effective triple might not be initialized yet, so construct a
472  // pseudo-effective triple to get the minimum supported OS version.
473  VersionTuple MinVers =
474  llvm::Triple(getTriple().getArchName(), "apple", "macos")
475  .getMinimumSupportedOSVersion();
476  return (!MinVers.empty() && MinVers > TargetVersion
477  ? MinVers
478  : TargetVersion) < VersionTuple(V0, V1, V2);
479  }
480 
481 protected:
482  /// Return true if c++17 aligned allocation/deallocation functions are not
483  /// implemented in the c++ standard library of the deployment target we are
484  /// targeting.
485  bool isAlignedAllocationUnavailable() const;
486 
487  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
488  llvm::opt::ArgStringList &CC1Args,
489  Action::OffloadKind DeviceOffloadKind) const override;
490 
491  StringRef getPlatformFamily() const;
492  StringRef getOSLibraryNameSuffix(bool IgnoreSim = false) const override;
493 
494 public:
495  static StringRef getSDKName(StringRef isysroot);
496 
497  /// }
498  /// @name ToolChain Implementation
499  /// {
500 
501  // Darwin tools support multiple architecture (e.g., i386 and x86_64) and
502  // most development is done against SDKs, so compiling for a different
503  // architecture should not get any special treatment.
504  bool isCrossCompiling() const override { return false; }
505 
506  llvm::opt::DerivedArgList *
507  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
508  Action::OffloadKind DeviceOffloadKind) const override;
509 
510  CXXStdlibType GetDefaultCXXStdlibType() const override;
511  ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
512  bool hasBlocksRuntime() const override;
513 
514  void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
515  llvm::opt::ArgStringList &CC1Args) const override;
516  void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs,
517  llvm::opt::ArgStringList &CC1Args) const override;
518 
519  bool UseObjCMixedDispatch() const override {
520  // This is only used with the non-fragile ABI and non-legacy dispatch.
521 
522  // Mixed dispatch is used everywhere except OS X before 10.6.
523  return !(isTargetMacOSBased() && isMacosxVersionLT(10, 6));
524  }
525 
527  GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
528  // Stack protectors default to on for user code on 10.5,
529  // and for everything in 10.6 and beyond
530  if (isTargetIOSBased() || isTargetWatchOSBased())
531  return LangOptions::SSPOn;
532  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 6))
533  return LangOptions::SSPOn;
534  else if (isTargetMacOSBased() && !isMacosxVersionLT(10, 5) && !KernelOrKext)
535  return LangOptions::SSPOn;
536 
537  return LangOptions::SSPOff;
538  }
539 
540  void CheckObjCARC() const override;
541 
542  llvm::ExceptionHandling GetExceptionModel(
543  const llvm::opt::ArgList &Args) const override;
544 
545  bool SupportsEmbeddedBitcode() const override;
546 
547  SanitizerMask getSupportedSanitizers() const override;
548 
549  void printVerboseInfo(raw_ostream &OS) const override;
550 };
551 
552 /// DarwinClang - The Darwin toolchain used by Clang.
553 class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin {
554 public:
555  DarwinClang(const Driver &D, const llvm::Triple &Triple,
556  const llvm::opt::ArgList &Args);
557 
558  /// @name Apple ToolChain Implementation
559  /// {
560 
561  RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override;
562 
563  void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args,
564  llvm::opt::ArgStringList &CmdArgs,
565  bool ForceLinkBuiltinRT = false) const override;
566 
567  void AddClangCXXStdlibIncludeArgs(
568  const llvm::opt::ArgList &DriverArgs,
569  llvm::opt::ArgStringList &CC1Args) const override;
570 
571  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
572  llvm::opt::ArgStringList &CC1Args) const override;
573 
574  void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
575  llvm::opt::ArgStringList &CmdArgs) const override;
576 
577  void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
578  llvm::opt::ArgStringList &CmdArgs) const override;
579 
580  void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
581 
582  void AddLinkARCArgs(const llvm::opt::ArgList &Args,
583  llvm::opt::ArgStringList &CmdArgs) const override;
584 
585  unsigned GetDefaultDwarfVersion() const override;
586  // Until dtrace (via CTF) and LLDB can deal with distributed debug info,
587  // Darwin defaults to standalone/full debug info.
588  bool GetDefaultStandaloneDebug() const override { return true; }
589  llvm::DebuggerKind getDefaultDebuggerTuning() const override {
590  return llvm::DebuggerKind::LLDB;
591  }
592 
593  /// }
594 
595 private:
596  void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args,
597  llvm::opt::ArgStringList &CmdArgs,
598  StringRef Sanitizer,
599  bool shared = true) const;
600 
601  bool AddGnuCPlusPlusIncludePaths(const llvm::opt::ArgList &DriverArgs,
602  llvm::opt::ArgStringList &CC1Args,
604  llvm::StringRef Version,
605  llvm::StringRef ArchDir,
606  llvm::StringRef BitDir) const;
607 
608  llvm::StringRef GetHeaderSysroot(const llvm::opt::ArgList &DriverArgs) const;
609 };
610 
611 } // end namespace toolchains
612 } // end namespace driver
613 } // end namespace clang
614 
615 #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:527
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:181
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:174
clang::LangOptions::StackProtectorMode
StackProtectorMode
Definition: LangOptions.h:64
clang::driver::toolchains::Darwin::isTargetAppleSiliconMac
bool isTargetAppleSiliconMac() const
Definition: Darwin.h:441
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:519
clang::driver::toolchains::Darwin::isTargetWatchOSBased
bool isTargetWatchOSBased() const
Definition: Darwin.h:422
clang::driver::toolchains::Darwin::TargetVersion
VersionTuple TargetVersion
The native OS version we are targeting.
Definition: Darwin.h:306
clang::driver::toolchains::Darwin::isTargetIPhoneOS
bool isTargetIPhoneOS() const
Definition: Darwin.h:380
llvm::Optional
Definition: LLVM.h:40
clang::driver::toolchains::Darwin::WatchOS
@ WatchOS
Definition: Darwin.h:293
clang::driver::toolchains::Darwin::isTargetMacOSBased
bool isTargetMacOSBased() const
Definition: Darwin.h:436
clang::driver::toolchains::Darwin::isCrossCompiling
bool isCrossCompiling() const override
Returns true if the toolchain is targeting a non-native architecture.
Definition: Darwin.h:504
clang::driver::tools::darwin::getArchTypeForMachOArchName
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Darwin.cpp:41
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:402
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:452
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:313
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:308
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:64
clang::driver::toolchains::MachO::RuntimeLinkOptions
RuntimeLinkOptions
Options to control how a runtime library is linked.
Definition: Darwin.h:193
clang::driver::toolchains::Darwin::isTargetTvOSBased
bool isTargetTvOSBased() const
Definition: Darwin.h:407
clang::driver::toolchains::Darwin::isTargetInitialized
bool isTargetInitialized() const
Definition: Darwin.h:446
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:311
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:457
LangOptions.h
clang::driver::toolchains::MachO::IsIntegratedAssemblerDefault
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Definition: Darwin.h:234
clang::driver::toolchains::MachO::IsEncodeExtendedBlockSignatureDefault
bool IsEncodeExtendedBlockSignatureDefault() const override
IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable -fencode-extended-block-signature...
Definition: Darwin.h:241
clang::driver::toolchains::Darwin
Darwin - The base Darwin tool chain.
Definition: Darwin.h:280
clang::driver::toolchains::Darwin::isTargetMacCatalyst
bool isTargetMacCatalyst() const
Definition: Darwin.h:427
clang::driver::toolchains::DarwinClang::getDefaultDebuggerTuning
llvm::DebuggerKind getDefaultDebuggerTuning() const override
Definition: Darwin.h:589
clang::driver::toolchains::Darwin::RocmInstallation
RocmInstallationDetector RocmInstallation
Definition: Darwin.h:314
clang::driver::toolchains::Darwin::isTargetMacOS
bool isTargetMacOS() const
Definition: Darwin.h:431
clang::driver::toolchains::Darwin::TargetInitialized
bool TargetInitialized
Whether the information on the target has been initialized.
Definition: Darwin.h:287
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:239
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:275
clang::driver::toolchains::MachO::isTargetIOSBased
bool isTargetIOSBased() const
Is the target either iOS or an iOS simulator?
Definition: Darwin.h:190
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:302
clang::driver::toolchains::Darwin::setTarget
void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment, unsigned Major, unsigned Minor, unsigned Micro, VersionTuple NativeTargetVersion) const
Definition: Darwin.h:354
clang::driver::toolchains::MachO::IsBlocksDefault
bool IsBlocksDefault() const override
IsBlocksDefault - Does this tool chain enable -fblocks by default.
Definition: Darwin.h:229
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:397
clang::driver::toolchains::Darwin::isTargetWatchOS
bool isTargetWatchOS() const
Definition: Darwin.h:412
clang::driver::toolchains::Darwin::IPhoneOS
@ IPhoneOS
Definition: Darwin.h:291
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:187
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:467
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:339
ROCm.h
clang::driver::toolchains::Darwin::isTargetWatchOSSimulator
bool isTargetWatchOSSimulator() const
Definition: Darwin.h:417
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:386
clang::driver::tools::darwin::StaticLibTool::isLinkJob
bool isLinkJob() const override
Definition: Darwin.h:87
clang::driver::toolchains::Darwin::TvOS
@ TvOS
Definition: Darwin.h:292
clang::driver::toolchains::MachO::getOSLibraryNameSuffix
virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim=false) const
Definition: Darwin.h:269
clang::driver::toolchains::Darwin::MacOS
@ MacOS
Definition: Darwin.h:290
clang::LangOptions::SSPOn
@ SSPOn
Definition: LangOptions.h:64
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:392
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:297
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:27
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:265
clang::driver::toolchains::Darwin::Simulator
@ Simulator
Definition: Darwin.h:298
clang::driver::toolchains::DarwinClang::GetDefaultStandaloneDebug
bool GetDefaultStandaloneDebug() const override
Definition: Darwin.h:588
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:163
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:59
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:248
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:212
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:296
clang::driver::toolchains::MachO::addMinVersionArgs
virtual void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:178
clang::driver::toolchains::MachO::IsObjCNonFragileABIDefault
bool IsObjCNonFragileABIDefault() const override
IsObjCNonFragileABIDefault - Does this tool chain set -fobjc-nonfragile-abi by default.
Definition: Darwin.h:243
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:85
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:380
clang::driver::toolchains::MachO::GetDefaultRuntimeLibType
RuntimeLibType GetDefaultRuntimeLibType() const override
GetDefaultRuntimeLibType - Get the default runtime library variant to use.
Definition: Darwin.h:252
clang::driver::toolchains::Darwin::DarwinPlatformKind
DarwinPlatformKind
Definition: Darwin.h:289
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:553
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:303
clang::SanitizerMask
Definition: Sanitizers.h:30
Cuda.h
clang::driver::toolchains::Darwin::MacCatalyst
@ MacCatalyst
Definition: Darwin.h:299