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 } 261