clang/lib/Basic/Targets/Sparc.cpp

   1 //===--- Sparc.cpp - Implement Sparc target feature support ---------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements Sparc TargetInfo objects.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "Sparc.h"
  14 #include "Targets.h"
  15 #include "clang/Basic/MacroBuilder.h"
  16 #include "llvm/ADT/StringSwitch.h"
  17
  18 using namespace clang;
  19 using namespace clang::targets;
  20
  21 const char *const SparcTargetInfo::GCCRegNames[] = {
  22     // Integer registers
  23     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",  "r8",  "r9",  "r10",
  24     "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21",
  25     "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
  26
  27     // Floating-point registers
  28     "f0",  "f1",  "f2",  "f3",  "f4",  "f5",  "f6",  "f7",  "f8",  "f9",  "f10",
  29     "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21",
  30     "f22", "f23", "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", "f32",
  31     "f34", "f36", "f38", "f40", "f42", "f44", "f46", "f48", "f50", "f52", "f54",
  32     "f56", "f58", "f60", "f62",
  33 };
  34
  35 ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const {
  36   return llvm::makeArrayRef(GCCRegNames);
  37 }
  38
  39 const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
  40     {{"g0"}, "r0"},  {{"g1"}, "r1"},  {{"g2"}, "r2"},        {{"g3"}, "r3"},
  41     {{"g4"}, "r4"},  {{"g5"}, "r5"},  {{"g6"}, "r6"},        {{"g7"}, "r7"},
  42     {{"o0"}, "r8"},  {{"o1"}, "r9"},  {{"o2"}, "r10"},       {{"o3"}, "r11"},
  43     {{"o4"}, "r12"}, {{"o5"}, "r13"}, {{"o6", "sp"}, "r14"}, {{"o7"}, "r15"},
  44     {{"l0"}, "r16"}, {{"l1"}, "r17"}, {{"l2"}, "r18"},       {{"l3"}, "r19"},
  45     {{"l4"}, "r20"}, {{"l5"}, "r21"}, {{"l6"}, "r22"},       {{"l7"}, "r23"},
  46     {{"i0"}, "r24"}, {{"i1"}, "r25"}, {{"i2"}, "r26"},       {{"i3"}, "r27"},
  47     {{"i4"}, "r28"}, {{"i5"}, "r29"}, {{"i6", "fp"}, "r30"}, {{"i7"}, "r31"},
  48 };
  49
  50 ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const {
  51   return llvm::makeArrayRef(GCCRegAliases);
  52 }
  53
  54 bool SparcTargetInfo::hasFeature(StringRef Feature) const {
  55   return llvm::StringSwitch<bool>(Feature)
  56       .Case("softfloat", SoftFloat)
  57       .Case("sparc", true)
  58       .Default(false);
  59 }
  60
  61 struct SparcCPUInfo {
  62   llvm::StringLiteral Name;
  63   SparcTargetInfo::CPUKind Kind;
  64   SparcTargetInfo::CPUGeneration Generation;
  65 };
  66
  67 static constexpr SparcCPUInfo CPUInfo[] = {
  68     {{"v8"}, SparcTargetInfo::CK_V8, SparcTargetInfo::CG_V8},
  69     {{"supersparc"}, SparcTargetInfo::CK_SUPERSPARC, SparcTargetInfo::CG_V8},
  70     {{"sparclite"}, SparcTargetInfo::CK_SPARCLITE, SparcTargetInfo::CG_V8},
  71     {{"f934"}, SparcTargetInfo::CK_F934, SparcTargetInfo::CG_V8},
  72     {{"hypersparc"}, SparcTargetInfo::CK_HYPERSPARC, SparcTargetInfo::CG_V8},
  73     {{"sparclite86x"},
  74      SparcTargetInfo::CK_SPARCLITE86X,
  75      SparcTargetInfo::CG_V8},
  76     {{"sparclet"}, SparcTargetInfo::CK_SPARCLET, SparcTargetInfo::CG_V8},
  77     {{"tsc701"}, SparcTargetInfo::CK_TSC701, SparcTargetInfo::CG_V8},
  78     {{"v9"}, SparcTargetInfo::CK_V9, SparcTargetInfo::CG_V9},
  79     {{"ultrasparc"}, SparcTargetInfo::CK_ULTRASPARC, SparcTargetInfo::CG_V9},
  80     {{"ultrasparc3"}, SparcTargetInfo::CK_ULTRASPARC3, SparcTargetInfo::CG_V9},
  81     {{"niagara"}, SparcTargetInfo::CK_NIAGARA, SparcTargetInfo::CG_V9},
  82     {{"niagara2"}, SparcTargetInfo::CK_NIAGARA2, SparcTargetInfo::CG_V9},
  83     {{"niagara3"}, SparcTargetInfo::CK_NIAGARA3, SparcTargetInfo::CG_V9},
  84     {{"niagara4"}, SparcTargetInfo::CK_NIAGARA4, SparcTargetInfo::CG_V9},
  85     {{"ma2100"}, SparcTargetInfo::CK_MYRIAD2100, SparcTargetInfo::CG_V8},
  86     {{"ma2150"}, SparcTargetInfo::CK_MYRIAD2150, SparcTargetInfo::CG_V8},
  87     {{"ma2155"}, SparcTargetInfo::CK_MYRIAD2155, SparcTargetInfo::CG_V8},
  88     {{"ma2450"}, SparcTargetInfo::CK_MYRIAD2450, SparcTargetInfo::CG_V8},
  89     {{"ma2455"}, SparcTargetInfo::CK_MYRIAD2455, SparcTargetInfo::CG_V8},
  90     {{"ma2x5x"}, SparcTargetInfo::CK_MYRIAD2x5x, SparcTargetInfo::CG_V8},
  91     {{"ma2080"}, SparcTargetInfo::CK_MYRIAD2080, SparcTargetInfo::CG_V8},
  92     {{"ma2085"}, SparcTargetInfo::CK_MYRIAD2085, SparcTargetInfo::CG_V8},
  93     {{"ma2480"}, SparcTargetInfo::CK_MYRIAD2480, SparcTargetInfo::CG_V8},
  94     {{"ma2485"}, SparcTargetInfo::CK_MYRIAD2485, SparcTargetInfo::CG_V8},
  95     {{"ma2x8x"}, SparcTargetInfo::CK_MYRIAD2x8x, SparcTargetInfo::CG_V8},
  96     // FIXME: the myriad2[.n] spellings are obsolete,
  97     // but a grace period is needed to allow updating dependent builds.
  98     {{"myriad2"}, SparcTargetInfo::CK_MYRIAD2x5x, SparcTargetInfo::CG_V8},
  99     {{"myriad2.1"}, SparcTargetInfo::CK_MYRIAD2100, SparcTargetInfo::CG_V8},
 100     {{"myriad2.2"}, SparcTargetInfo::CK_MYRIAD2x5x, SparcTargetInfo::CG_V8},
 101     {{"myriad2.3"}, SparcTargetInfo::CK_MYRIAD2x8x, SparcTargetInfo::CG_V8},
 102     {{"leon2"}, SparcTargetInfo::CK_LEON2, SparcTargetInfo::CG_V8},
 103     {{"at697e"}, SparcTargetInfo::CK_LEON2_AT697E, SparcTargetInfo::CG_V8},
 104     {{"at697f"}, SparcTargetInfo::CK_LEON2_AT697F, SparcTargetInfo::CG_V8},
 105     {{"leon3"}, SparcTargetInfo::CK_LEON3, SparcTargetInfo::CG_V8},
 106     {{"ut699"}, SparcTargetInfo::CK_LEON3_UT699, SparcTargetInfo::CG_V8},
 107     {{"gr712rc"}, SparcTargetInfo::CK_LEON3_GR712RC, SparcTargetInfo::CG_V8},
 108     {{"leon4"}, SparcTargetInfo::CK_LEON4, SparcTargetInfo::CG_V8},
 109     {{"gr740"}, SparcTargetInfo::CK_LEON4_GR740, SparcTargetInfo::CG_V8},
 110 };
 111
 112 SparcTargetInfo::CPUGeneration
 113 SparcTargetInfo::getCPUGeneration(CPUKind Kind) const {
 114   if (Kind == CK_GENERIC)
 115     return CG_V8;
 116   const SparcCPUInfo *Item = llvm::find_if(
 117       CPUInfo, [Kind](const SparcCPUInfo &Info) { return Info.Kind == Kind; });
 118   if (Item == std::end(CPUInfo))
 119     llvm_unreachable("Unexpected CPU kind");
 120   return Item->Generation;
 121 }
 122
 123 SparcTargetInfo::CPUKind SparcTargetInfo::getCPUKind(StringRef Name) const {
 124   const SparcCPUInfo *Item = llvm::find_if(
 125       CPUInfo, [Name](const SparcCPUInfo &Info) { return Info.Name == Name; });
 126
 127   if (Item == std::end(CPUInfo))
 128     return CK_GENERIC;
 129   return Item->Kind;
 130 }
 131
 132 void SparcTargetInfo::fillValidCPUList(
 133     SmallVectorImpl<StringRef> &Values) const {
 134   for (const SparcCPUInfo &Info : CPUInfo)
 135     Values.push_back(Info.Name);
 136 }
 137
 138 void SparcTargetInfo::getTargetDefines(const LangOptions &Opts,
 139                                        MacroBuilder &Builder) const {
 140   DefineStd(Builder, "sparc", Opts);
 141   Builder.defineMacro("__REGISTER_PREFIX__", "");
 142
 143   if (SoftFloat)
 144     Builder.defineMacro("SOFT_FLOAT", "1");
 145 }
 146
 147 void SparcV8TargetInfo::getTargetDefines(const LangOptions &Opts,
 148                                          MacroBuilder &Builder) const {
 149   SparcTargetInfo::getTargetDefines(Opts, Builder);
 150   if (getTriple().getOS() == llvm::Triple::Solaris)
 151     Builder.defineMacro("__sparcv8");
 152   else {
 153     switch (getCPUGeneration(CPU)) {
 154     case CG_V8:
 155       Builder.defineMacro("__sparcv8");
 156       Builder.defineMacro("__sparcv8__");
 157       break;
 158     case CG_V9:
 159       Builder.defineMacro("__sparc_v9__");
 160       break;
 161     }
 162   }
 163   if (getTriple().getVendor() == llvm::Triple::Myriad) {
 164     std::string MyriadArchValue, Myriad2Value;
 165     Builder.defineMacro("__sparc_v8__");
 166     Builder.defineMacro("__leon__");
 167     switch (CPU) {
 168     case CK_MYRIAD2100:
 169       MyriadArchValue = "__ma2100";
 170       Myriad2Value = "1";
 171       break;
 172     case CK_MYRIAD2150:
 173       MyriadArchValue = "__ma2150";
 174       Myriad2Value = "2";
 175       break;
 176     case CK_MYRIAD2155:
 177       MyriadArchValue = "__ma2155";
 178       Myriad2Value = "2";
 179       break;
 180     case CK_MYRIAD2450:
 181       MyriadArchValue = "__ma2450";
 182       Myriad2Value = "2";
 183       break;
 184     case CK_MYRIAD2455:
 185       MyriadArchValue = "__ma2455";
 186       Myriad2Value = "2";
 187       break;
 188     case CK_MYRIAD2x5x:
 189       Myriad2Value = "2";
 190       break;
 191     case CK_MYRIAD2080:
 192       MyriadArchValue = "__ma2080";
 193       Myriad2Value = "3";
 194       break;
 195     case CK_MYRIAD2085:
 196       MyriadArchValue = "__ma2085";
 197       Myriad2Value = "3";
 198       break;
 199     case CK_MYRIAD2480:
 200       MyriadArchValue = "__ma2480";
 201       Myriad2Value = "3";
 202       break;
 203     case CK_MYRIAD2485:
 204       MyriadArchValue = "__ma2485";
 205       Myriad2Value = "3";
 206       break;
 207     case CK_MYRIAD2x8x:
 208       Myriad2Value = "3";
 209       break;
 210     default:
 211       MyriadArchValue = "__ma2100";
 212       Myriad2Value = "1";
 213       break;
 214     }
 215     if (!MyriadArchValue.empty()) {
 216       Builder.defineMacro(MyriadArchValue, "1");
 217       Builder.defineMacro(MyriadArchValue + "__", "1");
 218     }
 219     if (Myriad2Value == "2") {
 220       Builder.defineMacro("__ma2x5x", "1");
 221       Builder.defineMacro("__ma2x5x__", "1");
 222     } else if (Myriad2Value == "3") {
 223       Builder.defineMacro("__ma2x8x", "1");
 224       Builder.defineMacro("__ma2x8x__", "1");
 225     }
 226     Builder.defineMacro("__myriad2__", Myriad2Value);
 227     Builder.defineMacro("__myriad2", Myriad2Value);
 228   }
 229   if (getCPUGeneration(CPU) == CG_V9) {
 230     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 231     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 232     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 233     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 234   }
 235 }
 236
 237 void SparcV9TargetInfo::getTargetDefines(const LangOptions &Opts,
 238                                          MacroBuilder &Builder) const {
 239   SparcTargetInfo::getTargetDefines(Opts, Builder);
 240   Builder.defineMacro("__sparcv9");
 241   Builder.defineMacro("__arch64__");
 242   // Solaris doesn't need these variants, but the BSDs do.
 243   if (getTriple().getOS() != llvm::Triple::Solaris) {
 244     Builder.defineMacro("__sparc64__");
 245     Builder.defineMacro("__sparc_v9__");
 246     Builder.defineMacro("__sparcv9__");
 247   }
 248
 249   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 250   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 251   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 252   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 253 }
 254
 255 void SparcV9TargetInfo::fillValidCPUList(
 256     SmallVectorImpl<StringRef> &Values) const {
 257   for (const SparcCPUInfo &Info : CPUInfo)
 258     if (Info.Generation == CG_V9)
 259       Values.push_back(Info.Name);
 260 }