1 //===- SubtargetFeature.cpp - CPU characteristics Implementation ----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the SubtargetFeature interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/MC/SubtargetFeature.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/Format.h" 17 #include "llvm/Support/raw_ostream.h" 18 #include <algorithm> 19 #include <cassert> 20 #include <cctype> 21 #include <cstdlib> 22 using namespace llvm; 23 24 //===----------------------------------------------------------------------===// 25 // Static Helper Functions 26 //===----------------------------------------------------------------------===// 27 28 /// hasFlag - Determine if a feature has a flag; '+' or '-' 29 /// 30 static inline bool hasFlag(const StringRef Feature) { 31 assert(!Feature.empty() && "Empty string"); 32 // Get first character 33 char Ch = Feature[0]; 34 // Check if first character is '+' or '-' flag 35 return Ch == '+' || Ch =='-'; 36 } 37 38 /// StripFlag - Return string stripped of flag. 39 /// 40 static inline std::string StripFlag(const StringRef Feature) { 41 return hasFlag(Feature) ? Feature.substr(1) : Feature; 42 } 43 44 /// isEnabled - Return true if enable flag; '+'. 45 /// 46 static inline bool isEnabled(const StringRef Feature) { 47 assert(!Feature.empty() && "Empty string"); 48 // Get first character 49 char Ch = Feature[0]; 50 // Check if first character is '+' for enabled 51 return Ch == '+'; 52 } 53 54 /// PrependFlag - Return a string with a prepended flag; '+' or '-'. 55 /// 56 static inline std::string PrependFlag(const StringRef Feature, 57 bool IsEnabled) { 58 assert(!Feature.empty() && "Empty string"); 59 if (hasFlag(Feature)) 60 return Feature; 61 std::string Prefix = IsEnabled ? "+" : "-"; 62 Prefix += Feature; 63 return Prefix; 64 } 65 66 /// Split - Splits a string of comma separated items in to a vector of strings. 67 /// 68 static void Split(std::vector<std::string> &V, const StringRef S) { 69 if (S.empty()) 70 return; 71 72 // Start at beginning of string. 73 size_t Pos = 0; 74 while (true) { 75 // Find the next comma 76 size_t Comma = S.find(',', Pos); 77 // If no comma found then the rest of the string is used 78 if (Comma == std::string::npos) { 79 // Add string to vector 80 V.push_back(S.substr(Pos)); 81 break; 82 } 83 // Otherwise add substring to vector 84 V.push_back(S.substr(Pos, Comma - Pos)); 85 // Advance to next item 86 Pos = Comma + 1; 87 } 88 } 89 90 /// Join a vector of strings to a string with a comma separating each element. 91 /// 92 static std::string Join(const std::vector<std::string> &V) { 93 // Start with empty string. 94 std::string Result; 95 // If the vector is not empty 96 if (!V.empty()) { 97 // Start with the first feature 98 Result = V[0]; 99 // For each successive feature 100 for (size_t i = 1; i < V.size(); i++) { 101 // Add a comma 102 Result += ","; 103 // Add the feature 104 Result += V[i]; 105 } 106 } 107 // Return the features string 108 return Result; 109 } 110 111 /// Adding features. 112 void SubtargetFeatures::AddFeature(const StringRef String, 113 bool IsEnabled) { 114 // Don't add empty features 115 if (!String.empty()) { 116 // Convert to lowercase, prepend flag and add to vector 117 Features.push_back(PrependFlag(String.lower(), IsEnabled)); 118 } 119 } 120 121 /// Find KV in array using binary search. 122 static const SubtargetFeatureKV *Find(StringRef S, const SubtargetFeatureKV *A, 123 size_t L) { 124 // Make the lower bound element we're looking for 125 SubtargetFeatureKV KV; 126 KV.Key = S.data(); 127 // Determine the end of the array 128 const SubtargetFeatureKV *Hi = A + L; 129 // Binary search the array 130 const SubtargetFeatureKV *F = std::lower_bound(A, Hi, KV); 131 // If not found then return NULL 132 if (F == Hi || StringRef(F->Key) != S) return NULL; 133 // Return the found array item 134 return F; 135 } 136 137 /// getLongestEntryLength - Return the length of the longest entry in the table. 138 /// 139 static size_t getLongestEntryLength(const SubtargetFeatureKV *Table, 140 size_t Size) { 141 size_t MaxLen = 0; 142 for (size_t i = 0; i < Size; i++) 143 MaxLen = std::max(MaxLen, std::strlen(Table[i].Key)); 144 return MaxLen; 145 } 146 147 /// Display help for feature choices. 148 /// 149 static void Help(const SubtargetFeatureKV *CPUTable, size_t CPUTableSize, 150 const SubtargetFeatureKV *FeatTable, size_t FeatTableSize) { 151 // Determine the length of the longest CPU and Feature entries. 152 unsigned MaxCPULen = getLongestEntryLength(CPUTable, CPUTableSize); 153 unsigned MaxFeatLen = getLongestEntryLength(FeatTable, FeatTableSize); 154 155 // Print the CPU table. 156 errs() << "Available CPUs for this target:\n\n"; 157 for (size_t i = 0; i != CPUTableSize; i++) 158 errs() << format(" %-*s - %s.\n", 159 MaxCPULen, CPUTable[i].Key, CPUTable[i].Desc); 160 errs() << '\n'; 161 162 // Print the Feature table. 163 errs() << "Available features for this target:\n\n"; 164 for (size_t i = 0; i != FeatTableSize; i++) 165 errs() << format(" %-*s - %s.\n", 166 MaxFeatLen, FeatTable[i].Key, FeatTable[i].Desc); 167 errs() << '\n'; 168 169 errs() << "Use +feature to enable a feature, or -feature to disable it.\n" 170 "For example, llc -mcpu=mycpu -mattr=+feature1,-feature2\n"; 171 std::exit(1); 172 } 173 174 //===----------------------------------------------------------------------===// 175 // SubtargetFeatures Implementation 176 //===----------------------------------------------------------------------===// 177 178 SubtargetFeatures::SubtargetFeatures(const StringRef Initial) { 179 // Break up string into separate features 180 Split(Features, Initial); 181 } 182 183 184 std::string SubtargetFeatures::getString() const { 185 return Join(Features); 186 } 187 188 /// SetImpliedBits - For each feature that is (transitively) implied by this 189 /// feature, set it. 190 /// 191 static 192 void SetImpliedBits(uint64_t &Bits, const SubtargetFeatureKV *FeatureEntry, 193 const SubtargetFeatureKV *FeatureTable, 194 size_t FeatureTableSize) { 195 for (size_t i = 0; i < FeatureTableSize; ++i) { 196 const SubtargetFeatureKV &FE = FeatureTable[i]; 197 198 if (FeatureEntry->Value == FE.Value) continue; 199 200 if (FeatureEntry->Implies & FE.Value) { 201 Bits |= FE.Value; 202 SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 203 } 204 } 205 } 206 207 /// ClearImpliedBits - For each feature that (transitively) implies this 208 /// feature, clear it. 209 /// 210 static 211 void ClearImpliedBits(uint64_t &Bits, const SubtargetFeatureKV *FeatureEntry, 212 const SubtargetFeatureKV *FeatureTable, 213 size_t FeatureTableSize) { 214 for (size_t i = 0; i < FeatureTableSize; ++i) { 215 const SubtargetFeatureKV &FE = FeatureTable[i]; 216 217 if (FeatureEntry->Value == FE.Value) continue; 218 219 if (FE.Implies & FeatureEntry->Value) { 220 Bits &= ~FE.Value; 221 ClearImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 222 } 223 } 224 } 225 226 /// ToggleFeature - Toggle a feature and returns the newly updated feature 227 /// bits. 228 uint64_t 229 SubtargetFeatures::ToggleFeature(uint64_t Bits, const StringRef Feature, 230 const SubtargetFeatureKV *FeatureTable, 231 size_t FeatureTableSize) { 232 // Find feature in table. 233 const SubtargetFeatureKV *FeatureEntry = 234 Find(StripFlag(Feature), FeatureTable, FeatureTableSize); 235 // If there is a match 236 if (FeatureEntry) { 237 if ((Bits & FeatureEntry->Value) == FeatureEntry->Value) { 238 Bits &= ~FeatureEntry->Value; 239 240 // For each feature that implies this, clear it. 241 ClearImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 242 } else { 243 Bits |= FeatureEntry->Value; 244 245 // For each feature that this implies, set it. 246 SetImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 247 } 248 } else { 249 errs() << "'" << Feature 250 << "' is not a recognized feature for this target" 251 << " (ignoring feature)\n"; 252 } 253 254 return Bits; 255 } 256 257 258 /// getFeatureBits - Get feature bits a CPU. 259 /// 260 uint64_t SubtargetFeatures::getFeatureBits(const StringRef CPU, 261 const SubtargetFeatureKV *CPUTable, 262 size_t CPUTableSize, 263 const SubtargetFeatureKV *FeatureTable, 264 size_t FeatureTableSize) { 265 if (!FeatureTableSize || !CPUTableSize) 266 return 0; 267 268 #ifndef NDEBUG 269 for (size_t i = 1; i < CPUTableSize; i++) { 270 assert(strcmp(CPUTable[i - 1].Key, CPUTable[i].Key) < 0 && 271 "CPU table is not sorted"); 272 } 273 for (size_t i = 1; i < FeatureTableSize; i++) { 274 assert(strcmp(FeatureTable[i - 1].Key, FeatureTable[i].Key) < 0 && 275 "CPU features table is not sorted"); 276 } 277 #endif 278 uint64_t Bits = 0; // Resulting bits 279 280 // Check if help is needed 281 if (CPU == "help") 282 Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize); 283 284 // Find CPU entry if CPU name is specified. 285 if (!CPU.empty()) { 286 const SubtargetFeatureKV *CPUEntry = Find(CPU, CPUTable, CPUTableSize); 287 // If there is a match 288 if (CPUEntry) { 289 // Set base feature bits 290 Bits = CPUEntry->Value; 291 292 // Set the feature implied by this CPU feature, if any. 293 for (size_t i = 0; i < FeatureTableSize; ++i) { 294 const SubtargetFeatureKV &FE = FeatureTable[i]; 295 if (CPUEntry->Value & FE.Value) 296 SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 297 } 298 } else { 299 errs() << "'" << CPU 300 << "' is not a recognized processor for this target" 301 << " (ignoring processor)\n"; 302 } 303 } 304 305 // Iterate through each feature 306 for (size_t i = 0, E = Features.size(); i < E; i++) { 307 const StringRef Feature = Features[i]; 308 309 // Check for help 310 if (Feature == "+help") 311 Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize); 312 313 // Find feature in table. 314 const SubtargetFeatureKV *FeatureEntry = 315 Find(StripFlag(Feature), FeatureTable, FeatureTableSize); 316 // If there is a match 317 if (FeatureEntry) { 318 // Enable/disable feature in bits 319 if (isEnabled(Feature)) { 320 Bits |= FeatureEntry->Value; 321 322 // For each feature that this implies, set it. 323 SetImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 324 } else { 325 Bits &= ~FeatureEntry->Value; 326 327 // For each feature that implies this, clear it. 328 ClearImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 329 } 330 } else { 331 errs() << "'" << Feature 332 << "' is not a recognized feature for this target" 333 << " (ignoring feature)\n"; 334 } 335 } 336 337 return Bits; 338 } 339 340 /// print - Print feature string. 341 /// 342 void SubtargetFeatures::print(raw_ostream &OS) const { 343 for (size_t i = 0, e = Features.size(); i != e; ++i) 344 OS << Features[i] << " "; 345 OS << "\n"; 346 } 347 348 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 349 /// dump - Dump feature info. 350 /// 351 void SubtargetFeatures::dump() const { 352 print(dbgs()); 353 } 354 #endif 355 356 /// getDefaultSubtargetFeatures - Return a string listing the features 357 /// associated with the target triple. 358 /// 359 /// FIXME: This is an inelegant way of specifying the features of a 360 /// subtarget. It would be better if we could encode this information 361 /// into the IR. See <rdar://5972456>. 362 /// 363 void SubtargetFeatures::getDefaultSubtargetFeatures(const Triple& Triple) { 364 if (Triple.getVendor() == Triple::Apple) { 365 if (Triple.getArch() == Triple::ppc) { 366 // powerpc-apple-* 367 AddFeature("altivec"); 368 } else if (Triple.getArch() == Triple::ppc64) { 369 // powerpc64-apple-* 370 AddFeature("64bit"); 371 AddFeature("altivec"); 372 } 373 } 374 } 375
