Page MenuHomePhabricator
Differential D12002 Diff 33985 cfe/trunk/lib/Basic/Targets.cpp

Changeset View

Standalone View

View Options

cfe/trunk/lib/Basic/Targets.cpp

Show First 20 Lines • Show All 728 Lines • ▼ Show 20 Lines if (Triple.getArch() == llvm::Triple::arm) {
// Handled on mips' setDataLayoutString. // Handled on mips' setDataLayoutString.
} else { } else {
assert(Triple.getArch() == llvm::Triple::le32); assert(Triple.getArch() == llvm::Triple::le32);
this->DataLayoutString = "e-p:32:32-i64:64"; this->DataLayoutString = "e-p:32:32-i64:64";
} }
} }
}; };
namespace {
// WebAssembly target
template <typename Target>
class WebAssemblyOSTargetInfo : public OSTargetInfo<Target> {
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
MacroBuilder &Builder) const override 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 override final {
return ".text.__startup";
}
public:
explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple)
: OSTargetInfo<Target>(Triple) {
this->MCountName = "__mcount";
this->UserLabelPrefix = "";
this->TheCXXABI.set(TargetCXXABI::WebAssembly);
}
};
} // end anonymous namespace
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Specific target implementations. // Specific target implementations.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// PPC abstract base class // PPC abstract base class
class PPCTargetInfo : public TargetInfo { class PPCTargetInfo : public TargetInfo {
static const Builtin::Info BuiltinInfo[]; static const Builtin::Info BuiltinInfo[];
static const char * const GCCRegNames[]; static const char * const GCCRegNames[];
▲ Show 20 Lines • Show All 6,205 Lines • ▼ Show 20 Linespublic:
} }
bool validateAsmConstraint(const char *&Name, bool validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &Info) const override { TargetInfo::ConstraintInfo &Info) const override {
return false; return false;
} }
bool hasProtectedVisibility() const override { return false; } bool hasProtectedVisibility() const override { return false; }
}; };
class WebAssemblyTargetInfo : public TargetInfo {
static const Builtin::Info BuiltinInfo[];
enum SIMDEnum {
NoSIMD,
SIMD128,
} SIMDLevel;
public:
explicit WebAssemblyTargetInfo(const llvm::Triple &T)
: TargetInfo(T), SIMDLevel(NoSIMD) {
BigEndian = false;
NoAsmVariants = true;
SuitableAlign = 128;
LargeArrayMinWidth = 128;
LargeArrayAlign = 128;
SimdDefaultAlign = 128;
}
protected:
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override {
defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
if (SIMDLevel >= SIMD128)
Builder.defineMacro("__wasm_simd128__");
}
private:
bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
StringRef CPU,
std::vector<std::string> &FeaturesVec) const override {
if (CPU == "bleeding-edge")
Features["simd128"] = true;
return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
}
bool hasFeature(StringRef Feature) const override final {
return llvm::StringSwitch<bool>(Feature)
.Case("simd128", SIMDLevel >= SIMD128)
.Default(false);
}
bool handleTargetFeatures(std::vector<std::string> &Features,
DiagnosticsEngine &Diags) override final {
for (const auto &Feature : Features) {
if (Feature == "+simd128") {
SIMDLevel = std::max(SIMDLevel, SIMD128);
continue;
}
if (Feature == "-simd128") {
SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
continue;
}
Diags.Report(diag::err_opt_not_valid_with_opt) << Feature
<< "-target-feature";
return false;
}
return true;
}
bool setCPU(const std::string &Name) override final {
return llvm::StringSwitch<bool>(Name)
.Case("mvp", true)
.Case("bleeding-edge", true)
.Case("generic", true)
.Default(false);
}
void getTargetBuiltins(const Builtin::Info *&Records,
unsigned &NumRecords) const override final {
Records = BuiltinInfo;
NumRecords = clang::WebAssembly::LastTSBuiltin - Builtin::FirstTSBuiltin;
}
BuiltinVaListKind getBuiltinVaListKind() const override final {
// TODO: Implement va_list properly.
return VoidPtrBuiltinVaList;
}
void getGCCRegNames(const char *const *&Names,
unsigned &NumNames) const override final {
Names = nullptr;
NumNames = 0;
}
void getGCCRegAliases(const GCCRegAlias *&Aliases,
unsigned &NumAliases) const override final {
Aliases = nullptr;
NumAliases = 0;
}
bool
validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &Info) const override final {
return false;
}
const char *getClobbers() const override final { return ""; }
bool isCLZForZeroUndef() const override final { return false; }
bool hasInt128Type() const override final { return true; }
};
const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
#define BUILTIN(ID, TYPE, ATTRS) \
{ #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
{ #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
#include "clang/Basic/BuiltinsWebAssembly.def"
};
class WebAssembly32TargetInfo : public WebAssemblyTargetInfo {
public:
explicit WebAssembly32TargetInfo(const llvm::Triple &T)
: WebAssemblyTargetInfo(T) {
// TODO: Set this to the correct value once the spec issues are resolved.
MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
DataLayoutString = "e-p:32:32-i64:64-n32:64-S128";
}
protected:
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override {
WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
}
};
class WebAssembly64TargetInfo : public WebAssemblyTargetInfo {
public:
explicit WebAssembly64TargetInfo(const llvm::Triple &T)
: WebAssemblyTargetInfo(T) {
LongAlign = LongWidth = 64;
PointerAlign = PointerWidth = 64;
// TODO: Set this to the correct value once the spec issues are resolved.
MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
DataLayoutString = "e-p:64:64-i64:64-n32:64-S128";
}
protected:
void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const override {
WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
}
};
} // end anonymous namespace. } // end anonymous namespace.
const Builtin::Info Le64TargetInfo::BuiltinInfo[] = { const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
#define BUILTIN(ID, TYPE, ATTRS) \ #define BUILTIN(ID, TYPE, ATTRS) \
{ #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr }, { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
#include "clang/Basic/BuiltinsLe64.def" #include "clang/Basic/BuiltinsLe64.def"
}; };
▲ Show 20 Lines • Show All 588 Lines • ▼ Show 20 Lines case llvm::Triple::spir: {
return new SPIR32TargetInfo(Triple); return new SPIR32TargetInfo(Triple);
} }
case llvm::Triple::spir64: { case llvm::Triple::spir64: {
if (Triple.getOS() != llvm::Triple::UnknownOS || if (Triple.getOS() != llvm::Triple::UnknownOS ||
Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
return nullptr; return nullptr;
return new SPIR64TargetInfo(Triple); return new SPIR64TargetInfo(Triple);
} }
case llvm::Triple::wasm32:
if (!(Triple == llvm::Triple("wasm32-unknown-unknown")))
return nullptr;
return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple);
case llvm::Triple::wasm64:
if (!(Triple == llvm::Triple("wasm64-unknown-unknown")))
return nullptr;
return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple);
} }
} }
/// CreateTargetInfo - Return the target info object for the specified target /// CreateTargetInfo - Return the target info object for the specified target
/// options. /// options.
TargetInfo * TargetInfo *
TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
const std::shared_ptr<TargetOptions> &Opts) { const std::shared_ptr<TargetOptions> &Opts) {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines