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