1 //===--- TargetInfo.cpp - Information about Target machine ----------------===// 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 TargetInfo and TargetInfoImpl interfaces. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Basic/AddressSpaces.h" 15 #include "clang/Basic/TargetInfo.h" 16 #include "clang/Basic/LangOptions.h" 17 #include "llvm/ADT/APFloat.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include <cctype> 21 #include <cstdlib> 22 using namespace clang; 23 24 static const LangAS::Map DefaultAddrSpaceMap = { 0 }; 25 26 // TargetInfo Constructor. 27 TargetInfo::TargetInfo(const std::string &T) : Triple(T) { 28 // Set defaults. Defaults are set for a 32-bit RISC platform, like PPC or 29 // SPARC. These should be overridden by concrete targets as needed. 30 TLSSupported = true; 31 NoAsmVariants = false; 32 PointerWidth = PointerAlign = 32; 33 BoolWidth = BoolAlign = 8; 34 IntWidth = IntAlign = 32; 35 LongWidth = LongAlign = 32; 36 LongLongWidth = LongLongAlign = 64; 37 HalfWidth = 16; 38 HalfAlign = 16; 39 FloatWidth = 32; 40 FloatAlign = 32; 41 DoubleWidth = 64; 42 DoubleAlign = 64; 43 LongDoubleWidth = 64; 44 LongDoubleAlign = 64; 45 LargeArrayMinWidth = 0; 46 LargeArrayAlign = 0; 47 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0; 48 SizeType = UnsignedLong; 49 PtrDiffType = SignedLong; 50 IntMaxType = SignedLongLong; 51 UIntMaxType = UnsignedLongLong; 52 IntPtrType = SignedLong; 53 WCharType = SignedInt; 54 WIntType = SignedInt; 55 Char16Type = UnsignedShort; 56 Char32Type = UnsignedInt; 57 Int64Type = SignedLongLong; 58 SigAtomicType = SignedInt; 59 UseBitFieldTypeAlignment = true; 60 UseZeroLengthBitfieldAlignment = false; 61 ZeroLengthBitfieldBoundary = 0; 62 HalfFormat = &llvm::APFloat::IEEEhalf; 63 FloatFormat = &llvm::APFloat::IEEEsingle; 64 DoubleFormat = &llvm::APFloat::IEEEdouble; 65 LongDoubleFormat = &llvm::APFloat::IEEEdouble; 66 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" 67 "i64:64:64-f32:32:32-f64:64:64-n32"; 68 UserLabelPrefix = "_"; 69 MCountName = "mcount"; 70 RegParmMax = 0; 71 SSERegParmMax = 0; 72 HasAlignMac68kSupport = false; 73 74 // Default to no types using fpret. 75 RealTypeUsesObjCFPRet = 0; 76 77 // Default to using the Itanium ABI. 78 CXXABI = CXXABI_Itanium; 79 80 // Default to an empty address space map. 81 AddrSpaceMap = &DefaultAddrSpaceMap; 82 83 // Default to an unknown platform name. 84 PlatformName = "unknown"; 85 PlatformMinVersion = VersionTuple(); 86 } 87 88 // Out of line virtual dtor for TargetInfo. 89 TargetInfo::~TargetInfo() {} 90 91 /// getTypeName - Return the user string for the specified integer type enum. 92 /// For example, SignedShort -> "short". 93 const char *TargetInfo::getTypeName(IntType T) { 94 switch (T) { 95 default: llvm_unreachable("not an integer!"); 96 case SignedShort: return "short"; 97 case UnsignedShort: return "unsigned short"; 98 case SignedInt: return "int"; 99 case UnsignedInt: return "unsigned int"; 100 case SignedLong: return "long int"; 101 case UnsignedLong: return "long unsigned int"; 102 case SignedLongLong: return "long long int"; 103 case UnsignedLongLong: return "long long unsigned int"; 104 } 105 } 106 107 /// getTypeConstantSuffix - Return the constant suffix for the specified 108 /// integer type enum. For example, SignedLong -> "L". 109 const char *TargetInfo::getTypeConstantSuffix(IntType T) { 110 switch (T) { 111 default: llvm_unreachable("not an integer!"); 112 case SignedShort: 113 case SignedInt: return ""; 114 case SignedLong: return "L"; 115 case SignedLongLong: return "LL"; 116 case UnsignedShort: 117 case UnsignedInt: return "U"; 118 case UnsignedLong: return "UL"; 119 case UnsignedLongLong: return "ULL"; 120 } 121 } 122 123 /// getTypeWidth - Return the width (in bits) of the specified integer type 124 /// enum. For example, SignedInt -> getIntWidth(). 125 unsigned TargetInfo::getTypeWidth(IntType T) const { 126 switch (T) { 127 default: llvm_unreachable("not an integer!"); 128 case SignedShort: 129 case UnsignedShort: return getShortWidth(); 130 case SignedInt: 131 case UnsignedInt: return getIntWidth(); 132 case SignedLong: 133 case UnsignedLong: return getLongWidth(); 134 case SignedLongLong: 135 case UnsignedLongLong: return getLongLongWidth(); 136 }; 137 } 138 139 /// getTypeAlign - Return the alignment (in bits) of the specified integer type 140 /// enum. For example, SignedInt -> getIntAlign(). 141 unsigned TargetInfo::getTypeAlign(IntType T) const { 142 switch (T) { 143 default: llvm_unreachable("not an integer!"); 144 case SignedShort: 145 case UnsignedShort: return getShortAlign(); 146 case SignedInt: 147 case UnsignedInt: return getIntAlign(); 148 case SignedLong: 149 case UnsignedLong: return getLongAlign(); 150 case SignedLongLong: 151 case UnsignedLongLong: return getLongLongAlign(); 152 }; 153 } 154 155 /// isTypeSigned - Return whether an integer types is signed. Returns true if 156 /// the type is signed; false otherwise. 157 bool TargetInfo::isTypeSigned(IntType T) { 158 switch (T) { 159 default: llvm_unreachable("not an integer!"); 160 case SignedShort: 161 case SignedInt: 162 case SignedLong: 163 case SignedLongLong: 164 return true; 165 case UnsignedShort: 166 case UnsignedInt: 167 case UnsignedLong: 168 case UnsignedLongLong: 169 return false; 170 }; 171 } 172 173 /// setForcedLangOptions - Set forced language options. 174 /// Apply changes to the target information with respect to certain 175 /// language options which change the target configuration. 176 void TargetInfo::setForcedLangOptions(LangOptions &Opts) { 177 if (Opts.NoBitFieldTypeAlign) 178 UseBitFieldTypeAlignment = false; 179 if (Opts.ShortWChar) 180 WCharType = UnsignedShort; 181 } 182 183 //===----------------------------------------------------------------------===// 184 185 186 static StringRef removeGCCRegisterPrefix(StringRef Name) { 187 if (Name[0] == '%' || Name[0] == '#') 188 Name = Name.substr(1); 189 190 return Name; 191 } 192 193 /// isValidClobber - Returns whether the passed in string is 194 /// a valid clobber in an inline asm statement. This is used by 195 /// Sema. 196 bool TargetInfo::isValidClobber(StringRef Name) const { 197 return (isValidGCCRegisterName(Name) || 198 Name == "memory" || Name == "cc"); 199 } 200 201 /// isValidGCCRegisterName - Returns whether the passed in string 202 /// is a valid register name according to GCC. This is used by Sema for 203 /// inline asm statements. 204 bool TargetInfo::isValidGCCRegisterName(StringRef Name) const { 205 if (Name.empty()) 206 return false; 207 208 const char * const *Names; 209 unsigned NumNames; 210 211 // Get rid of any register prefix. 212 Name = removeGCCRegisterPrefix(Name); 213 214 getGCCRegNames(Names, NumNames); 215 216 // If we have a number it maps to an entry in the register name array. 217 if (isdigit(Name[0])) { 218 int n; 219 if (!Name.getAsInteger(0, n)) 220 return n >= 0 && (unsigned)n < NumNames; 221 } 222 223 // Check register names. 224 for (unsigned i = 0; i < NumNames; i++) { 225 if (Name == Names[i]) 226 return true; 227 } 228 229 // Check any additional names that we have. 230 const AddlRegName *AddlNames; 231 unsigned NumAddlNames; 232 getGCCAddlRegNames(AddlNames, NumAddlNames); 233 for (unsigned i = 0; i < NumAddlNames; i++) 234 for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) { 235 if (!AddlNames[i].Names[j]) 236 break; 237 // Make sure the register that the additional name is for is within 238 // the bounds of the register names from above. 239 if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames) 240 return true; 241 } 242 243 // Now check aliases. 244 const GCCRegAlias *Aliases; 245 unsigned NumAliases; 246 247 getGCCRegAliases(Aliases, NumAliases); 248 for (unsigned i = 0; i < NumAliases; i++) { 249 for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) { 250 if (!Aliases[i].Aliases[j]) 251 break; 252 if (Aliases[i].Aliases[j] == Name) 253 return true; 254 } 255 } 256 257 return false; 258 } 259 260 StringRef 261 TargetInfo::getNormalizedGCCRegisterName(StringRef Name) const { 262 assert(isValidGCCRegisterName(Name) && "Invalid register passed in"); 263 264 // Get rid of any register prefix. 265 Name = removeGCCRegisterPrefix(Name); 266 267 const char * const *Names; 268 unsigned NumNames; 269 270 getGCCRegNames(Names, NumNames); 271 272 // First, check if we have a number. 273 if (isdigit(Name[0])) { 274 int n; 275 if (!Name.getAsInteger(0, n)) { 276 assert(n >= 0 && (unsigned)n < NumNames && 277 "Out of bounds register number!"); 278 return Names[n]; 279 } 280 } 281 282 // Check any additional names that we have. 283 const AddlRegName *AddlNames; 284 unsigned NumAddlNames; 285 getGCCAddlRegNames(AddlNames, NumAddlNames); 286 for (unsigned i = 0; i < NumAddlNames; i++) 287 for (unsigned j = 0; j < llvm::array_lengthof(AddlNames[i].Names); j++) { 288 if (!AddlNames[i].Names[j]) 289 break; 290 // Make sure the register that the additional name is for is within 291 // the bounds of the register names from above. 292 if (AddlNames[i].Names[j] == Name && AddlNames[i].RegNum < NumNames) 293 return Name; 294 } 295 296 // Now check aliases. 297 const GCCRegAlias *Aliases; 298 unsigned NumAliases; 299 300 getGCCRegAliases(Aliases, NumAliases); 301 for (unsigned i = 0; i < NumAliases; i++) { 302 for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) { 303 if (!Aliases[i].Aliases[j]) 304 break; 305 if (Aliases[i].Aliases[j] == Name) 306 return Aliases[i].Register; 307 } 308 } 309 310 return Name; 311 } 312 313 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const { 314 const char *Name = Info.getConstraintStr().c_str(); 315 // An output constraint must start with '=' or '+' 316 if (*Name != '=' && *Name != '+') 317 return false; 318 319 if (*Name == '+') 320 Info.setIsReadWrite(); 321 322 Name++; 323 while (*Name) { 324 switch (*Name) { 325 default: 326 if (!validateAsmConstraint(Name, Info)) { 327 // FIXME: We temporarily return false 328 // so we can add more constraints as we hit it. 329 // Eventually, an unknown constraint should just be treated as 'g'. 330 return false; 331 } 332 case '&': // early clobber. 333 break; 334 case '%': // commutative. 335 // FIXME: Check that there is a another register after this one. 336 break; 337 case 'r': // general register. 338 Info.setAllowsRegister(); 339 break; 340 case 'm': // memory operand. 341 case 'o': // offsetable memory operand. 342 case 'V': // non-offsetable memory operand. 343 case '<': // autodecrement memory operand. 344 case '>': // autoincrement memory operand. 345 Info.setAllowsMemory(); 346 break; 347 case 'g': // general register, memory operand or immediate integer. 348 case 'X': // any operand. 349 Info.setAllowsRegister(); 350 Info.setAllowsMemory(); 351 break; 352 case ',': // multiple alternative constraint. Pass it. 353 // Handle additional optional '=' or '+' modifiers. 354 if (Name[1] == '=' || Name[1] == '+') 355 Name++; 356 break; 357 case '?': // Disparage slightly code. 358 case '!': // Disparage severely. 359 break; // Pass them. 360 } 361 362 Name++; 363 } 364 365 return true; 366 } 367 368 bool TargetInfo::resolveSymbolicName(const char *&Name, 369 ConstraintInfo *OutputConstraints, 370 unsigned NumOutputs, 371 unsigned &Index) const { 372 assert(*Name == '[' && "Symbolic name did not start with '['"); 373 Name++; 374 const char *Start = Name; 375 while (*Name && *Name != ']') 376 Name++; 377 378 if (!*Name) { 379 // Missing ']' 380 return false; 381 } 382 383 std::string SymbolicName(Start, Name - Start); 384 385 for (Index = 0; Index != NumOutputs; ++Index) 386 if (SymbolicName == OutputConstraints[Index].getName()) 387 return true; 388 389 return false; 390 } 391 392 bool TargetInfo::validateInputConstraint(ConstraintInfo *OutputConstraints, 393 unsigned NumOutputs, 394 ConstraintInfo &Info) const { 395 const char *Name = Info.ConstraintStr.c_str(); 396 397 while (*Name) { 398 switch (*Name) { 399 default: 400 // Check if we have a matching constraint 401 if (*Name >= '0' && *Name <= '9') { 402 unsigned i = *Name - '0'; 403 404 // Check if matching constraint is out of bounds. 405 if (i >= NumOutputs) 406 return false; 407 408 // A number must refer to an output only operand. 409 if (OutputConstraints[i].isReadWrite()) 410 return false; 411 412 // If the constraint is already tied, it must be tied to the 413 // same operand referenced to by the number. 414 if (Info.hasTiedOperand() && Info.getTiedOperand() != i) 415 return false; 416 417 // The constraint should have the same info as the respective 418 // output constraint. 419 Info.setTiedOperand(i, OutputConstraints[i]); 420 } else if (!validateAsmConstraint(Name, Info)) { 421 // FIXME: This error return is in place temporarily so we can 422 // add more constraints as we hit it. Eventually, an unknown 423 // constraint should just be treated as 'g'. 424 return false; 425 } 426 break; 427 case '[': { 428 unsigned Index = 0; 429 if (!resolveSymbolicName(Name, OutputConstraints, NumOutputs, Index)) 430 return false; 431 432 // If the constraint is already tied, it must be tied to the 433 // same operand referenced to by the number. 434 if (Info.hasTiedOperand() && Info.getTiedOperand() != Index) 435 return false; 436 437 Info.setTiedOperand(Index, OutputConstraints[Index]); 438 break; 439 } 440 case '%': // commutative 441 // FIXME: Fail if % is used with the last operand. 442 break; 443 case 'i': // immediate integer. 444 case 'n': // immediate integer with a known value. 445 break; 446 case 'I': // Various constant constraints with target-specific meanings. 447 case 'J': 448 case 'K': 449 case 'L': 450 case 'M': 451 case 'N': 452 case 'O': 453 case 'P': 454 break; 455 case 'r': // general register. 456 Info.setAllowsRegister(); 457 break; 458 case 'm': // memory operand. 459 case 'o': // offsettable memory operand. 460 case 'V': // non-offsettable memory operand. 461 case '<': // autodecrement memory operand. 462 case '>': // autoincrement memory operand. 463 Info.setAllowsMemory(); 464 break; 465 case 'g': // general register, memory operand or immediate integer. 466 case 'X': // any operand. 467 Info.setAllowsRegister(); 468 Info.setAllowsMemory(); 469 break; 470 case 'E': // immediate floating point. 471 case 'F': // immediate floating point. 472 case 'p': // address operand. 473 break; 474 case ',': // multiple alternative constraint. Ignore comma. 475 break; 476 case '?': // Disparage slightly code. 477 case '!': // Disparage severely. 478 break; // Pass them. 479 } 480 481 Name++; 482 } 483 484 return true; 485 } 486