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 template<typename T> const T *Find(const StringRef S, const T *A, size_t L) { 123 // Make the lower bound element we're looking for 124 T KV; 125 KV.Key = S.data(); 126 // Determine the end of the array 127 const T *Hi = A + L; 128 // Binary search the array 129 const T *F = std::lower_bound(A, Hi, KV); 130 // If not found then return NULL 131 if (F == Hi || StringRef(F->Key) != S) return NULL; 132 // Return the found array item 133 return F; 134 } 135 136 /// getLongestEntryLength - Return the length of the longest entry in the table. 137 /// 138 static size_t getLongestEntryLength(const SubtargetFeatureKV *Table, 139 size_t Size) { 140 size_t MaxLen = 0; 141 for (size_t i = 0; i < Size; i++) 142 MaxLen = std::max(MaxLen, std::strlen(Table[i].Key)); 143 return MaxLen; 144 } 145 146 /// Display help for feature choices. 147 /// 148 static void Help(const SubtargetFeatureKV *CPUTable, size_t CPUTableSize, 149 const SubtargetFeatureKV *FeatTable, size_t FeatTableSize) { 150 // Determine the length of the longest CPU and Feature entries. 151 unsigned MaxCPULen = getLongestEntryLength(CPUTable, CPUTableSize); 152 unsigned MaxFeatLen = getLongestEntryLength(FeatTable, FeatTableSize); 153 154 // Print the CPU table. 155 errs() << "Available CPUs for this target:\n\n"; 156 for (size_t i = 0; i != CPUTableSize; i++) 157 errs() << format(" %-*s - %s.\n", 158 MaxCPULen, CPUTable[i].Key, CPUTable[i].Desc); 159 errs() << '\n'; 160 161 // Print the Feature table. 162 errs() << "Available features for this target:\n\n"; 163 for (size_t i = 0; i != FeatTableSize; i++) 164 errs() << format(" %-*s - %s.\n", 165 MaxFeatLen, FeatTable[i].Key, FeatTable[i].Desc); 166 errs() << '\n'; 167 168 errs() << "Use +feature to enable a feature, or -feature to disable it.\n" 169 "For example, llc -mcpu=mycpu -mattr=+feature1,-feature2\n"; 170 std::exit(1); 171 } 172 173 //===----------------------------------------------------------------------===// 174 // SubtargetFeatures Implementation 175 //===----------------------------------------------------------------------===// 176 177 SubtargetFeatures::SubtargetFeatures(const StringRef Initial) { 178 // Break up string into separate features 179 Split(Features, Initial); 180 } 181 182 183 std::string SubtargetFeatures::getString() const { 184 return Join(Features); 185 } 186 187 /// SetImpliedBits - For each feature that is (transitively) implied by this 188 /// feature, set it. 189 /// 190 static 191 void SetImpliedBits(uint64_t &Bits, const SubtargetFeatureKV *FeatureEntry, 192 const SubtargetFeatureKV *FeatureTable, 193 size_t FeatureTableSize) { 194 for (size_t i = 0; i < FeatureTableSize; ++i) { 195 const SubtargetFeatureKV &FE = FeatureTable[i]; 196 197 if (FeatureEntry->Value == FE.Value) continue; 198 199 if (FeatureEntry->Implies & FE.Value) { 200 Bits |= FE.Value; 201 SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 202 } 203 } 204 } 205 206 /// ClearImpliedBits - For each feature that (transitively) implies this 207 /// feature, clear it. 208 /// 209 static 210 void ClearImpliedBits(uint64_t &Bits, const SubtargetFeatureKV *FeatureEntry, 211 const SubtargetFeatureKV *FeatureTable, 212 size_t FeatureTableSize) { 213 for (size_t i = 0; i < FeatureTableSize; ++i) { 214 const SubtargetFeatureKV &FE = FeatureTable[i]; 215 216 if (FeatureEntry->Value == FE.Value) continue; 217 218 if (FE.Implies & FeatureEntry->Value) { 219 Bits &= ~FE.Value; 220 ClearImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 221 } 222 } 223 } 224 225 /// ToggleFeature - Toggle a feature and returns the newly updated feature 226 /// bits. 227 uint64_t 228 SubtargetFeatures::ToggleFeature(uint64_t Bits, const StringRef Feature, 229 const SubtargetFeatureKV *FeatureTable, 230 size_t FeatureTableSize) { 231 // Find feature in table. 232 const SubtargetFeatureKV *FeatureEntry = 233 Find(StripFlag(Feature), FeatureTable, FeatureTableSize); 234 // If there is a match 235 if (FeatureEntry) { 236 if ((Bits & FeatureEntry->Value) == FeatureEntry->Value) { 237 Bits &= ~FeatureEntry->Value; 238 239 // For each feature that implies this, clear it. 240 ClearImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 241 } else { 242 Bits |= FeatureEntry->Value; 243 244 // For each feature that this implies, set it. 245 SetImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 246 } 247 } else { 248 errs() << "'" << Feature 249 << "' is not a recognized feature for this target" 250 << " (ignoring feature)\n"; 251 } 252 253 return Bits; 254 } 255 256 257 /// getFeatureBits - Get feature bits a CPU. 258 /// 259 uint64_t SubtargetFeatures::getFeatureBits(const StringRef CPU, 260 const SubtargetFeatureKV *CPUTable, 261 size_t CPUTableSize, 262 const SubtargetFeatureKV *FeatureTable, 263 size_t FeatureTableSize) { 264 if (!FeatureTableSize || !CPUTableSize) 265 return 0; 266 267 #ifndef NDEBUG 268 for (size_t i = 1; i < CPUTableSize; i++) { 269 assert(strcmp(CPUTable[i - 1].Key, CPUTable[i].Key) < 0 && 270 "CPU table is not sorted"); 271 } 272 for (size_t i = 1; i < FeatureTableSize; i++) { 273 assert(strcmp(FeatureTable[i - 1].Key, FeatureTable[i].Key) < 0 && 274 "CPU features table is not sorted"); 275 } 276 #endif 277 uint64_t Bits = 0; // Resulting bits 278 279 // Check if help is needed 280 if (CPU == "help") 281 Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize); 282 283 // Find CPU entry if CPU name is specified. 284 if (!CPU.empty()) { 285 const SubtargetFeatureKV *CPUEntry = Find(CPU, CPUTable, CPUTableSize); 286 // If there is a match 287 if (CPUEntry) { 288 // Set base feature bits 289 Bits = CPUEntry->Value; 290 291 // Set the feature implied by this CPU feature, if any. 292 for (size_t i = 0; i < FeatureTableSize; ++i) { 293 const SubtargetFeatureKV &FE = FeatureTable[i]; 294 if (CPUEntry->Value & FE.Value) 295 SetImpliedBits(Bits, &FE, FeatureTable, FeatureTableSize); 296 } 297 } else { 298 errs() << "'" << CPU 299 << "' is not a recognized processor for this target" 300 << " (ignoring processor)\n"; 301 } 302 } 303 304 // Iterate through each feature 305 for (size_t i = 0, E = Features.size(); i < E; i++) { 306 const StringRef Feature = Features[i]; 307 308 // Check for help 309 if (Feature == "+help") 310 Help(CPUTable, CPUTableSize, FeatureTable, FeatureTableSize); 311 312 // Find feature in table. 313 const SubtargetFeatureKV *FeatureEntry = 314 Find(StripFlag(Feature), FeatureTable, FeatureTableSize); 315 // If there is a match 316 if (FeatureEntry) { 317 // Enable/disable feature in bits 318 if (isEnabled(Feature)) { 319 Bits |= FeatureEntry->Value; 320 321 // For each feature that this implies, set it. 322 SetImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 323 } else { 324 Bits &= ~FeatureEntry->Value; 325 326 // For each feature that implies this, clear it. 327 ClearImpliedBits(Bits, FeatureEntry, FeatureTable, FeatureTableSize); 328 } 329 } else { 330 errs() << "'" << Feature 331 << "' is not a recognized feature for this target" 332 << " (ignoring feature)\n"; 333 } 334 } 335 336 return Bits; 337 } 338 339 /// Get scheduling itinerary of a CPU. 340 const void *SubtargetFeatures::getItinerary(const StringRef CPU, 341 const SubtargetInfoKV *Table, 342 size_t TableSize) { 343 assert(Table && "missing table"); 344 #ifndef NDEBUG 345 for (size_t i = 1; i < TableSize; i++) { 346 assert(strcmp(Table[i - 1].Key, Table[i].Key) < 0 && "Table is not sorted"); 347 } 348 #endif 349 350 // Find entry 351 const SubtargetInfoKV *Entry = Find(CPU, Table, TableSize); 352 353 if (Entry) { 354 return Entry->Value; 355 } else { 356 errs() << "'" << CPU 357 << "' is not a recognized processor for this target" 358 << " (ignoring processor)\n"; 359 return NULL; 360 } 361 } 362 363 /// print - Print feature string. 364 /// 365 void SubtargetFeatures::print(raw_ostream &OS) const { 366 for (size_t i = 0, e = Features.size(); i != e; ++i) 367 OS << Features[i] << " "; 368 OS << "\n"; 369 } 370 371 #ifndef NDEBUG 372 /// dump - Dump feature info. 373 /// 374 void SubtargetFeatures::dump() const { 375 print(dbgs()); 376 } 377 #endif 378 379 /// getDefaultSubtargetFeatures - Return a string listing the features 380 /// associated with the target triple. 381 /// 382 /// FIXME: This is an inelegant way of specifying the features of a 383 /// subtarget. It would be better if we could encode this information 384 /// into the IR. See <rdar://5972456>. 385 /// 386 void SubtargetFeatures::getDefaultSubtargetFeatures(const Triple& Triple) { 387 if (Triple.getVendor() == Triple::Apple) { 388 if (Triple.getArch() == Triple::ppc) { 389 // powerpc-apple-* 390 AddFeature("altivec"); 391 } else if (Triple.getArch() == Triple::ppc64) { 392 // powerpc64-apple-* 393 AddFeature("64bit"); 394 AddFeature("altivec"); 395 } 396 } 397 } 398