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