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 switch (getCPUGeneration(CPU)) { 151 case CG_V8: 152 Builder.defineMacro("__sparcv8"); 153 if (getTriple().getOS() != llvm::Triple::Solaris) 154 Builder.defineMacro("__sparcv8__"); 155 break; 156 case CG_V9: 157 Builder.defineMacro("__sparcv9"); 158 if (getTriple().getOS() != llvm::Triple::Solaris) { 159 Builder.defineMacro("__sparcv9__"); 160 Builder.defineMacro("__sparc_v9__"); 161 } 162 break; 163 } 164 if (getTriple().getVendor() == llvm::Triple::Myriad) { 165 std::string MyriadArchValue, Myriad2Value; 166 Builder.defineMacro("__sparc_v8__"); 167 Builder.defineMacro("__leon__"); 168 switch (CPU) { 169 case CK_MYRIAD2100: 170 MyriadArchValue = "__ma2100"; 171 Myriad2Value = "1"; 172 break; 173 case CK_MYRIAD2150: 174 MyriadArchValue = "__ma2150"; 175 Myriad2Value = "2"; 176 break; 177 case CK_MYRIAD2155: 178 MyriadArchValue = "__ma2155"; 179 Myriad2Value = "2"; 180 break; 181 case CK_MYRIAD2450: 182 MyriadArchValue = "__ma2450"; 183 Myriad2Value = "2"; 184 break; 185 case CK_MYRIAD2455: 186 MyriadArchValue = "__ma2455"; 187 Myriad2Value = "2"; 188 break; 189 case CK_MYRIAD2x5x: 190 Myriad2Value = "2"; 191 break; 192 case CK_MYRIAD2080: 193 MyriadArchValue = "__ma2080"; 194 Myriad2Value = "3"; 195 break; 196 case CK_MYRIAD2085: 197 MyriadArchValue = "__ma2085"; 198 Myriad2Value = "3"; 199 break; 200 case CK_MYRIAD2480: 201 MyriadArchValue = "__ma2480"; 202 Myriad2Value = "3"; 203 break; 204 case CK_MYRIAD2485: 205 MyriadArchValue = "__ma2485"; 206 Myriad2Value = "3"; 207 break; 208 case CK_MYRIAD2x8x: 209 Myriad2Value = "3"; 210 break; 211 default: 212 MyriadArchValue = "__ma2100"; 213 Myriad2Value = "1"; 214 break; 215 } 216 if (!MyriadArchValue.empty()) { 217 Builder.defineMacro(MyriadArchValue, "1"); 218 Builder.defineMacro(MyriadArchValue + "__", "1"); 219 } 220 if (Myriad2Value == "2") { 221 Builder.defineMacro("__ma2x5x", "1"); 222 Builder.defineMacro("__ma2x5x__", "1"); 223 } else if (Myriad2Value == "3") { 224 Builder.defineMacro("__ma2x8x", "1"); 225 Builder.defineMacro("__ma2x8x__", "1"); 226 } 227 Builder.defineMacro("__myriad2__", Myriad2Value); 228 Builder.defineMacro("__myriad2", Myriad2Value); 229 } 230 } 231 232 void SparcV9TargetInfo::getTargetDefines(const LangOptions &Opts, 233 MacroBuilder &Builder) const { 234 SparcTargetInfo::getTargetDefines(Opts, Builder); 235 Builder.defineMacro("__sparcv9"); 236 Builder.defineMacro("__arch64__"); 237 // Solaris doesn't need these variants, but the BSDs do. 238 if (getTriple().getOS() != llvm::Triple::Solaris) { 239 Builder.defineMacro("__sparc64__"); 240 Builder.defineMacro("__sparc_v9__"); 241 Builder.defineMacro("__sparcv9__"); 242 } 243 } 244 245 void SparcV9TargetInfo::fillValidCPUList( 246 SmallVectorImpl<StringRef> &Values) const { 247 for (const SparcCPUInfo &Info : CPUInfo) 248 if (Info.Generation == CG_V9) 249 Values.push_back(Info.Name); 250 } 251