| //===--- ToolChains.h - ToolChain Implementations ---------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H |
| #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H |
| |
| #include "Tools.h" |
| #include "clang/Basic/Cuda.h" |
| #include "clang/Basic/VersionTuple.h" |
| #include "clang/Driver/Action.h" |
| #include "clang/Driver/Multilib.h" |
| #include "clang/Driver/ToolChain.h" |
| #include "llvm/ADT/Optional.h" |
| #include "llvm/ADT/SmallSet.h" |
| #include "llvm/Support/Compiler.h" |
| #include <set> |
| #include <vector> |
| |
| namespace clang { |
| namespace driver { |
| namespace toolchains { |
| |
| /// Generic_GCC - A tool chain using the 'gcc' command to perform |
| /// all subcommands; this relies on gcc translating the majority of |
| /// command line options. |
| class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain { |
| public: |
| /// \brief Struct to store and manipulate GCC versions. |
| /// |
| /// We rely on assumptions about the form and structure of GCC version |
| /// numbers: they consist of at most three '.'-separated components, and each |
| /// component is a non-negative integer except for the last component. For |
| /// the last component we are very flexible in order to tolerate release |
| /// candidates or 'x' wildcards. |
| /// |
| /// Note that the ordering established among GCCVersions is based on the |
| /// preferred version string to use. For example we prefer versions without |
| /// a hard-coded patch number to those with a hard coded patch number. |
| /// |
| /// Currently this doesn't provide any logic for textual suffixes to patches |
| /// in the way that (for example) Debian's version format does. If that ever |
| /// becomes necessary, it can be added. |
| struct GCCVersion { |
| /// \brief The unparsed text of the version. |
| std::string Text; |
| |
| /// \brief The parsed major, minor, and patch numbers. |
| int Major, Minor, Patch; |
| |
| /// \brief The text of the parsed major, and major+minor versions. |
| std::string MajorStr, MinorStr; |
| |
| /// \brief Any textual suffix on the patch number. |
| std::string PatchSuffix; |
| |
| static GCCVersion Parse(StringRef VersionText); |
| bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch, |
| StringRef RHSPatchSuffix = StringRef()) const; |
| bool operator<(const GCCVersion &RHS) const { |
| return isOlderThan(RHS.Major, RHS.Minor, RHS.Patch, RHS.PatchSuffix); |
| } |
| bool operator>(const GCCVersion &RHS) const { return RHS < *this; } |
| bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); } |
| bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); } |
| }; |
| |
| /// \brief This is a class to find a viable GCC installation for Clang to |
| /// use. |
| /// |
| /// This class tries to find a GCC installation on the system, and report |
| /// information about it. It starts from the host information provided to the |
| /// Driver, and has logic for fuzzing that where appropriate. |
| class GCCInstallationDetector { |
| bool IsValid; |
| llvm::Triple GCCTriple; |
| const Driver &D; |
| |
| // FIXME: These might be better as path objects. |
| std::string GCCInstallPath; |
| std::string GCCParentLibPath; |
| |
| /// The primary multilib appropriate for the given flags. |
| Multilib SelectedMultilib; |
| /// On Biarch systems, this corresponds to the default multilib when |
| /// targeting the non-default multilib. Otherwise, it is empty. |
| llvm::Optional<Multilib> BiarchSibling; |
| |
| GCCVersion Version; |
| |
| // We retain the list of install paths that were considered and rejected in |
| // order to print out detailed information in verbose mode. |
| std::set<std::string> CandidateGCCInstallPaths; |
| |
| /// The set of multilibs that the detected installation supports. |
| MultilibSet Multilibs; |
| |
| public: |
| explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {} |
| void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args, |
| ArrayRef<std::string> ExtraTripleAliases = None); |
| |
| /// \brief Check whether we detected a valid GCC install. |
| bool isValid() const { return IsValid; } |
| |
| /// \brief Get the GCC triple for the detected install. |
| const llvm::Triple &getTriple() const { return GCCTriple; } |
| |
| /// \brief Get the detected GCC installation path. |
| StringRef getInstallPath() const { return GCCInstallPath; } |
| |
| /// \brief Get the detected GCC parent lib path. |
| StringRef getParentLibPath() const { return GCCParentLibPath; } |
| |
| /// \brief Get the detected Multilib |
| const Multilib &getMultilib() const { return SelectedMultilib; } |
| |
| /// \brief Get the whole MultilibSet |
| const MultilibSet &getMultilibs() const { return Multilibs; } |
| |
| /// Get the biarch sibling multilib (if it exists). |
| /// \return true iff such a sibling exists |
| bool getBiarchSibling(Multilib &M) const; |
| |
| /// \brief Get the detected GCC version string. |
| const GCCVersion &getVersion() const { return Version; } |
| |
| /// \brief Print information about the detected GCC installation. |
| void print(raw_ostream &OS) const; |
| |
| private: |
| static void |
| CollectLibDirsAndTriples(const llvm::Triple &TargetTriple, |
| const llvm::Triple &BiarchTriple, |
| SmallVectorImpl<StringRef> &LibDirs, |
| SmallVectorImpl<StringRef> &TripleAliases, |
| SmallVectorImpl<StringRef> &BiarchLibDirs, |
| SmallVectorImpl<StringRef> &BiarchTripleAliases); |
| |
| void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch, |
| const llvm::opt::ArgList &Args, |
| const std::string &LibDir, |
| StringRef CandidateTriple, |
| bool NeedsBiarchSuffix = false); |
| |
| void scanLibDirForGCCTripleSolaris(const llvm::Triple &TargetArch, |
| const llvm::opt::ArgList &Args, |
| const std::string &LibDir, |
| StringRef CandidateTriple, |
| bool NeedsBiarchSuffix = false); |
| }; |
| |
| protected: |
| GCCInstallationDetector GCCInstallation; |
| |
| // \brief A class to find a viable CUDA installation |
| class CudaInstallationDetector { |
| private: |
| const Driver &D; |
| bool IsValid = false; |
| CudaVersion Version = CudaVersion::UNKNOWN; |
| std::string InstallPath; |
| std::string BinPath; |
| std::string LibPath; |
| std::string LibDevicePath; |
| std::string IncludePath; |
| llvm::StringMap<std::string> LibDeviceMap; |
| |
| // CUDA architectures for which we have raised an error in |
| // CheckCudaVersionSupportsArch. |
| mutable llvm::SmallSet<CudaArch, 4> ArchsWithVersionTooLowErrors; |
| |
| public: |
| CudaInstallationDetector(const Driver &D) : D(D) {} |
| void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args); |
| |
| /// \brief Emit an error if Version does not support the given Arch. |
| /// |
| /// If either Version or Arch is unknown, does not emit an error. Emits at |
| /// most one error per Arch. |
| void CheckCudaVersionSupportsArch(CudaArch Arch) const; |
| |
| /// \brief Check whether we detected a valid Cuda install. |
| bool isValid() const { return IsValid; } |
| /// \brief Print information about the detected CUDA installation. |
| void print(raw_ostream &OS) const; |
| |
| /// \brief Get the deteced Cuda install's version. |
| CudaVersion version() const { return Version; } |
| /// \brief Get the detected Cuda installation path. |
| StringRef getInstallPath() const { return InstallPath; } |
| /// \brief Get the detected path to Cuda's bin directory. |
| StringRef getBinPath() const { return BinPath; } |
| /// \brief Get the detected Cuda Include path. |
| StringRef getIncludePath() const { return IncludePath; } |
| /// \brief Get the detected Cuda library path. |
| StringRef getLibPath() const { return LibPath; } |
| /// \brief Get the detected Cuda device library path. |
| StringRef getLibDevicePath() const { return LibDevicePath; } |
| /// \brief Get libdevice file for given architecture |
| std::string getLibDeviceFile(StringRef Gpu) const { |
| return LibDeviceMap.lookup(Gpu); |
| } |
| }; |
| |
| CudaInstallationDetector CudaInstallation; |
| |
| public: |
| Generic_GCC(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~Generic_GCC() override; |
| |
| void printVerboseInfo(raw_ostream &OS) const override; |
| |
| bool IsUnwindTablesDefault() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| bool IsIntegratedAssemblerDefault() const override; |
| |
| protected: |
| Tool *getTool(Action::ActionClass AC) const override; |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| |
| /// \name ToolChain Implementation Helper Functions |
| /// @{ |
| |
| /// \brief Check whether the target triple's architecture is 64-bits. |
| bool isTarget64Bit() const { return getTriple().isArch64Bit(); } |
| |
| /// \brief Check whether the target triple's architecture is 32-bits. |
| bool isTarget32Bit() const { return getTriple().isArch32Bit(); } |
| |
| bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple, |
| StringRef GCCMultiarchTriple, |
| StringRef TargetMultiarchTriple, |
| Twine IncludeSuffix, |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const; |
| |
| /// @} |
| |
| private: |
| mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess; |
| mutable std::unique_ptr<tools::gcc::Compiler> Compile; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY MachO : public ToolChain { |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| Tool *getTool(Action::ActionClass AC) const override; |
| |
| private: |
| mutable std::unique_ptr<tools::darwin::Lipo> Lipo; |
| mutable std::unique_ptr<tools::darwin::Dsymutil> Dsymutil; |
| mutable std::unique_ptr<tools::darwin::VerifyDebug> VerifyDebug; |
| |
| public: |
| MachO(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~MachO() override; |
| |
| /// @name MachO specific toolchain API |
| /// { |
| |
| /// Get the "MachO" arch name for a particular compiler invocation. For |
| /// example, Apple treats different ARM variations as distinct architectures. |
| StringRef getMachOArchName(const llvm::opt::ArgList &Args) const; |
| |
| /// Add the linker arguments to link the ARC runtime library. |
| virtual void AddLinkARCArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const {} |
| |
| /// Add the linker arguments to link the compiler runtime library. |
| virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const; |
| |
| virtual void addStartObjectFileArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const { |
| } |
| |
| virtual void addMinVersionArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const {} |
| |
| /// On some iOS platforms, kernel and kernel modules were built statically. Is |
| /// this such a target? |
| virtual bool isKernelStatic() const { return false; } |
| |
| /// Is the target either iOS or an iOS simulator? |
| bool isTargetIOSBased() const { return false; } |
| |
| void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs, |
| StringRef DarwinLibName, bool AlwaysLink = false, |
| bool IsEmbedded = false, bool AddRPath = false) const; |
| |
| /// Add any profiling runtime libraries that are needed. This is essentially a |
| /// MachO specific version of addProfileRT in Tools.cpp. |
| void addProfileRTLibs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override { |
| // There aren't any profiling libs for embedded targets currently. |
| } |
| |
| /// } |
| /// @name ToolChain Implementation |
| /// { |
| |
| types::ID LookupTypeForExtension(const char *Ext) const override; |
| |
| bool HasNativeLLVMSupport() const override; |
| |
| llvm::opt::DerivedArgList * |
| TranslateArgs(const llvm::opt::DerivedArgList &Args, |
| const char *BoundArch) const override; |
| |
| bool IsBlocksDefault() const override { |
| // Always allow blocks on Apple; users interested in versioning are |
| // expected to use /usr/include/Block.h. |
| return true; |
| } |
| bool IsIntegratedAssemblerDefault() const override { |
| // Default integrated assembler to on for Apple's MachO targets. |
| return true; |
| } |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| |
| bool IsEncodeExtendedBlockSignatureDefault() const override { return true; } |
| |
| bool IsObjCNonFragileABIDefault() const override { |
| // Non-fragile ABI is default for everything but i386. |
| return getTriple().getArch() != llvm::Triple::x86; |
| } |
| |
| bool UseObjCMixedDispatch() const override { return true; } |
| |
| bool IsUnwindTablesDefault() const override; |
| |
| RuntimeLibType GetDefaultRuntimeLibType() const override { |
| return ToolChain::RLT_CompilerRT; |
| } |
| |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| |
| bool SupportsProfiling() const override; |
| |
| bool SupportsObjCGC() const override { return false; } |
| |
| bool UseDwarfDebugFlags() const override; |
| |
| bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override { |
| return false; |
| } |
| |
| /// } |
| }; |
| |
| /// Darwin - The base Darwin tool chain. |
| class LLVM_LIBRARY_VISIBILITY Darwin : public MachO { |
| public: |
| /// Whether the information on the target has been initialized. |
| // |
| // FIXME: This should be eliminated. What we want to do is make this part of |
| // the "default target for arguments" selection process, once we get out of |
| // the argument translation business. |
| mutable bool TargetInitialized; |
| |
| enum DarwinPlatformKind { |
| MacOS, |
| IPhoneOS, |
| IPhoneOSSimulator, |
| TvOS, |
| TvOSSimulator, |
| WatchOS, |
| WatchOSSimulator |
| }; |
| |
| mutable DarwinPlatformKind TargetPlatform; |
| |
| /// The OS version we are targeting. |
| mutable VersionTuple TargetVersion; |
| |
| private: |
| void AddDeploymentTarget(llvm::opt::DerivedArgList &Args) const; |
| |
| public: |
| Darwin(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~Darwin() override; |
| |
| std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, |
| types::ID InputType) const override; |
| |
| /// @name Apple Specific Toolchain Implementation |
| /// { |
| |
| void addMinVersionArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| void addStartObjectFileArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| bool isKernelStatic() const override { |
| return (!(isTargetIPhoneOS() && !isIPhoneOSVersionLT(6, 0)) && |
| !isTargetWatchOS()); |
| } |
| |
| void addProfileRTLibs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| protected: |
| /// } |
| /// @name Darwin specific Toolchain functions |
| /// { |
| |
| // FIXME: Eliminate these ...Target functions and derive separate tool chains |
| // for these targets and put version in constructor. |
| void setTarget(DarwinPlatformKind Platform, unsigned Major, unsigned Minor, |
| unsigned Micro) const { |
| // FIXME: For now, allow reinitialization as long as values don't |
| // change. This will go away when we move away from argument translation. |
| if (TargetInitialized && TargetPlatform == Platform && |
| TargetVersion == VersionTuple(Major, Minor, Micro)) |
| return; |
| |
| assert(!TargetInitialized && "Target already initialized!"); |
| TargetInitialized = true; |
| TargetPlatform = Platform; |
| TargetVersion = VersionTuple(Major, Minor, Micro); |
| } |
| |
| bool isTargetIPhoneOS() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == IPhoneOS || TargetPlatform == TvOS; |
| } |
| |
| bool isTargetIOSSimulator() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == IPhoneOSSimulator || |
| TargetPlatform == TvOSSimulator; |
| } |
| |
| bool isTargetIOSBased() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return isTargetIPhoneOS() || isTargetIOSSimulator(); |
| } |
| |
| bool isTargetTvOS() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == TvOS; |
| } |
| |
| bool isTargetTvOSSimulator() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == TvOSSimulator; |
| } |
| |
| bool isTargetTvOSBased() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == TvOS || TargetPlatform == TvOSSimulator; |
| } |
| |
| bool isTargetWatchOS() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == WatchOS; |
| } |
| |
| bool isTargetWatchOSSimulator() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == WatchOSSimulator; |
| } |
| |
| bool isTargetWatchOSBased() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == WatchOS || TargetPlatform == WatchOSSimulator; |
| } |
| |
| bool isTargetMacOS() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetPlatform == MacOS; |
| } |
| |
| bool isTargetInitialized() const { return TargetInitialized; } |
| |
| VersionTuple getTargetVersion() const { |
| assert(TargetInitialized && "Target not initialized!"); |
| return TargetVersion; |
| } |
| |
| bool isIPhoneOSVersionLT(unsigned V0, unsigned V1 = 0, |
| unsigned V2 = 0) const { |
| assert(isTargetIOSBased() && "Unexpected call for non iOS target!"); |
| return TargetVersion < VersionTuple(V0, V1, V2); |
| } |
| |
| bool isMacosxVersionLT(unsigned V0, unsigned V1 = 0, unsigned V2 = 0) const { |
| assert(isTargetMacOS() && "Unexpected call for non OS X target!"); |
| return TargetVersion < VersionTuple(V0, V1, V2); |
| } |
| |
| StringRef getPlatformFamily() const; |
| static StringRef getSDKName(StringRef isysroot); |
| StringRef getOSLibraryNameSuffix() const; |
| |
| public: |
| /// } |
| /// @name ToolChain Implementation |
| /// { |
| |
| // Darwin tools support multiple architecture (e.g., i386 and x86_64) and |
| // most development is done against SDKs, so compiling for a different |
| // architecture should not get any special treatment. |
| bool isCrossCompiling() const override { return false; } |
| |
| llvm::opt::DerivedArgList * |
| TranslateArgs(const llvm::opt::DerivedArgList &Args, |
| const char *BoundArch) const override; |
| |
| CXXStdlibType GetDefaultCXXStdlibType() const override; |
| ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override; |
| bool hasBlocksRuntime() const override; |
| |
| bool UseObjCMixedDispatch() const override { |
| // This is only used with the non-fragile ABI and non-legacy dispatch. |
| |
| // Mixed dispatch is used everywhere except OS X before 10.6. |
| return !(isTargetMacOS() && isMacosxVersionLT(10, 6)); |
| } |
| |
| unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override { |
| // Stack protectors default to on for user code on 10.5, |
| // and for everything in 10.6 and beyond |
| if (isTargetIOSBased() || isTargetWatchOSBased()) |
| return 1; |
| else if (isTargetMacOS() && !isMacosxVersionLT(10, 6)) |
| return 1; |
| else if (isTargetMacOS() && !isMacosxVersionLT(10, 5) && !KernelOrKext) |
| return 1; |
| |
| return 0; |
| } |
| |
| bool SupportsObjCGC() const override; |
| |
| void CheckObjCARC() const override; |
| |
| bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override; |
| |
| bool SupportsEmbeddedBitcode() const override; |
| |
| SanitizerMask getSupportedSanitizers() const override; |
| }; |
| |
| /// DarwinClang - The Darwin toolchain used by Clang. |
| class LLVM_LIBRARY_VISIBILITY DarwinClang : public Darwin { |
| public: |
| DarwinClang(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| /// @name Apple ToolChain Implementation |
| /// { |
| |
| RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override; |
| |
| void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| void AddCCKextLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override; |
| |
| void AddLinkARCArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| unsigned GetDefaultDwarfVersion() const override; |
| // Until dtrace (via CTF) and LLDB can deal with distributed debug info, |
| // Darwin defaults to standalone/full debug info. |
| bool GetDefaultStandaloneDebug() const override { return true; } |
| llvm::DebuggerKind getDefaultDebuggerTuning() const override { |
| return llvm::DebuggerKind::LLDB; |
| } |
| |
| /// } |
| |
| private: |
| void AddLinkSanitizerLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs, |
| StringRef Sanitizer) const; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC { |
| virtual void anchor(); |
| |
| public: |
| Generic_ELF(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args) |
| : Generic_GCC(D, Triple, Args) {} |
| |
| void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY CloudABI : public Generic_ELF { |
| public: |
| CloudABI(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| bool HasNativeLLVMSupport() const override { return true; } |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| |
| CXXStdlibType |
| GetCXXStdlibType(const llvm::opt::ArgList &Args) const override { |
| return ToolChain::CST_Libcxx; |
| } |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| bool isPIEDefault() const override; |
| SanitizerMask getSupportedSanitizers() const override; |
| SanitizerMask getDefaultSanitizers() const override; |
| |
| protected: |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Solaris : public Generic_GCC { |
| public: |
| Solaris(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsIntegratedAssemblerDefault() const override { return true; } |
| |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| unsigned GetDefaultDwarfVersion() const override { return 2; } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain { |
| public: |
| MinGW(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsIntegratedAssemblerDefault() const override; |
| bool IsUnwindTablesDefault() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| bool UseSEHExceptions() const; |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| protected: |
| Tool *getTool(Action::ActionClass AC) const override; |
| Tool *buildLinker() const override; |
| Tool *buildAssembler() const override; |
| |
| private: |
| std::string Base; |
| std::string GccLibDir; |
| std::string Ver; |
| std::string Arch; |
| mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor; |
| mutable std::unique_ptr<tools::gcc::Compiler> Compiler; |
| void findGccLibDir(); |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Haiku : public Generic_ELF { |
| public: |
| Haiku(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool isPIEDefault() const override { return getTriple().getArch() == llvm::Triple::x86_64; } |
| |
| void |
| AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF { |
| public: |
| OpenBSD(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| bool isPIEDefault() const override { return true; } |
| |
| unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override { |
| return 2; |
| } |
| unsigned GetDefaultDwarfVersion() const override { return 2; } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF { |
| public: |
| Bitrig(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| |
| CXXStdlibType GetDefaultCXXStdlibType() const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override { |
| return 1; |
| } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY FreeBSD : public Generic_ELF { |
| public: |
| FreeBSD(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| bool HasNativeLLVMSupport() const override; |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| |
| CXXStdlibType GetDefaultCXXStdlibType() const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const override; |
| bool isPIEDefault() const override; |
| SanitizerMask getSupportedSanitizers() const override; |
| unsigned GetDefaultDwarfVersion() const override { return 2; } |
| // Until dtrace (via CTF) and LLDB can deal with distributed debug info, |
| // FreeBSD defaults to standalone/full debug info. |
| bool GetDefaultStandaloneDebug() const override { return true; } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY NetBSD : public Generic_ELF { |
| public: |
| NetBSD(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| |
| CXXStdlibType GetDefaultCXXStdlibType() const override; |
| |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| bool IsUnwindTablesDefault() const override { return true; } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Minix : public Generic_ELF { |
| public: |
| Minix(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY DragonFly : public Generic_ELF { |
| public: |
| DragonFly(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF { |
| public: |
| Linux(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool HasNativeLLVMSupport() const override; |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| bool isPIEDefault() const override; |
| SanitizerMask getSupportedSanitizers() const override; |
| void addProfileRTLibs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| virtual std::string computeSysRoot() const; |
| |
| virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const; |
| |
| std::vector<std::string> ExtraOpts; |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY CudaToolChain : public Linux { |
| public: |
| CudaToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| llvm::opt::DerivedArgList * |
| TranslateArgs(const llvm::opt::DerivedArgList &Args, |
| const char *BoundArch) const override; |
| void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| // Never try to use the integrated assembler with CUDA; always fork out to |
| // ptxas. |
| bool useIntegratedAs() const override { return false; } |
| |
| void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| const Generic_GCC::CudaInstallationDetector &cudaInstallation() const { |
| return CudaInstallation; |
| } |
| Generic_GCC::CudaInstallationDetector &cudaInstallation() { |
| return CudaInstallation; |
| } |
| |
| protected: |
| Tool *buildAssembler() const override; // ptxas |
| Tool *buildLinker() const override; // fatbinary (ok, not really a linker) |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY MipsLLVMToolChain : public Linux { |
| protected: |
| Tool *buildLinker() const override; |
| |
| public: |
| MipsLLVMToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; |
| |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, |
| bool Shared = false) const override; |
| |
| std::string computeSysRoot() const override; |
| |
| RuntimeLibType GetDefaultRuntimeLibType() const override { |
| return GCCInstallation.isValid() ? RuntimeLibType::RLT_Libgcc |
| : RuntimeLibType::RLT_CompilerRT; |
| } |
| |
| private: |
| Multilib SelectedMultilib; |
| std::string LibSuffix; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY LanaiToolChain : public Generic_ELF { |
| public: |
| LanaiToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args) |
| : Generic_ELF(D, Triple, Args) {} |
| bool IsIntegratedAssemblerDefault() const override { return true; } |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY HexagonToolChain : public Linux { |
| protected: |
| GCCVersion GCCLibAndIncVersion; |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| |
| public: |
| HexagonToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~HexagonToolChain() override; |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; |
| |
| StringRef GetGCCLibAndIncVersion() const { return GCCLibAndIncVersion.Text; } |
| bool IsIntegratedAssemblerDefault() const override { |
| return true; |
| } |
| |
| std::string getHexagonTargetDir( |
| const std::string &InstalledDir, |
| const SmallVectorImpl<std::string> &PrefixDirs) const; |
| void getHexagonLibraryPaths(const llvm::opt::ArgList &Args, |
| ToolChain::path_list &LibPaths) const; |
| |
| static const StringRef GetDefaultCPU(); |
| static const StringRef GetTargetCPUVersion(const llvm::opt::ArgList &Args); |
| |
| static Optional<unsigned> getSmallDataThreshold( |
| const llvm::opt::ArgList &Args); |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY AMDGPUToolChain : public Generic_ELF { |
| protected: |
| Tool *buildLinker() const override; |
| |
| public: |
| AMDGPUToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| unsigned GetDefaultDwarfVersion() const override { return 2; } |
| bool IsIntegratedAssemblerDefault() const override { return true; } |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY NaClToolChain : public Generic_ELF { |
| public: |
| NaClToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; |
| |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| bool IsIntegratedAssemblerDefault() const override { |
| return getTriple().getArch() == llvm::Triple::mipsel; |
| } |
| |
| // Get the path to the file containing NaCl's ARM macros. |
| // It lives in NaClToolChain because the ARMAssembler tool needs a |
| // const char * that it can pass around, |
| const char *GetNaClArmMacrosPath() const { return NaClArmMacrosPath.c_str(); } |
| |
| std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, |
| types::ID InputType) const override; |
| |
| protected: |
| Tool *buildLinker() const override; |
| Tool *buildAssembler() const override; |
| |
| private: |
| std::string NaClArmMacrosPath; |
| }; |
| |
| /// TCEToolChain - A tool chain using the llvm bitcode tools to perform |
| /// all subcommands. See http://tce.cs.tut.fi for our peculiar target. |
| class LLVM_LIBRARY_VISIBILITY TCEToolChain : public ToolChain { |
| public: |
| TCEToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~TCEToolChain() override; |
| |
| bool IsMathErrnoDefault() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY MSVCToolChain : public ToolChain { |
| public: |
| MSVCToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| llvm::opt::DerivedArgList * |
| TranslateArgs(const llvm::opt::DerivedArgList &Args, |
| const char *BoundArch) const override; |
| |
| bool IsIntegratedAssemblerDefault() const override; |
| bool IsUnwindTablesDefault() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| bool getWindowsSDKDir(std::string &path, int &major, |
| std::string &windowsSDKIncludeVersion, |
| std::string &windowsSDKLibVersion) const; |
| bool getWindowsSDKLibraryPath(std::string &path) const; |
| /// \brief Check if Universal CRT should be used if available |
| bool useUniversalCRT(std::string &visualStudioDir) const; |
| bool getUniversalCRTSdkDir(std::string &path, std::string &ucrtVersion) const; |
| bool getUniversalCRTLibraryPath(std::string &path) const; |
| bool getVisualStudioInstallDir(std::string &path) const; |
| bool getVisualStudioBinariesFolder(const char *clangProgramPath, |
| std::string &path) const; |
| VersionTuple getMSVCVersionFromExe() const override; |
| |
| std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, |
| types::ID InputType) const override; |
| SanitizerMask getSupportedSanitizers() const override; |
| |
| protected: |
| void AddSystemIncludeWithSubfolder(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args, |
| const std::string &folder, |
| const Twine &subfolder1, |
| const Twine &subfolder2 = "", |
| const Twine &subfolder3 = "") const; |
| |
| Tool *buildLinker() const override; |
| Tool *buildAssembler() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY CrossWindowsToolChain : public Generic_GCC { |
| public: |
| CrossWindowsToolChain(const Driver &D, const llvm::Triple &T, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsIntegratedAssemblerDefault() const override { return true; } |
| bool IsUnwindTablesDefault() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| |
| unsigned int GetDefaultStackProtectorLevel(bool KernelOrKext) const override { |
| return 0; |
| } |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| |
| SanitizerMask getSupportedSanitizers() const override; |
| |
| protected: |
| Tool *buildLinker() const override; |
| Tool *buildAssembler() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY XCoreToolChain : public ToolChain { |
| public: |
| XCoreToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| |
| public: |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| bool SupportsProfiling() const override; |
| bool hasBlocksRuntime() const override; |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, |
| llvm::opt::ArgStringList &CmdArgs) const override; |
| }; |
| |
| /// MyriadToolChain - A tool chain using either clang or the external compiler |
| /// installed by the Movidius SDK to perform all subcommands. |
| class LLVM_LIBRARY_VISIBILITY MyriadToolChain : public Generic_ELF { |
| public: |
| MyriadToolChain(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| ~MyriadToolChain() override; |
| |
| void |
| AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| Tool *SelectTool(const JobAction &JA) const override; |
| unsigned GetDefaultDwarfVersion() const override { return 2; } |
| |
| protected: |
| Tool *buildLinker() const override; |
| bool isShaveCompilation(const llvm::Triple &T) const { |
| return T.getArch() == llvm::Triple::shave; |
| } |
| |
| private: |
| mutable std::unique_ptr<Tool> Compiler; |
| mutable std::unique_ptr<Tool> Assembler; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY WebAssembly final : public ToolChain { |
| public: |
| WebAssembly(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| private: |
| bool IsMathErrnoDefault() const override; |
| bool IsObjCNonFragileABIDefault() const override; |
| bool UseObjCMixedDispatch() const override; |
| bool isPICDefault() const override; |
| bool isPIEDefault() const override; |
| bool isPICDefaultForced() const override; |
| bool IsIntegratedAssemblerDefault() const override; |
| bool hasBlocksRuntime() const override; |
| bool SupportsObjCGC() const override; |
| bool SupportsProfiling() const override; |
| bool HasNativeLLVMSupport() const override; |
| void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| RuntimeLibType GetDefaultRuntimeLibType() const override; |
| CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override; |
| void AddClangSystemIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| void AddClangCXXStdlibIncludeArgs( |
| const llvm::opt::ArgList &DriverArgs, |
| llvm::opt::ArgStringList &CC1Args) const override; |
| |
| Tool *buildLinker() const override; |
| }; |
| |
| class LLVM_LIBRARY_VISIBILITY PS4CPU : public Generic_ELF { |
| public: |
| PS4CPU(const Driver &D, const llvm::Triple &Triple, |
| const llvm::opt::ArgList &Args); |
| |
| bool IsMathErrnoDefault() const override { return false; } |
| bool IsObjCNonFragileABIDefault() const override { return true; } |
| bool HasNativeLLVMSupport() const override; |
| bool isPICDefault() const override; |
| |
| unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override { |
| return 2; // SSPStrong |
| } |
| |
| llvm::DebuggerKind getDefaultDebuggerTuning() const override { |
| return llvm::DebuggerKind::SCE; |
| } |
| |
| SanitizerMask getSupportedSanitizers() const override; |
| |
| protected: |
| Tool *buildAssembler() const override; |
| Tool *buildLinker() const override; |
| }; |
| |
| } // end namespace toolchains |
| } // end namespace driver |
| } // end namespace clang |
| |
| #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H |
