2017-07-22 06:37:03 +08:00
|
|
|
//===--- OSTargets.h - Declare OS target feature support --------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file declares OS specific TargetInfo types.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
|
|
|
|
#define LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
|
|
|
|
|
|
|
|
#include "Targets.h"
|
|
|
|
#include "llvm/MC/MCSectionMachO.h"
|
|
|
|
|
|
|
|
namespace clang {
|
|
|
|
namespace targets {
|
|
|
|
|
|
|
|
template <typename TgtInfo>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY OSTargetInfo : public TgtInfo {
|
|
|
|
protected:
|
|
|
|
virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const = 0;
|
|
|
|
|
|
|
|
public:
|
|
|
|
OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: TgtInfo(Triple, Opts) {}
|
|
|
|
|
|
|
|
void getTargetDefines(const LangOptions &Opts,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
TgtInfo::getTargetDefines(Opts, Builder);
|
|
|
|
getOSDefines(Opts, TgtInfo::getTriple(), Builder);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// CloudABI Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY CloudABITargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
Builder.defineMacro("__CloudABI__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
|
|
|
|
// CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
|
|
|
|
Builder.defineMacro("__STDC_ISO_10646__", "201206L");
|
|
|
|
Builder.defineMacro("__STDC_UTF_16__");
|
|
|
|
Builder.defineMacro("__STDC_UTF_32__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Ananas target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY AnanasTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// Ananas defines
|
|
|
|
Builder.defineMacro("__Ananas__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
AnanasTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
|
|
|
|
const llvm::Triple &Triple, StringRef &PlatformName,
|
|
|
|
VersionTuple &PlatformMinVersion);
|
|
|
|
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY DarwinTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
|
|
|
|
this->PlatformMinVersion);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
// By default, no TLS, and we whitelist permitted architecture/OS
|
|
|
|
// combinations.
|
|
|
|
this->TLSSupported = false;
|
|
|
|
|
|
|
|
if (Triple.isMacOSX())
|
|
|
|
this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
|
|
|
|
else if (Triple.isiOS()) {
|
|
|
|
// 64-bit iOS supported it from 8 onwards, 32-bit from 9 onwards.
|
|
|
|
if (Triple.getArch() == llvm::Triple::x86_64 ||
|
|
|
|
Triple.getArch() == llvm::Triple::aarch64)
|
|
|
|
this->TLSSupported = !Triple.isOSVersionLT(8);
|
|
|
|
else if (Triple.getArch() == llvm::Triple::x86 ||
|
|
|
|
Triple.getArch() == llvm::Triple::arm ||
|
|
|
|
Triple.getArch() == llvm::Triple::thumb)
|
|
|
|
this->TLSSupported = !Triple.isOSVersionLT(9);
|
|
|
|
} else if (Triple.isWatchOS())
|
|
|
|
this->TLSSupported = !Triple.isOSVersionLT(2);
|
|
|
|
|
|
|
|
this->MCountName = "\01mcount";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string isValidSectionSpecifier(StringRef SR) const override {
|
|
|
|
// Let MCSectionMachO validate this.
|
|
|
|
StringRef Segment, Section;
|
|
|
|
unsigned TAA, StubSize;
|
|
|
|
bool HasTAA;
|
|
|
|
return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
|
|
|
|
TAA, HasTAA, StubSize);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *getStaticInitSectionSpecifier() const override {
|
|
|
|
// FIXME: We should return 0 when building kexts.
|
|
|
|
return "__TEXT,__StaticInit,regular,pure_instructions";
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Darwin does not support protected visibility. Darwin's "default"
|
|
|
|
/// is very similar to ELF's "protected"; Darwin requires a "weak"
|
|
|
|
/// attribute on declarations that can be dynamically replaced.
|
|
|
|
bool hasProtectedVisibility() const override { return false; }
|
|
|
|
};
|
|
|
|
|
|
|
|
// DragonFlyBSD Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY DragonFlyBSDTargetInfo
|
|
|
|
: public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// DragonFly defines; list based off of gcc output
|
|
|
|
Builder.defineMacro("__DragonFly__");
|
|
|
|
Builder.defineMacro("__DragonFly_cc_version", "100001");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
|
|
|
|
Builder.defineMacro("__tune_i386__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
case llvm::Triple::x86:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
this->MCountName = ".mcount";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifndef FREEBSD_CC_VERSION
|
|
|
|
#define FREEBSD_CC_VERSION 0U
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// FreeBSD Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY FreeBSDTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// FreeBSD defines; list based off of gcc output
|
|
|
|
|
|
|
|
unsigned Release = Triple.getOSMajorVersion();
|
|
|
|
if (Release == 0U)
|
|
|
|
Release = 8U;
|
|
|
|
unsigned CCVersion = FREEBSD_CC_VERSION;
|
|
|
|
if (CCVersion == 0U)
|
|
|
|
CCVersion = Release * 100000U + 1U;
|
|
|
|
|
|
|
|
Builder.defineMacro("__FreeBSD__", Twine(Release));
|
|
|
|
Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
|
|
|
|
Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
|
|
|
|
// On FreeBSD, wchar_t contains the number of the code point as
|
|
|
|
// used by the character set of the locale. These character sets are
|
|
|
|
// not necessarily a superset of ASCII.
|
|
|
|
//
|
|
|
|
// FIXME: This is wrong; the macro refers to the numerical values
|
|
|
|
// of wchar_t *literals*, which are not locale-dependent. However,
|
|
|
|
// FreeBSD systems apparently depend on us getting this wrong, and
|
|
|
|
// setting this to 1 is conforming even if all the basic source
|
|
|
|
// character literals have the same encoding as char and wchar_t.
|
|
|
|
Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
case llvm::Triple::x86:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
this->MCountName = ".mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::mips:
|
|
|
|
case llvm::Triple::mipsel:
|
|
|
|
case llvm::Triple::ppc:
|
|
|
|
case llvm::Triple::ppc64:
|
|
|
|
case llvm::Triple::ppc64le:
|
|
|
|
this->MCountName = "_mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::arm:
|
|
|
|
this->MCountName = "__mcount";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// GNU/kFreeBSD Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY KFreeBSDTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// GNU/kFreeBSD defines; list based off of gcc output
|
|
|
|
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__FreeBSD_kernel__");
|
|
|
|
Builder.defineMacro("__GLIBC__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Haiku Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY HaikuTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// Haiku defines; list based off of gcc output
|
|
|
|
Builder.defineMacro("__HAIKU__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->SizeType = TargetInfo::UnsignedLong;
|
|
|
|
this->IntPtrType = TargetInfo::SignedLong;
|
|
|
|
this->PtrDiffType = TargetInfo::SignedLong;
|
|
|
|
this->ProcessIDType = TargetInfo::SignedLong;
|
|
|
|
this->TLSSupported = false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Minix Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY MinixTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// Minix defines
|
|
|
|
|
|
|
|
Builder.defineMacro("__minix", "3");
|
|
|
|
Builder.defineMacro("_EM_WSIZE", "4");
|
|
|
|
Builder.defineMacro("_EM_PSIZE", "4");
|
|
|
|
Builder.defineMacro("_EM_SSIZE", "2");
|
|
|
|
Builder.defineMacro("_EM_LSIZE", "4");
|
|
|
|
Builder.defineMacro("_EM_FSIZE", "4");
|
|
|
|
Builder.defineMacro("_EM_DSIZE", "8");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Linux target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY LinuxTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// Linux defines; list based off of gcc output
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
DefineStd(Builder, "linux", Opts);
|
|
|
|
Builder.defineMacro("__gnu_linux__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
if (Triple.isAndroid()) {
|
|
|
|
Builder.defineMacro("__ANDROID__", "1");
|
|
|
|
unsigned Maj, Min, Rev;
|
|
|
|
Triple.getEnvironmentVersion(Maj, Min, Rev);
|
|
|
|
this->PlatformName = "android";
|
|
|
|
this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
|
|
|
|
if (Maj)
|
|
|
|
Builder.defineMacro("__ANDROID_API__", Twine(Maj));
|
|
|
|
}
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
|
|
|
if (this->HasFloat128)
|
|
|
|
Builder.defineMacro("__FLOAT128__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->WIntType = TargetInfo::UnsignedInt;
|
|
|
|
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case llvm::Triple::mips:
|
|
|
|
case llvm::Triple::mipsel:
|
|
|
|
case llvm::Triple::mips64:
|
|
|
|
case llvm::Triple::mips64el:
|
|
|
|
case llvm::Triple::ppc:
|
|
|
|
case llvm::Triple::ppc64:
|
|
|
|
case llvm::Triple::ppc64le:
|
|
|
|
this->MCountName = "_mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::x86:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
case llvm::Triple::systemz:
|
|
|
|
this->HasFloat128 = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *getStaticInitSectionSpecifier() const override {
|
|
|
|
return ".text.startup";
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// NetBSD Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY NetBSDTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// NetBSD defines; list based off of gcc output
|
|
|
|
Builder.defineMacro("__NetBSD__");
|
|
|
|
Builder.defineMacro("__unix__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case llvm::Triple::arm:
|
|
|
|
case llvm::Triple::armeb:
|
|
|
|
case llvm::Triple::thumb:
|
|
|
|
case llvm::Triple::thumbeb:
|
|
|
|
Builder.defineMacro("__ARM_DWARF_EH__");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->MCountName = "_mcount";
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// OpenBSD Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY OpenBSDTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// OpenBSD defines; list based off of gcc output
|
|
|
|
|
|
|
|
Builder.defineMacro("__OpenBSD__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
if (this->HasFloat128)
|
|
|
|
Builder.defineMacro("__FLOAT128__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
case llvm::Triple::x86:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
this->HasFloat128 = true;
|
|
|
|
// FALLTHROUGH
|
|
|
|
default:
|
|
|
|
this->MCountName = "__mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::mips64:
|
|
|
|
case llvm::Triple::mips64el:
|
|
|
|
case llvm::Triple::ppc:
|
|
|
|
case llvm::Triple::sparcv9:
|
|
|
|
this->MCountName = "_mcount";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// PSP Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY PSPTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// PSP defines; list based on the output of the pspdev gcc toolchain.
|
|
|
|
Builder.defineMacro("PSP");
|
|
|
|
Builder.defineMacro("_PSP");
|
|
|
|
Builder.defineMacro("__psp__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
|
|
|
|
};
|
|
|
|
|
|
|
|
// PS3 PPU Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY PS3PPUTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// PS3 PPU defines.
|
|
|
|
Builder.defineMacro("__PPC__");
|
|
|
|
Builder.defineMacro("__PPU__");
|
|
|
|
Builder.defineMacro("__CELLOS_LV2__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
Builder.defineMacro("__LP32__");
|
|
|
|
Builder.defineMacro("_ARCH_PPC64");
|
|
|
|
Builder.defineMacro("__powerpc64__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->LongWidth = this->LongAlign = 32;
|
|
|
|
this->PointerWidth = this->PointerAlign = 32;
|
|
|
|
this->IntMaxType = TargetInfo::SignedLongLong;
|
|
|
|
this->Int64Type = TargetInfo::SignedLongLong;
|
|
|
|
this->SizeType = TargetInfo::UnsignedInt;
|
|
|
|
this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY PS4OSTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
Builder.defineMacro("__FreeBSD__", "9");
|
|
|
|
Builder.defineMacro("__FreeBSD_cc_version", "900001");
|
|
|
|
Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
Builder.defineMacro("__ORBIS__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
2017-10-07 07:09:55 +08:00
|
|
|
this->WCharType = TargetInfo::UnsignedShort;
|
2017-07-22 06:37:03 +08:00
|
|
|
|
|
|
|
// On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
|
|
|
|
this->MaxTLSAlign = 256;
|
|
|
|
|
|
|
|
// On PS4, do not honor explicit bit field alignment,
|
|
|
|
// as in "__attribute__((aligned(2))) int b : 1;".
|
|
|
|
this->UseExplicitBitFieldAlignment = false;
|
|
|
|
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
case llvm::Triple::x86_64:
|
|
|
|
this->MCountName = ".mcount";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-08-01 05:00:16 +08:00
|
|
|
// RTEMS Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY RTEMSTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
// RTEMS defines; list based off of gcc output
|
|
|
|
|
|
|
|
Builder.defineMacro("__rtems__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
2017-08-02 22:36:52 +08:00
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
2017-08-01 05:00:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
switch (Triple.getArch()) {
|
|
|
|
default:
|
|
|
|
case llvm::Triple::x86:
|
|
|
|
// this->MCountName = ".mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::mips:
|
|
|
|
case llvm::Triple::mipsel:
|
|
|
|
case llvm::Triple::ppc:
|
|
|
|
case llvm::Triple::ppc64:
|
|
|
|
case llvm::Triple::ppc64le:
|
|
|
|
// this->MCountName = "_mcount";
|
|
|
|
break;
|
|
|
|
case llvm::Triple::arm:
|
|
|
|
// this->MCountName = "__mcount";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-07-22 06:37:03 +08:00
|
|
|
// Solaris target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY SolarisTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
DefineStd(Builder, "sun", Opts);
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
Builder.defineMacro("__svr4__");
|
|
|
|
Builder.defineMacro("__SVR4");
|
|
|
|
// Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
|
|
|
|
// newer, but to 500 for everything else. feature_test.h has a check to
|
|
|
|
// ensure that you are not using C99 with an old version of X/Open or C89
|
|
|
|
// with a new version.
|
|
|
|
if (Opts.C99)
|
|
|
|
Builder.defineMacro("_XOPEN_SOURCE", "600");
|
|
|
|
else
|
|
|
|
Builder.defineMacro("_XOPEN_SOURCE", "500");
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("__C99FEATURES__");
|
|
|
|
Builder.defineMacro("_LARGEFILE_SOURCE");
|
|
|
|
Builder.defineMacro("_LARGEFILE64_SOURCE");
|
|
|
|
Builder.defineMacro("__EXTENSIONS__");
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
// FIXME: WIntType should be SignedLong
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Windows target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY WindowsTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
Builder.defineMacro("_WIN32");
|
|
|
|
}
|
|
|
|
void getVisualStudioDefines(const LangOptions &Opts,
|
|
|
|
MacroBuilder &Builder) const {
|
|
|
|
if (Opts.CPlusPlus) {
|
|
|
|
if (Opts.RTTIData)
|
|
|
|
Builder.defineMacro("_CPPRTTI");
|
|
|
|
|
|
|
|
if (Opts.CXXExceptions)
|
|
|
|
Builder.defineMacro("_CPPUNWIND");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Opts.Bool)
|
|
|
|
Builder.defineMacro("__BOOL_DEFINED");
|
|
|
|
|
|
|
|
if (!Opts.CharIsSigned)
|
|
|
|
Builder.defineMacro("_CHAR_UNSIGNED");
|
|
|
|
|
|
|
|
// FIXME: POSIXThreads isn't exactly the option this should be defined for,
|
|
|
|
// but it works for now.
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_MT");
|
|
|
|
|
|
|
|
if (Opts.MSCompatibilityVersion) {
|
|
|
|
Builder.defineMacro("_MSC_VER",
|
|
|
|
Twine(Opts.MSCompatibilityVersion / 100000));
|
|
|
|
Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
|
|
|
|
// FIXME We cannot encode the revision information into 32-bits
|
|
|
|
Builder.defineMacro("_MSC_BUILD", Twine(1));
|
|
|
|
|
|
|
|
if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
|
|
|
|
Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
|
|
|
|
|
|
|
|
if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
|
|
|
|
if (Opts.CPlusPlus1z)
|
|
|
|
Builder.defineMacro("_MSVC_LANG", "201403L");
|
|
|
|
else if (Opts.CPlusPlus14)
|
|
|
|
Builder.defineMacro("_MSVC_LANG", "201402L");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Opts.MicrosoftExt) {
|
|
|
|
Builder.defineMacro("_MSC_EXTENSIONS");
|
|
|
|
|
|
|
|
if (Opts.CPlusPlus11) {
|
|
|
|
Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
|
|
|
|
Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
|
|
|
|
Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
2017-10-07 07:09:55 +08:00
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->WCharType = TargetInfo::UnsignedShort;
|
|
|
|
}
|
2017-07-22 06:37:03 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY NaClTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
|
|
|
|
|
|
|
DefineStd(Builder, "unix", Opts);
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
Builder.defineMacro("__native_client__");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->LongAlign = 32;
|
|
|
|
this->LongWidth = 32;
|
|
|
|
this->PointerAlign = 32;
|
|
|
|
this->PointerWidth = 32;
|
|
|
|
this->IntMaxType = TargetInfo::SignedLongLong;
|
|
|
|
this->Int64Type = TargetInfo::SignedLongLong;
|
|
|
|
this->DoubleAlign = 64;
|
|
|
|
this->LongDoubleWidth = 64;
|
|
|
|
this->LongDoubleAlign = 64;
|
|
|
|
this->LongLongWidth = 64;
|
|
|
|
this->LongLongAlign = 64;
|
|
|
|
this->SizeType = TargetInfo::UnsignedInt;
|
|
|
|
this->PtrDiffType = TargetInfo::SignedInt;
|
|
|
|
this->IntPtrType = TargetInfo::SignedInt;
|
|
|
|
// RegParmMax is inherited from the underlying architecture.
|
|
|
|
this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
|
|
|
|
if (Triple.getArch() == llvm::Triple::arm) {
|
|
|
|
// Handled in ARM's setABI().
|
|
|
|
} else if (Triple.getArch() == llvm::Triple::x86) {
|
|
|
|
this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
|
|
|
|
} else if (Triple.getArch() == llvm::Triple::x86_64) {
|
|
|
|
this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
|
|
|
|
} else if (Triple.getArch() == llvm::Triple::mipsel) {
|
|
|
|
// Handled on mips' setDataLayout.
|
|
|
|
} else {
|
|
|
|
assert(Triple.getArch() == llvm::Triple::le32);
|
|
|
|
this->resetDataLayout("e-p:32:32-i64:64");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Fuchsia Target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY FuchsiaTargetInfo : public OSTargetInfo<Target> {
|
|
|
|
protected:
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const override {
|
|
|
|
Builder.defineMacro("__Fuchsia__");
|
|
|
|
Builder.defineMacro("__ELF__");
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
// Required by the libc++ locale support.
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
FuchsiaTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->MCountName = "__mcount";
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// WebAssembly target
|
|
|
|
template <typename Target>
|
|
|
|
class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo
|
|
|
|
: public OSTargetInfo<Target> {
|
|
|
|
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
|
|
|
|
MacroBuilder &Builder) const final {
|
|
|
|
// A common platform macro.
|
|
|
|
if (Opts.POSIXThreads)
|
|
|
|
Builder.defineMacro("_REENTRANT");
|
|
|
|
// Follow g++ convention and predefine _GNU_SOURCE for C++.
|
|
|
|
if (Opts.CPlusPlus)
|
|
|
|
Builder.defineMacro("_GNU_SOURCE");
|
|
|
|
}
|
|
|
|
|
|
|
|
// As an optimization, group static init code together in a section.
|
|
|
|
const char *getStaticInitSectionSpecifier() const final {
|
|
|
|
return ".text.__startup";
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
|
|
|
|
const TargetOptions &Opts)
|
|
|
|
: OSTargetInfo<Target>(Triple, Opts) {
|
|
|
|
this->MCountName = "__mcount";
|
|
|
|
this->TheCXXABI.set(TargetCXXABI::WebAssembly);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace targets
|
|
|
|
} // namespace clang
|
|
|
|
#endif // LLVM_CLANG_LIB_BASIC_TARGETS_OSTARGETS_H
|