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> 22using namespace llvm; 23 24//===----------------------------------------------------------------------===// 25// Static Helper Functions 26//===----------------------------------------------------------------------===// 27 28/// hasFlag - Determine if a feature has a flag; '+' or '-' 29/// 30static 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/// 40static 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/// 46static 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/// 56static 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/// 68static 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/// 92static 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. 112void 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. 122static 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/// 139static 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/// 149static 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 178SubtargetFeatures::SubtargetFeatures(const StringRef Initial) { 179 // Break up string into separate features 180 Split(Features, Initial); 181} 182 183 184std::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/// 191static 192void 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/// 210static 211void 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. 228uint64_t 229SubtargetFeatures::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/// 260uint64_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/// 342void 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/// 351void 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/// 363void 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