lib/Basic/TargetInfo.cpp

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