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/TargetInfo.h"
  15 #include "clang/Basic/LangOptions.h"
  16 #include "llvm/ADT/APFloat.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include <cstdlib>
  19 using namespace clang;
  20
  21 // TargetInfo Constructor.
  22 TargetInfo::TargetInfo(const std::string &T) : Triple(T) {
  23   // Set defaults.  Defaults are set for a 32-bit RISC platform,
  24   // like PPC or SPARC.
  25   // These should be overridden by concrete targets as needed.
  26   TLSSupported = true;
  27   PointerWidth = PointerAlign = 32;
  28   IntWidth = IntAlign = 32;
  29   LongWidth = LongAlign = 32;
  30   LongLongWidth = LongLongAlign = 64;
  31   FloatWidth = 32;
  32   FloatAlign = 32;
  33   DoubleWidth = 64;
  34   DoubleAlign = 64;
  35   LongDoubleWidth = 64;
  36   LongDoubleAlign = 64;
  37   SizeType = UnsignedLong;
  38   PtrDiffType = SignedLong;
  39   IntMaxType = SignedLongLong;
  40   UIntMaxType = UnsignedLongLong;
  41   IntPtrType = SignedLong;
  42   WCharType = SignedInt;
  43   WIntType = SignedInt;
  44   Char16Type = UnsignedShort;
  45   Char32Type = UnsignedInt;
  46   Int64Type = SignedLongLong;
  47   SigAtomicType = SignedInt;
  48   FloatFormat = &llvm::APFloat::IEEEsingle;
  49   DoubleFormat = &llvm::APFloat::IEEEdouble;
  50   LongDoubleFormat = &llvm::APFloat::IEEEdouble;
  51   DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
  52                       "i64:64:64-f32:32:32-f64:64:64-n32";
  53   UserLabelPrefix = "_";
  54 }
  55
  56 // Out of line virtual dtor for TargetInfo.
  57 TargetInfo::~TargetInfo() {}
  58
  59 /// getTypeName - Return the user string for the specified integer type enum.
  60 /// For example, SignedShort -> "short".
  61 const char *TargetInfo::getTypeName(IntType T) {
  62   switch (T) {
  63   default: assert(0 && "not an integer!");
  64   case SignedShort:      return "short";
  65   case UnsignedShort:    return "unsigned short";
  66   case SignedInt:        return "int";
  67   case UnsignedInt:      return "unsigned int";
  68   case SignedLong:       return "long int";
  69   case UnsignedLong:     return "long unsigned int";
  70   case SignedLongLong:   return "long long int";
  71   case UnsignedLongLong: return "long long unsigned int";
  72   }
  73 }
  74
  75 /// getTypeConstantSuffix - Return the constant suffix for the specified
  76 /// integer type enum. For example, SignedLong -> "L".
  77 const char *TargetInfo::getTypeConstantSuffix(IntType T) {
  78   switch (T) {
  79   default: assert(0 && "not an integer!");
  80   case SignedShort:
  81   case SignedInt:        return "";
  82   case SignedLong:       return "L";
  83   case SignedLongLong:   return "LL";
  84   case UnsignedShort:
  85   case UnsignedInt:      return "U";
  86   case UnsignedLong:     return "UL";
  87   case UnsignedLongLong: return "ULL";
  88   }
  89 }
  90
  91 /// getTypeWidth - Return the width (in bits) of the specified integer type
  92 /// enum. For example, SignedInt -> getIntWidth().
  93 unsigned TargetInfo::getTypeWidth(IntType T) const {
  94   switch (T) {
  95   default: assert(0 && "not an integer!");
  96   case SignedShort:
  97   case UnsignedShort:    return getShortWidth();
  98   case SignedInt:
  99   case UnsignedInt:      return getIntWidth();
 100   case SignedLong:
 101   case UnsignedLong:     return getLongWidth();
 102   case SignedLongLong:
 103   case UnsignedLongLong: return getLongLongWidth();
 104   };
 105 }
 106
 107 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
 108 /// enum. For example, SignedInt -> getIntAlign().
 109 unsigned TargetInfo::getTypeAlign(IntType T) const {
 110   switch (T) {
 111   default: assert(0 && "not an integer!");
 112   case SignedShort:
 113   case UnsignedShort:    return getShortAlign();
 114   case SignedInt:
 115   case UnsignedInt:      return getIntAlign();
 116   case SignedLong:
 117   case UnsignedLong:     return getLongAlign();
 118   case SignedLongLong:
 119   case UnsignedLongLong: return getLongLongAlign();
 120   };
 121 }
 122
 123 /// isTypeSigned - Return whether an integer types is signed. Returns true if
 124 /// the type is signed; false otherwise.
 125 bool TargetInfo::isTypeSigned(IntType T) const {
 126   switch (T) {
 127   default: assert(0 && "not an integer!");
 128   case SignedShort:
 129   case SignedInt:
 130   case SignedLong:
 131   case SignedLongLong:
 132     return true;
 133   case UnsignedShort:
 134   case UnsignedInt:
 135   case UnsignedLong:
 136   case UnsignedLongLong:
 137     return false;
 138   };
 139 }
 140
 141 /// setForcedLangOptions - Set forced language options.
 142 /// Apply changes to the target information with respect to certain
 143 /// language options which change the target configuration.
 144 void TargetInfo::setForcedLangOptions(LangOptions &Opts) {
 145   if (Opts.ShortWChar) {
 146     WCharType = UnsignedShort;
 147   }
 148 }
 149
 150 //===----------------------------------------------------------------------===//
 151
 152
 153 static llvm::StringRef removeGCCRegisterPrefix(llvm::StringRef Name) {
 154   if (Name[0] == '%' || Name[0] == '#')
 155     Name = Name.substr(1);
 156
 157   return Name;
 158 }
 159
 160 /// isValidGCCRegisterName - Returns whether the passed in string
 161 /// is a valid register name according to GCC. This is used by Sema for
 162 /// inline asm statements.
 163 bool TargetInfo::isValidGCCRegisterName(llvm::StringRef Name) const {
 164   if (Name.empty())
 165     return false;
 166
 167   const char * const *Names;
 168   unsigned NumNames;
 169
 170   // Get rid of any register prefix.
 171   Name = removeGCCRegisterPrefix(Name);
 172
 173   if (Name == "memory" || Name == "cc")
 174     return true;
 175
 176   getGCCRegNames(Names, NumNames);
 177
 178   // If we have a number it maps to an entry in the register name array.
 179   if (isdigit(Name[0])) {
 180     int n;
 181     if (!Name.getAsInteger(0, n))
 182       return n >= 0 && (unsigned)n < NumNames;
 183   }
 184
 185   // Check register names.
 186   for (unsigned i = 0; i < NumNames; i++) {
 187     if (Name == Names[i])
 188       return true;
 189   }
 190
 191   // Now check aliases.
 192   const GCCRegAlias *Aliases;
 193   unsigned NumAliases;
 194
 195   getGCCRegAliases(Aliases, NumAliases);
 196   for (unsigned i = 0; i < NumAliases; i++) {
 197     for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
 198       if (!Aliases[i].Aliases[j])
 199         break;
 200       if (Aliases[i].Aliases[j] == Name)
 201         return true;
 202     }
 203   }
 204
 205   return false;
 206 }
 207
 208 llvm::StringRef
 209 TargetInfo::getNormalizedGCCRegisterName(llvm::StringRef Name) const {
 210   assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
 211
 212   // Get rid of any register prefix.
 213   Name = removeGCCRegisterPrefix(Name);
 214
 215   const char * const *Names;
 216   unsigned NumNames;
 217
 218   getGCCRegNames(Names, NumNames);
 219
 220   // First, check if we have a number.
 221   if (isdigit(Name[0])) {
 222     int n;
 223     if (!Name.getAsInteger(0, n)) {
 224       assert(n >= 0 && (unsigned)n < NumNames &&
 225              "Out of bounds register number!");
 226       return Names[n];
 227     }
 228   }
 229
 230   // Now check aliases.
 231   const GCCRegAlias *Aliases;
 232   unsigned NumAliases;
 233
 234   getGCCRegAliases(Aliases, NumAliases);
 235   for (unsigned i = 0; i < NumAliases; i++) {
 236     for (unsigned j = 0 ; j < llvm::array_lengthof(Aliases[i].Aliases); j++) {
 237       if (!Aliases[i].Aliases[j])
 238         break;
 239       if (Aliases[i].Aliases[j] == Name)
 240         return Aliases[i].Register;
 241     }
 242   }
 243
 244   return Name;
 245 }
 246
 247 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
 248   const char *Name = Info.getConstraintStr().c_str();
 249   // An output constraint must start with '=' or '+'
 250   if (*Name != '=' && *Name != '+')
 251     return false;
 252
 253   if (*Name == '+')
 254     Info.setIsReadWrite();
 255
 256   Name++;
 257   while (*Name) {
 258     switch (*Name) {
 259     default:
 260       if (!validateAsmConstraint(Name, Info)) {
 261         // FIXME: We temporarily return false
 262         // so we can add more constraints as we hit it.
 263         // Eventually, an unknown constraint should just be treated as 'g'.
 264         return false;
 265       }
 266     case '&': // early clobber.
 267       break;
 268     case '%': // commutative.
 269       // FIXME: Check that there is a another register after this one.
 270       break;
 271     case 'r': // general register.
 272       Info.setAllowsRegister();
 273       break;
 274     case 'm': // memory operand.
 275       Info.setAllowsMemory();
 276       break;
 277     case 'g': // general register, memory operand or immediate integer.
 278     case 'X': // any operand.
 279       Info.setAllowsRegister();
 280       Info.setAllowsMemory();
 281       break;
 282     }
 283
 284     Name++;
 285   }
 286
 287   return true;
 288 }
 289
 290 bool TargetInfo::resolveSymbolicName(const char *&Name,
 291                                      ConstraintInfo *OutputConstraints,
 292                                      unsigned NumOutputs,
 293                                      unsigned &Index) const {
 294   assert(*Name == '[' && "Symbolic name did not start with '['");
 295   Name++;
 296   const char *Start = Name;
 297   while (*Name && *Name != ']')
 298     Name++;
 299
 300   if (!*Name) {
 301     // Missing ']'
 302     return false;
 303   }
 304
 305   std::string SymbolicName(Start, Name - Start);
 306
 307   for (Index = 0; Index != NumOutputs; ++Index)
 308     if (SymbolicName == OutputConstraints[Index].getName())
 309       return true;
 310
 311   return false;
 312 }
 313
 314 bool TargetInfo::validateInputConstraint(ConstraintInfo *OutputConstraints,
 315                                          unsigned NumOutputs,
 316                                          ConstraintInfo &Info) const {
 317   const char *Name = Info.ConstraintStr.c_str();
 318
 319   while (*Name) {
 320     switch (*Name) {
 321     default:
 322       // Check if we have a matching constraint
 323       if (*Name >= '0' && *Name <= '9') {
 324         unsigned i = *Name - '0';
 325
 326         // Check if matching constraint is out of bounds.
 327         if (i >= NumOutputs)
 328           return false;
 329
 330         // The constraint should have the same info as the respective
 331         // output constraint.
 332         Info.setTiedOperand(i, OutputConstraints[i]);
 333       } else if (!validateAsmConstraint(Name, Info)) {
 334         // FIXME: This error return is in place temporarily so we can
 335         // add more constraints as we hit it.  Eventually, an unknown
 336         // constraint should just be treated as 'g'.
 337         return false;
 338       }
 339       break;
 340     case '[': {
 341       unsigned Index = 0;
 342       if (!resolveSymbolicName(Name, OutputConstraints, NumOutputs, Index))
 343         return false;
 344
 345       break;
 346     }
 347     case '%': // commutative
 348       // FIXME: Fail if % is used with the last operand.
 349       break;
 350     case 'i': // immediate integer.
 351     case 'n': // immediate integer with a known value.
 352       break;
 353     case 'I':  // Various constant constraints with target-specific meanings.
 354     case 'J':
 355     case 'K':
 356     case 'L':
 357     case 'M':
 358     case 'N':
 359     case 'O':
 360     case 'P':
 361       break;
 362     case 'r': // general register.
 363       Info.setAllowsRegister();
 364       break;
 365     case 'm': // memory operand.
 366     case 'o': // offsettable memory operand
 367     case 'V': // non-offsettable memory operand
 368       Info.setAllowsMemory();
 369       break;
 370     case 'g': // general register, memory operand or immediate integer.
 371     case 'X': // any operand.
 372       Info.setAllowsRegister();
 373       Info.setAllowsMemory();
 374       break;
 375     }
 376
 377     Name++;
 378   }
 379
 380   return true;
 381 }