| //===--- Sparc.cpp - Implement Sparc target feature support ---------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements Sparc TargetInfo objects. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "Sparc.h" |
| #include "Targets.h" |
| #include "clang/Basic/MacroBuilder.h" |
| #include "llvm/ADT/StringSwitch.h" |
| |
| using namespace clang; |
| using namespace clang::targets; |
| |
| const char *const SparcTargetInfo::GCCRegNames[] = { |
| "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", |
| "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", |
| "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31" |
| }; |
| |
| ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const { |
| return llvm::makeArrayRef(GCCRegNames); |
| } |
| |
| const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = { |
| {{"g0"}, "r0"}, {{"g1"}, "r1"}, {{"g2"}, "r2"}, {{"g3"}, "r3"}, |
| {{"g4"}, "r4"}, {{"g5"}, "r5"}, {{"g6"}, "r6"}, {{"g7"}, "r7"}, |
| {{"o0"}, "r8"}, {{"o1"}, "r9"}, {{"o2"}, "r10"}, {{"o3"}, "r11"}, |
| {{"o4"}, "r12"}, {{"o5"}, "r13"}, {{"o6", "sp"}, "r14"}, {{"o7"}, "r15"}, |
| {{"l0"}, "r16"}, {{"l1"}, "r17"}, {{"l2"}, "r18"}, {{"l3"}, "r19"}, |
| {{"l4"}, "r20"}, {{"l5"}, "r21"}, {{"l6"}, "r22"}, {{"l7"}, "r23"}, |
| {{"i0"}, "r24"}, {{"i1"}, "r25"}, {{"i2"}, "r26"}, {{"i3"}, "r27"}, |
| {{"i4"}, "r28"}, {{"i5"}, "r29"}, {{"i6", "fp"}, "r30"}, {{"i7"}, "r31"}, |
| }; |
| |
| ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const { |
| return llvm::makeArrayRef(GCCRegAliases); |
| } |
| |
| bool SparcTargetInfo::hasFeature(StringRef Feature) const { |
| return llvm::StringSwitch<bool>(Feature) |
| .Case("softfloat", SoftFloat) |
| .Case("sparc", true) |
| .Default(false); |
| } |
| |
| SparcTargetInfo::CPUKind SparcTargetInfo::getCPUKind(StringRef Name) const { |
| return llvm::StringSwitch<CPUKind>(Name) |
| .Case("v8", CK_V8) |
| .Case("supersparc", CK_SUPERSPARC) |
| .Case("sparclite", CK_SPARCLITE) |
| .Case("f934", CK_F934) |
| .Case("hypersparc", CK_HYPERSPARC) |
| .Case("sparclite86x", CK_SPARCLITE86X) |
| .Case("sparclet", CK_SPARCLET) |
| .Case("tsc701", CK_TSC701) |
| .Case("v9", CK_V9) |
| .Case("ultrasparc", CK_ULTRASPARC) |
| .Case("ultrasparc3", CK_ULTRASPARC3) |
| .Case("niagara", CK_NIAGARA) |
| .Case("niagara2", CK_NIAGARA2) |
| .Case("niagara3", CK_NIAGARA3) |
| .Case("niagara4", CK_NIAGARA4) |
| .Case("ma2100", CK_MYRIAD2100) |
| .Case("ma2150", CK_MYRIAD2150) |
| .Case("ma2155", CK_MYRIAD2155) |
| .Case("ma2450", CK_MYRIAD2450) |
| .Case("ma2455", CK_MYRIAD2455) |
| .Case("ma2x5x", CK_MYRIAD2x5x) |
| .Case("ma2080", CK_MYRIAD2080) |
| .Case("ma2085", CK_MYRIAD2085) |
| .Case("ma2480", CK_MYRIAD2480) |
| .Case("ma2485", CK_MYRIAD2485) |
| .Case("ma2x8x", CK_MYRIAD2x8x) |
| // FIXME: the myriad2[.n] spellings are obsolete, |
| // but a grace period is needed to allow updating dependent builds. |
| .Case("myriad2", CK_MYRIAD2x5x) |
| .Case("myriad2.1", CK_MYRIAD2100) |
| .Case("myriad2.2", CK_MYRIAD2x5x) |
| .Case("myriad2.3", CK_MYRIAD2x8x) |
| .Case("leon2", CK_LEON2) |
| .Case("at697e", CK_LEON2_AT697E) |
| .Case("at697f", CK_LEON2_AT697F) |
| .Case("leon3", CK_LEON3) |
| .Case("ut699", CK_LEON3_UT699) |
| .Case("gr712rc", CK_LEON3_GR712RC) |
| .Case("leon4", CK_LEON4) |
| .Case("gr740", CK_LEON4_GR740) |
| .Default(CK_GENERIC); |
| } |
| |
| void SparcTargetInfo::getTargetDefines(const LangOptions &Opts, |
| MacroBuilder &Builder) const { |
| DefineStd(Builder, "sparc", Opts); |
| Builder.defineMacro("__REGISTER_PREFIX__", ""); |
| |
| if (SoftFloat) |
| Builder.defineMacro("SOFT_FLOAT", "1"); |
| } |
| |
| void SparcV8TargetInfo::getTargetDefines(const LangOptions &Opts, |
| MacroBuilder &Builder) const { |
| SparcTargetInfo::getTargetDefines(Opts, Builder); |
| switch (getCPUGeneration(CPU)) { |
| case CG_V8: |
| Builder.defineMacro("__sparcv8"); |
| if (getTriple().getOS() != llvm::Triple::Solaris) |
| Builder.defineMacro("__sparcv8__"); |
| break; |
| case CG_V9: |
| Builder.defineMacro("__sparcv9"); |
| if (getTriple().getOS() != llvm::Triple::Solaris) { |
| Builder.defineMacro("__sparcv9__"); |
| Builder.defineMacro("__sparc_v9__"); |
| } |
| break; |
| } |
| if (getTriple().getVendor() == llvm::Triple::Myriad) { |
| std::string MyriadArchValue, Myriad2Value; |
| Builder.defineMacro("__sparc_v8__"); |
| Builder.defineMacro("__leon__"); |
| switch (CPU) { |
| case CK_MYRIAD2100: |
| MyriadArchValue = "__ma2100"; |
| Myriad2Value = "1"; |
| break; |
| case CK_MYRIAD2150: |
| MyriadArchValue = "__ma2150"; |
| Myriad2Value = "2"; |
| break; |
| case CK_MYRIAD2155: |
| MyriadArchValue = "__ma2155"; |
| Myriad2Value = "2"; |
| break; |
| case CK_MYRIAD2450: |
| MyriadArchValue = "__ma2450"; |
| Myriad2Value = "2"; |
| break; |
| case CK_MYRIAD2455: |
| MyriadArchValue = "__ma2455"; |
| Myriad2Value = "2"; |
| break; |
| case CK_MYRIAD2x5x: |
| Myriad2Value = "2"; |
| break; |
| case CK_MYRIAD2080: |
| MyriadArchValue = "__ma2080"; |
| Myriad2Value = "3"; |
| break; |
| case CK_MYRIAD2085: |
| MyriadArchValue = "__ma2085"; |
| Myriad2Value = "3"; |
| break; |
| case CK_MYRIAD2480: |
| MyriadArchValue = "__ma2480"; |
| Myriad2Value = "3"; |
| break; |
| case CK_MYRIAD2485: |
| MyriadArchValue = "__ma2485"; |
| Myriad2Value = "3"; |
| break; |
| case CK_MYRIAD2x8x: |
| Myriad2Value = "3"; |
| break; |
| default: |
| MyriadArchValue = "__ma2100"; |
| Myriad2Value = "1"; |
| break; |
| } |
| if (!MyriadArchValue.empty()) { |
| Builder.defineMacro(MyriadArchValue, "1"); |
| Builder.defineMacro(MyriadArchValue + "__", "1"); |
| } |
| Builder.defineMacro("__myriad2__", Myriad2Value); |
| Builder.defineMacro("__myriad2", Myriad2Value); |
| } |
| } |
| |
| void SparcV9TargetInfo::getTargetDefines(const LangOptions &Opts, |
| MacroBuilder &Builder) const { |
| SparcTargetInfo::getTargetDefines(Opts, Builder); |
| Builder.defineMacro("__sparcv9"); |
| Builder.defineMacro("__arch64__"); |
| // Solaris doesn't need these variants, but the BSDs do. |
| if (getTriple().getOS() != llvm::Triple::Solaris) { |
| Builder.defineMacro("__sparc64__"); |
| Builder.defineMacro("__sparc_v9__"); |
| Builder.defineMacro("__sparcv9__"); |
| } |
| } |