forked from OSchip/llvm-project
1129 lines
40 KiB
C++
1129 lines
40 KiB
C++
//===--- 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/VersionTuple.h"
|
|
#include "clang/Driver/Action.h"
|
|
#include "clang/Driver/Multilib.h"
|
|
#include "clang/Driver/ToolChain.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/Optional.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 {
|
|
bool IsValid;
|
|
const Driver &D;
|
|
std::string CudaInstallPath;
|
|
std::string CudaLibPath;
|
|
std::string CudaLibDevicePath;
|
|
std::string CudaIncludePath;
|
|
llvm::StringMap<std::string> CudaLibDeviceMap;
|
|
|
|
public:
|
|
CudaInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
|
|
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args);
|
|
|
|
/// \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 detected Cuda installation path.
|
|
StringRef getInstallPath() const { return CudaInstallPath; }
|
|
/// \brief Get the detected Cuda Include path.
|
|
StringRef getIncludePath() const { return CudaIncludePath; }
|
|
/// \brief Get the detected Cuda library path.
|
|
StringRef getLibPath() const { return CudaLibPath; }
|
|
/// \brief Get the detected Cuda device library path.
|
|
StringRef getLibDevicePath() const { return CudaLibDevicePath; }
|
|
/// \brief Get libdevice file for given architecture
|
|
std::string getLibDeviceFile(StringRef Gpu) const {
|
|
return CudaLibDeviceMap.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
|
|
/// {
|
|
|
|
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
|
|
types::ID InputType) const override;
|
|
|
|
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);
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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
|
|
/// {
|
|
|
|
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 { return 2; }
|
|
// 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; }
|
|
|
|
/// }
|
|
|
|
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 { return false; }
|
|
|
|
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 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 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;
|
|
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 GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
|
|
void AddClangCXXStdlibIncludeArgs(
|
|
const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) 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 GetCXXStdlibType(const llvm::opt::ArgList &Args) 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;
|
|
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;
|
|
|
|
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;
|
|
};
|
|
|
|
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 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; }
|
|
|
|
std::string GetGnuDir(const std::string &InstalledDir,
|
|
const llvm::opt::ArgList &Args) const;
|
|
|
|
static StringRef GetTargetCPU(const llvm::opt::ArgList &Args);
|
|
|
|
static const char *GetSmallDataThreshold(const llvm::opt::ArgList &Args);
|
|
|
|
static bool UsesG0(const char *smallDataThreshold);
|
|
};
|
|
|
|
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);
|
|
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;
|
|
|
|
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_GCC {
|
|
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)
|
|
: ToolChain(D, Triple, 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;
|
|
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
|
|
llvm::opt::ArgStringList &CC1Args) 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
|
|
}
|
|
|
|
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
|