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