Home | History | Annotate | Download | only in Basic 
      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/AddressSpaces.h"
     16 #include "clang/Basic/CharInfo.h"
     17 #include "clang/Basic/LangOptions.h"
     18 #include "llvm/ADT/APFloat.h"
     19 #include "llvm/ADT/STLExtras.h"
     20 #include "llvm/Support/ErrorHandling.h"
     21 #include <cstdlib>
     22 using namespace clang;
     23 
     24 static const LangAS::Map DefaultAddrSpaceMap = { 0 };
     25 
     26 // TargetInfo Constructor.
     27 TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), 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   DefaultAlignForAttributeAligned = 128;
     40   MinGlobalAlign = 0;
     41   HalfWidth = 16;
     42   HalfAlign = 16;
     43   FloatWidth = 32;
     44   FloatAlign = 32;
     45   DoubleWidth = 64;
     46   DoubleAlign = 64;
     47   LongDoubleWidth = 64;
     48   LongDoubleAlign = 64;
     49   LargeArrayMinWidth = 0;
     50   LargeArrayAlign = 0;
     51   MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
     52   MaxVectorAlign = 0;
     53   MaxTLSAlign = 0;
     54   SimdDefaultAlign = 0;
     55   SizeType = UnsignedLong;
     56   PtrDiffType = SignedLong;
     57   IntMaxType = SignedLongLong;
     58   IntPtrType = SignedLong;
     59   WCharType = SignedInt;
     60   WIntType = SignedInt;
     61   Char16Type = UnsignedShort;
     62   Char32Type = UnsignedInt;
     63   Int64Type = SignedLongLong;
     64   SigAtomicType = SignedInt;
     65   ProcessIDType = SignedInt;
     66   UseSignedCharForObjCBool = true;
     67   UseBitFieldTypeAlignment = true;
     68   UseZeroLengthBitfieldAlignment = false;
     69   ZeroLengthBitfieldBoundary = 0;
     70   HalfFormat = &llvm::APFloat::IEEEhalf;
     71   FloatFormat = &llvm::APFloat::IEEEsingle;
     72   DoubleFormat = &llvm::APFloat::IEEEdouble;
     73   LongDoubleFormat = &llvm::APFloat::IEEEdouble;
     74   DataLayoutString = nullptr;
     75   UserLabelPrefix = "_";
     76   MCountName = "mcount";
     77   RegParmMax = 0;
     78   SSERegParmMax = 0;
     79   HasAlignMac68kSupport = false;
     80   HasBuiltinMSVaList = false;
     81 
     82   // Default to no types using fpret.
     83   RealTypeUsesObjCFPRet = 0;
     84 
     85   // Default to not using fp2ret for __Complex long double
     86   ComplexLongDoubleUsesFP2Ret = false;
     87 
     88   // Set the C++ ABI based on the triple.
     89   TheCXXABI.set(Triple.isKnownWindowsMSVCEnvironment()
     90                     ? TargetCXXABI::Microsoft
     91                     : TargetCXXABI::GenericItanium);
     92 
     93   // Default to an empty address space map.
     94   AddrSpaceMap = &DefaultAddrSpaceMap;
     95   UseAddrSpaceMapMangling = false;
     96 
     97   // Default to an unknown platform name.
     98   PlatformName = "unknown";
     99   PlatformMinVersion = VersionTuple();
    100 }
    101 
    102 // Out of line virtual dtor for TargetInfo.
    103 TargetInfo::~TargetInfo() {}
    104 
    105 /// getTypeName - Return the user string for the specified integer type enum.
    106 /// For example, SignedShort -> "short".
    107 const char *TargetInfo::getTypeName(IntType T) {
    108   switch (T) {
    109   default: llvm_unreachable("not an integer!");
    110   case SignedChar:       return "signed char";
    111   case UnsignedChar:     return "unsigned char";
    112   case SignedShort:      return "short";
    113   case UnsignedShort:    return "unsigned short";
    114   case SignedInt:        return "int";
    115   case UnsignedInt:      return "unsigned int";
    116   case SignedLong:       return "long int";
    117   case UnsignedLong:     return "long unsigned int";
    118   case SignedLongLong:   return "long long int";
    119   case UnsignedLongLong: return "long long unsigned int";
    120   }
    121 }
    122 
    123 /// getTypeConstantSuffix - Return the constant suffix for the specified
    124 /// integer type enum. For example, SignedLong -> "L".
    125 const char *TargetInfo::getTypeConstantSuffix(IntType T) const {
    126   switch (T) {
    127   default: llvm_unreachable("not an integer!");
    128   case SignedChar:
    129   case SignedShort:
    130   case SignedInt:        return "";
    131   case SignedLong:       return "L";
    132   case SignedLongLong:   return "LL";
    133   case UnsignedChar:
    134     if (getCharWidth() < getIntWidth())
    135       return "";
    136   case UnsignedShort:
    137     if (getShortWidth() < getIntWidth())
    138       return "";
    139   case UnsignedInt:      return "U";
    140   case UnsignedLong:     return "UL";
    141   case UnsignedLongLong: return "ULL";
    142   }
    143 }
    144 
    145 /// getTypeFormatModifier - Return the printf format modifier for the
    146 /// specified integer type enum. For example, SignedLong -> "l".
    147 
    148 const char *TargetInfo::getTypeFormatModifier(IntType T) {
    149   switch (T) {
    150   default: llvm_unreachable("not an integer!");
    151   case SignedChar:
    152   case UnsignedChar:     return "hh";
    153   case SignedShort:
    154   case UnsignedShort:    return "h";
    155   case SignedInt:
    156   case UnsignedInt:      return "";
    157   case SignedLong:
    158   case UnsignedLong:     return "l";
    159   case SignedLongLong:
    160   case UnsignedLongLong: return "ll";
    161   }
    162 }
    163 
    164 /// getTypeWidth - Return the width (in bits) of the specified integer type
    165 /// enum. For example, SignedInt -> getIntWidth().
    166 unsigned TargetInfo::getTypeWidth(IntType T) const {
    167   switch (T) {
    168   default: llvm_unreachable("not an integer!");
    169   case SignedChar:
    170   case UnsignedChar:     return getCharWidth();
    171   case SignedShort:
    172   case UnsignedShort:    return getShortWidth();
    173   case SignedInt:
    174   case UnsignedInt:      return getIntWidth();
    175   case SignedLong:
    176   case UnsignedLong:     return getLongWidth();
    177   case SignedLongLong:
    178   case UnsignedLongLong: return getLongLongWidth();
    179   };
    180 }
    181 
    182 TargetInfo::IntType TargetInfo::getIntTypeByWidth(
    183     unsigned BitWidth, bool IsSigned) const {
    184   if (getCharWidth() == BitWidth)
    185     return IsSigned ? SignedChar : UnsignedChar;
    186   if (getShortWidth() == BitWidth)
    187     return IsSigned ? SignedShort : UnsignedShort;
    188   if (getIntWidth() == BitWidth)
    189     return IsSigned ? SignedInt : UnsignedInt;
    190   if (getLongWidth() == BitWidth)
    191     return IsSigned ? SignedLong : UnsignedLong;
    192   if (getLongLongWidth() == BitWidth)
    193     return IsSigned ? SignedLongLong : UnsignedLongLong;
    194   return NoInt;
    195 }
    196 
    197 TargetInfo::IntType TargetInfo::getLeastIntTypeByWidth(unsigned BitWidth,
    198                                                        bool IsSigned) const {
    199   if (getCharWidth() >= BitWidth)
    200     return IsSigned ? SignedChar : UnsignedChar;
    201   if (getShortWidth() >= BitWidth)
    202     return IsSigned ? SignedShort : UnsignedShort;
    203   if (getIntWidth() >= BitWidth)
    204     return IsSigned ? SignedInt : UnsignedInt;
    205   if (getLongWidth() >= BitWidth)
    206     return IsSigned ? SignedLong : UnsignedLong;
    207   if (getLongLongWidth() >= BitWidth)
    208     return IsSigned ? SignedLongLong : UnsignedLongLong;
    209   return NoInt;
    210 }
    211 
    212 TargetInfo::RealType TargetInfo::getRealTypeByWidth(unsigned BitWidth) const {
    213   if (getFloatWidth() == BitWidth)
    214     return Float;
    215   if (getDoubleWidth() == BitWidth)
    216     return Double;
    217 
    218   switch (BitWidth) {
    219   case 96:
    220     if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended)
    221       return LongDouble;
    222     break;
    223   case 128:
    224     if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble ||
    225         &getLongDoubleFormat() == &llvm::APFloat::IEEEquad)
    226       return LongDouble;
    227     break;
    228   }
    229 
    230   return NoFloat;
    231 }
    232 
    233 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
    234 /// enum. For example, SignedInt -> getIntAlign().
    235 unsigned TargetInfo::getTypeAlign(IntType T) const {
    236   switch (T) {
    237   default: llvm_unreachable("not an integer!");
    238   case SignedChar:
    239   case UnsignedChar:     return getCharAlign();
    240   case SignedShort:
    241   case UnsignedShort:    return getShortAlign();
    242   case SignedInt:
    243   case UnsignedInt:      return getIntAlign();
    244   case SignedLong:
    245   case UnsignedLong:     return getLongAlign();
    246   case SignedLongLong:
    247   case UnsignedLongLong: return getLongLongAlign();
    248   };
    249 }
    250 
    251 /// isTypeSigned - Return whether an integer types is signed. Returns true if
    252 /// the type is signed; false otherwise.
    253 bool TargetInfo::isTypeSigned(IntType T) {
    254   switch (T) {
    255   default: llvm_unreachable("not an integer!");
    256   case SignedChar:
    257   case SignedShort:
    258   case SignedInt:
    259   case SignedLong:
    260   case SignedLongLong:
    261     return true;
    262   case UnsignedChar:
    263   case UnsignedShort:
    264   case UnsignedInt:
    265   case UnsignedLong:
    266   case UnsignedLongLong:
    267     return false;
    268   };
    269 }
    270 
    271 /// adjust - Set forced language options.
    272 /// Apply changes to the target information with respect to certain
    273 /// language options which change the target configuration.
    274 void TargetInfo::adjust(const LangOptions &Opts) {
    275   if (Opts.NoBitFieldTypeAlign)
    276     UseBitFieldTypeAlignment = false;
    277   if (Opts.ShortWChar)
    278     WCharType = UnsignedShort;
    279 
    280   if (Opts.OpenCL) {
    281     // OpenCL C requires specific widths for types, irrespective of
    282     // what these normally are for the target.
    283     // We also define long long and long double here, although the
    284     // OpenCL standard only mentions these as "reserved".
    285     IntWidth = IntAlign = 32;
    286     LongWidth = LongAlign = 64;
    287     LongLongWidth = LongLongAlign = 128;
    288     HalfWidth = HalfAlign = 16;
    289     FloatWidth = FloatAlign = 32;
    290 
    291     // Embedded 32-bit targets (OpenCL EP) might have double C type
    292     // defined as float. Let's not override this as it might lead
    293     // to generating illegal code that uses 64bit doubles.
    294     if (DoubleWidth != FloatWidth) {
    295       DoubleWidth = DoubleAlign = 64;
    296       DoubleFormat = &llvm::APFloat::IEEEdouble;
    297     }
    298     LongDoubleWidth = LongDoubleAlign = 128;
    299 
    300     assert(PointerWidth == 32 || PointerWidth == 64);
    301     bool Is32BitArch = PointerWidth == 32;
    302     SizeType = Is32BitArch ? UnsignedInt : UnsignedLong;
    303     PtrDiffType = Is32BitArch ? SignedInt : SignedLong;
    304     IntPtrType = Is32BitArch ? SignedInt : SignedLong;
    305 
    306     IntMaxType = SignedLongLong;
    307     Int64Type = SignedLong;
    308 
    309     HalfFormat = &llvm::APFloat::IEEEhalf;
    310     FloatFormat = &llvm::APFloat::IEEEsingle;
    311     LongDoubleFormat = &llvm::APFloat::IEEEquad;
    312   }
    313 }
    314 
    315 bool TargetInfo::initFeatureMap(
    316     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
    317     const std::vector<std::string> &FeatureVec) const {
    318   for (const auto &F : FeatureVec) {
    319     StringRef Name = F;
    320     // Apply the feature via the target.
    321     bool Enabled = Name[0] == '+';
    322     setFeatureEnabled(Features, Name.substr(1), Enabled);
    323   }
    324   return true;
    325 }
    326 
    327 //===----------------------------------------------------------------------===//
    328 
    329 
    330 static StringRef removeGCCRegisterPrefix(StringRef Name) {
    331   if (Name[0] == '%' || Name[0] == '#')
    332     Name = Name.substr(1);
    333 
    334   return Name;
    335 }
    336 
    337 /// isValidClobber - Returns whether the passed in string is
    338 /// a valid clobber in an inline asm statement. This is used by
    339 /// Sema.
    340 bool TargetInfo::isValidClobber(StringRef Name) const {
    341   return (isValidGCCRegisterName(Name) ||
    342           Name == "memory" || Name == "cc");
    343 }
    344 
    345 /// isValidGCCRegisterName - Returns whether the passed in string
    346 /// is a valid register name according to GCC. This is used by Sema for
    347 /// inline asm statements.
    348 bool TargetInfo::isValidGCCRegisterName(StringRef Name) const {
    349   if (Name.empty())
    350     return false;
    351 
    352   // Get rid of any register prefix.
    353   Name = removeGCCRegisterPrefix(Name);
    354   if (Name.empty())
    355     return false;
    356 
    357   ArrayRef<const char *> Names = getGCCRegNames();
    358 
    359   // If we have a number it maps to an entry in the register name array.
    360   if (isDigit(Name[0])) {
    361     unsigned n;
    362     if (!Name.getAsInteger(0, n))
    363       return n < Names.size();
    364   }
    365 
    366   // Check register names.
    367   if (std::find(Names.begin(), Names.end(), Name) != Names.end())
    368     return true;
    369 
    370   // Check any additional names that we have.
    371   for (const AddlRegName &ARN : getGCCAddlRegNames())
    372     for (const char *AN : ARN.Names) {
    373       if (!AN)
    374         break;
    375       // Make sure the register that the additional name is for is within
    376       // the bounds of the register names from above.
    377       if (AN == Name && ARN.RegNum < Names.size())
    378         return true;
    379     }
    380 
    381   // Now check aliases.
    382   for (const GCCRegAlias &GRA : getGCCRegAliases())
    383     for (const char *A : GRA.Aliases) {
    384       if (!A)
    385         break;
    386       if (A == Name)
    387         return true;
    388     }
    389 
    390   return false;
    391 }
    392 
    393 StringRef
    394 TargetInfo::getNormalizedGCCRegisterName(StringRef Name) const {
    395   assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
    396 
    397   // Get rid of any register prefix.
    398   Name = removeGCCRegisterPrefix(Name);
    399 
    400   ArrayRef<const char *> Names = getGCCRegNames();
    401 
    402   // First, check if we have a number.
    403   if (isDigit(Name[0])) {
    404     unsigned n;
    405     if (!Name.getAsInteger(0, n)) {
    406       assert(n < Names.size() && "Out of bounds register number!");
    407       return Names[n];
    408     }
    409   }
    410 
    411   // Check any additional names that we have.
    412   for (const AddlRegName &ARN : getGCCAddlRegNames())
    413     for (const char *AN : ARN.Names) {
    414       if (!AN)
    415         break;
    416       // Make sure the register that the additional name is for is within
    417       // the bounds of the register names from above.
    418       if (AN == Name && ARN.RegNum < Names.size())
    419         return Name;
    420     }
    421 
    422   // Now check aliases.
    423   for (const GCCRegAlias &RA : getGCCRegAliases())
    424     for (const char *A : RA.Aliases) {
    425       if (!A)
    426         break;
    427       if (A == Name)
    428         return RA.Register;
    429     }
    430 
    431   return Name;
    432 }
    433 
    434 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
    435   const char *Name = Info.getConstraintStr().c_str();
    436   // An output constraint must start with '=' or '+'
    437   if (*Name != '=' && *Name != '+')
    438     return false;
    439 
    440   if (*Name == '+')
    441     Info.setIsReadWrite();
    442 
    443   Name++;
    444   while (*Name) {
    445     switch (*Name) {
    446     default:
    447       if (!validateAsmConstraint(Name, Info)) {
    448         // FIXME: We temporarily return false
    449         // so we can add more constraints as we hit it.
    450         // Eventually, an unknown constraint should just be treated as 'g'.
    451         return false;
    452       }
    453       break;
    454     case '&': // early clobber.
    455       Info.setEarlyClobber();
    456       break;
    457     case '%': // commutative.
    458       // FIXME: Check that there is a another register after this one.
    459       break;
    460     case 'r': // general register.
    461       Info.setAllowsRegister();
    462       break;
    463     case 'm': // memory operand.
    464     case 'o': // offsetable memory operand.
    465     case 'V': // non-offsetable 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 ',': // multiple alternative constraint.  Pass it.
    476       // Handle additional optional '=' or '+' modifiers.
    477       if (Name[1] == '=' || Name[1] == '+')
    478         Name++;
    479       break;
    480     case '#': // Ignore as constraint.
    481       while (Name[1] && Name[1] != ',')
    482         Name++;
    483       break;
    484     case '?': // Disparage slightly code.
    485     case '!': // Disparage severely.
    486     case '*': // Ignore for choosing register preferences.
    487       break;  // Pass them.
    488     }
    489 
    490     Name++;
    491   }
    492 
    493   // Early clobber with a read-write constraint which doesn't permit registers
    494   // is invalid.
    495   if (Info.earlyClobber() && Info.isReadWrite() && !Info.allowsRegister())
    496     return false;
    497 
    498   // If a constraint allows neither memory nor register operands it contains
    499   // only modifiers. Reject it.
    500   return Info.allowsMemory() || Info.allowsRegister();
    501 }
    502 
    503 bool TargetInfo::resolveSymbolicName(const char *&Name,
    504                                      ArrayRef<ConstraintInfo> OutputConstraints,
    505                                      unsigned &Index) const {
    506   assert(*Name == '[' && "Symbolic name did not start with '['");
    507   Name++;
    508   const char *Start = Name;
    509   while (*Name && *Name != ']')
    510     Name++;
    511 
    512   if (!*Name) {
    513     // Missing ']'
    514     return false;
    515   }
    516 
    517   std::string SymbolicName(Start, Name - Start);
    518 
    519   for (Index = 0; Index != OutputConstraints.size(); ++Index)
    520     if (SymbolicName == OutputConstraints[Index].getName())
    521       return true;
    522 
    523   return false;
    524 }
    525 
    526 bool TargetInfo::validateInputConstraint(
    527                               MutableArrayRef<ConstraintInfo> OutputConstraints,
    528                               ConstraintInfo &Info) const {
    529   const char *Name = Info.ConstraintStr.c_str();
    530 
    531   if (!*Name)
    532     return false;
    533 
    534   while (*Name) {
    535     switch (*Name) {
    536     default:
    537       // Check if we have a matching constraint
    538       if (*Name >= '0' && *Name <= '9') {
    539         const char *DigitStart = Name;
    540         while (Name[1] >= '0' && Name[1] <= '9')
    541           Name++;
    542         const char *DigitEnd = Name;
    543         unsigned i;
    544         if (StringRef(DigitStart, DigitEnd - DigitStart + 1)
    545                 .getAsInteger(10, i))
    546           return false;
    547 
    548         // Check if matching constraint is out of bounds.
    549         if (i >= OutputConstraints.size()) return false;
    550 
    551         // A number must refer to an output only operand.
    552         if (OutputConstraints[i].isReadWrite())
    553           return false;
    554 
    555         // If the constraint is already tied, it must be tied to the
    556         // same operand referenced to by the number.
    557         if (Info.hasTiedOperand() && Info.getTiedOperand() != i)
    558           return false;
    559 
    560         // The constraint should have the same info as the respective
    561         // output constraint.
    562         Info.setTiedOperand(i, OutputConstraints[i]);
    563       } else if (!validateAsmConstraint(Name, Info)) {
    564         // FIXME: This error return is in place temporarily so we can
    565         // add more constraints as we hit it.  Eventually, an unknown
    566         // constraint should just be treated as 'g'.
    567         return false;
    568       }
    569       break;
    570     case '[': {
    571       unsigned Index = 0;
    572       if (!resolveSymbolicName(Name, OutputConstraints, Index))
    573         return false;
    574 
    575       // If the constraint is already tied, it must be tied to the
    576       // same operand referenced to by the number.
    577       if (Info.hasTiedOperand() && Info.getTiedOperand() != Index)
    578         return false;
    579 
    580       // A number must refer to an output only operand.
    581       if (OutputConstraints[Index].isReadWrite())
    582         return false;
    583 
    584       Info.setTiedOperand(Index, OutputConstraints[Index]);
    585       break;
    586     }
    587     case '%': // commutative
    588       // FIXME: Fail if % is used with the last operand.
    589       break;
    590     case 'i': // immediate integer.
    591     case 'n': // immediate integer with a known value.
    592       break;
    593     case 'I':  // Various constant constraints with target-specific meanings.
    594     case 'J':
    595     case 'K':
    596     case 'L':
    597     case 'M':
    598     case 'N':
    599     case 'O':
    600     case 'P':
    601       if (!validateAsmConstraint(Name, Info))
    602         return false;
    603       break;
    604     case 'r': // general register.
    605       Info.setAllowsRegister();
    606       break;
    607     case 'm': // memory operand.
    608     case 'o': // offsettable memory operand.
    609     case 'V': // non-offsettable memory operand.
    610     case '<': // autodecrement memory operand.
    611     case '>': // autoincrement memory operand.
    612       Info.setAllowsMemory();
    613       break;
    614     case 'g': // general register, memory operand or immediate integer.
    615     case 'X': // any operand.
    616       Info.setAllowsRegister();
    617       Info.setAllowsMemory();
    618       break;
    619     case 'E': // immediate floating point.
    620     case 'F': // immediate floating point.
    621     case 'p': // address operand.
    622       break;
    623     case ',': // multiple alternative constraint.  Ignore comma.
    624       break;
    625     case '#': // Ignore as constraint.
    626       while (Name[1] && Name[1] != ',')
    627         Name++;
    628       break;
    629     case '?': // Disparage slightly code.
    630     case '!': // Disparage severely.
    631     case '*': // Ignore for choosing register preferences.
    632       break;  // Pass them.
    633     }
    634 
    635     Name++;
    636   }
    637 
    638   return true;
    639 }
    640