clang/lib/Basic/TargetInfo.cpp

   1 //===--- TargetInfo.cpp - Information about Target machine ----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file implements the TargetInfo interface.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Basic/TargetInfo.h"
  14 #include "clang/Basic/AddressSpaces.h"
  15 #include "clang/Basic/CharInfo.h"
  16 #include "clang/Basic/Diagnostic.h"
  17 #include "clang/Basic/DiagnosticFrontend.h"
  18 #include "clang/Basic/LangOptions.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/Support/ErrorHandling.h"
  22 #include "llvm/TargetParser/TargetParser.h"
  23 #include <cstdlib>
  24 using namespace clang;
  25
  26 static const LangASMap DefaultAddrSpaceMap = {0};
  27 // The fake address space map must have a distinct entry for each
  28 // language-specific address space.
  29 static const LangASMap FakeAddrSpaceMap = {
  30     0,  // Default
  31     1,  // opencl_global
  32     3,  // opencl_local
  33     2,  // opencl_constant
  34     0,  // opencl_private
  35     4,  // opencl_generic
  36     5,  // opencl_global_device
  37     6,  // opencl_global_host
  38     7,  // cuda_device
  39     8,  // cuda_constant
  40     9,  // cuda_shared
  41     1,  // sycl_global
  42     5,  // sycl_global_device
  43     6,  // sycl_global_host
  44     3,  // sycl_local
  45     0,  // sycl_private
  46     10, // ptr32_sptr
  47     11, // ptr32_uptr
  48     12, // ptr64
  49     13, // hlsl_groupshared
  50     20, // wasm_funcref
  51 };
  52
  53 // TargetInfo Constructor.
  54 TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
  55   // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or
  56   // SPARC.  These should be overridden by concrete targets as needed.
  57   BigEndian = !T.isLittleEndian();
  58   TLSSupported = true;
  59   VLASupported = true;
  60   NoAsmVariants = false;
  61   HasLegalHalfType = false;
  62   HalfArgsAndReturns = false;
  63   HasFloat128 = false;
  64   HasIbm128 = false;
  65   HasFloat16 = false;
  66   HasBFloat16 = false;
  67   HasFullBFloat16 = false;
  68   HasLongDouble = true;
  69   HasFPReturn = true;
  70   HasStrictFP = false;
  71   PointerWidth = PointerAlign = 32;
  72   BoolWidth = BoolAlign = 8;
  73   IntWidth = IntAlign = 32;
  74   LongWidth = LongAlign = 32;
  75   LongLongWidth = LongLongAlign = 64;
  76   Int128Align = 128;
  77
  78   // Fixed point default bit widths
  79   ShortAccumWidth = ShortAccumAlign = 16;
  80   AccumWidth = AccumAlign = 32;
  81   LongAccumWidth = LongAccumAlign = 64;
  82   ShortFractWidth = ShortFractAlign = 8;
  83   FractWidth = FractAlign = 16;
  84   LongFractWidth = LongFractAlign = 32;
  85
  86   // Fixed point default integral and fractional bit sizes
  87   // We give the _Accum 1 fewer fractional bits than their corresponding _Fract
  88   // types by default to have the same number of fractional bits between _Accum
  89   // and _Fract types.
  90   PaddingOnUnsignedFixedPoint = false;
  91   ShortAccumScale = 7;
  92   AccumScale = 15;
  93   LongAccumScale = 31;
  94
  95   SuitableAlign = 64;
  96   DefaultAlignForAttributeAligned = 128;
  97   MinGlobalAlign = 0;
  98   // From the glibc documentation, on GNU systems, malloc guarantees 16-byte
  99   // alignment on 64-bit systems and 8-byte alignment on 32-bit systems. See
 100   // https://www.gnu.org/software/libc/manual/html_node/Malloc-Examples.html.
 101   // This alignment guarantee also applies to Windows and Android. On Darwin
 102   // and OpenBSD, the alignment is 16 bytes on both 64-bit and 32-bit systems.
 103   if (T.isGNUEnvironment() || T.isWindowsMSVCEnvironment() || T.isAndroid() ||
 104       T.isOHOSFamily())
 105     NewAlign = Triple.isArch64Bit() ? 128 : Triple.isArch32Bit() ? 64 : 0;
 106   else if (T.isOSDarwin() || T.isOSOpenBSD())
 107     NewAlign = 128;
 108   else
 109     NewAlign = 0; // Infer from basic type alignment.
 110   HalfWidth = 16;
 111   HalfAlign = 16;
 112   FloatWidth = 32;
 113   FloatAlign = 32;
 114   DoubleWidth = 64;
 115   DoubleAlign = 64;
 116   LongDoubleWidth = 64;
 117   LongDoubleAlign = 64;
 118   Float128Align = 128;
 119   Ibm128Align = 128;
 120   LargeArrayMinWidth = 0;
 121   LargeArrayAlign = 0;
 122   MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
 123   MaxVectorAlign = 0;
 124   MaxTLSAlign = 0;
 125   SizeType = UnsignedLong;
 126   PtrDiffType = SignedLong;
 127   IntMaxType = SignedLongLong;
 128   IntPtrType = SignedLong;
 129   WCharType = SignedInt;
 130   WIntType = SignedInt;
 131   Char16Type = UnsignedShort;
 132   Char32Type = UnsignedInt;
 133   Int64Type = SignedLongLong;
 134   Int16Type = SignedShort;
 135   SigAtomicType = SignedInt;
 136   ProcessIDType = SignedInt;
 137   UseSignedCharForObjCBool = true;
 138   UseBitFieldTypeAlignment = true;
 139   UseZeroLengthBitfieldAlignment = false;
 140   UseLeadingZeroLengthBitfield = true;
 141   UseExplicitBitFieldAlignment = true;
 142   ZeroLengthBitfieldBoundary = 0;
 143   MaxAlignedAttribute = 0;
 144   HalfFormat = &llvm::APFloat::IEEEhalf();
 145   FloatFormat = &llvm::APFloat::IEEEsingle();
 146   DoubleFormat = &llvm::APFloat::IEEEdouble();
 147   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 148   Float128Format = &llvm::APFloat::IEEEquad();
 149   Ibm128Format = &llvm::APFloat::PPCDoubleDouble();
 150   MCountName = "mcount";
 151   UserLabelPrefix = "_";
 152   RegParmMax = 0;
 153   SSERegParmMax = 0;
 154   HasAlignMac68kSupport = false;
 155   HasBuiltinMSVaList = false;
 156   IsRenderScriptTarget = false;
 157   HasAArch64SVETypes = false;
 158   HasRISCVVTypes = false;
 159   AllowAMDGPUUnsafeFPAtomics = false;
 160   ARMCDECoprocMask = 0;
 161
 162   // Default to no types using fpret.
 163   RealTypeUsesObjCFPRetMask = 0;
 164
 165   // Default to not using fp2ret for __Complex long double
 166   ComplexLongDoubleUsesFP2Ret = false;
 167
 168   // Set the C++ ABI based on the triple.
 169   TheCXXABI.set(Triple.isKnownWindowsMSVCEnvironment()
 170                     ? TargetCXXABI::Microsoft
 171                     : TargetCXXABI::GenericItanium);
 172
 173   // Default to an empty address space map.
 174   AddrSpaceMap = &DefaultAddrSpaceMap;
 175   UseAddrSpaceMapMangling = false;
 176
 177   // Default to an unknown platform name.
 178   PlatformName = "unknown";
 179   PlatformMinVersion = VersionTuple();
 180
 181   MaxOpenCLWorkGroupSize = 1024;
 182
 183   MaxBitIntWidth.reset();
 184 }
 185
 186 // Out of line virtual dtor for TargetInfo.
 187 TargetInfo::~TargetInfo() {}
 188
 189 void TargetInfo::resetDataLayout(StringRef DL, const char *ULP) {
 190   DataLayoutString = DL.str();
 191   UserLabelPrefix = ULP;
 192 }
 193
 194 bool
 195 TargetInfo::checkCFProtectionBranchSupported(DiagnosticsEngine &Diags) const {
 196   Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=branch";
 197   return false;
 198 }
 199
 200 bool
 201 TargetInfo::checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const {
 202   Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=return";
 203   return false;
 204 }
 205
 206 /// getTypeName - Return the user string for the specified integer type enum.
 207 /// For example, SignedShort -> "short".
 208 const char *TargetInfo::getTypeName(IntType T) {
 209   switch (T) {
 210   default: llvm_unreachable("not an integer!");
 211   case SignedChar:       return "signed char";
 212   case UnsignedChar:     return "unsigned char";
 213   case SignedShort:      return "short";
 214   case UnsignedShort:    return "unsigned short";
 215   case SignedInt:        return "int";
 216   case UnsignedInt:      return "unsigned int";
 217   case SignedLong:       return "long int";
 218   case UnsignedLong:     return "long unsigned int";
 219   case SignedLongLong:   return "long long int";
 220   case UnsignedLongLong: return "long long unsigned int";
 221   }
 222 }
 223
 224 /// getTypeConstantSuffix - Return the constant suffix for the specified
 225 /// integer type enum. For example, SignedLong -> "L".
 226 const char *TargetInfo::getTypeConstantSuffix(IntType T) const {
 227   switch (T) {
 228   default: llvm_unreachable("not an integer!");
 229   case SignedChar:
 230   case SignedShort:
 231   case SignedInt:        return "";
 232   case SignedLong:       return "L";
 233   case SignedLongLong:   return "LL";
 234   case UnsignedChar:
 235     if (getCharWidth() < getIntWidth())
 236       return "";
 237     [[fallthrough]];
 238   case UnsignedShort:
 239     if (getShortWidth() < getIntWidth())
 240       return "";
 241     [[fallthrough]];
 242   case UnsignedInt:      return "U";
 243   case UnsignedLong:     return "UL";
 244   case UnsignedLongLong: return "ULL";
 245   }
 246 }
 247
 248 /// getTypeFormatModifier - Return the printf format modifier for the
 249 /// specified integer type enum. For example, SignedLong -> "l".
 250
 251 const char *TargetInfo::getTypeFormatModifier(IntType T) {
 252   switch (T) {
 253   default: llvm_unreachable("not an integer!");
 254   case SignedChar:
 255   case UnsignedChar:     return "hh";
 256   case SignedShort:
 257   case UnsignedShort:    return "h";
 258   case SignedInt:
 259   case UnsignedInt:      return "";
 260   case SignedLong:
 261   case UnsignedLong:     return "l";
 262   case SignedLongLong:
 263   case UnsignedLongLong: return "ll";
 264   }
 265 }
 266
 267 /// getTypeWidth - Return the width (in bits) of the specified integer type
 268 /// enum. For example, SignedInt -> getIntWidth().
 269 unsigned TargetInfo::getTypeWidth(IntType T) const {
 270   switch (T) {
 271   default: llvm_unreachable("not an integer!");
 272   case SignedChar:
 273   case UnsignedChar:     return getCharWidth();
 274   case SignedShort:
 275   case UnsignedShort:    return getShortWidth();
 276   case SignedInt:
 277   case UnsignedInt:      return getIntWidth();
 278   case SignedLong:
 279   case UnsignedLong:     return getLongWidth();
 280   case SignedLongLong:
 281   case UnsignedLongLong: return getLongLongWidth();
 282   };
 283 }
 284
 285 TargetInfo::IntType TargetInfo::getIntTypeByWidth(
 286     unsigned BitWidth, bool IsSigned) const {
 287   if (getCharWidth() == BitWidth)
 288     return IsSigned ? SignedChar : UnsignedChar;
 289   if (getShortWidth() == BitWidth)
 290     return IsSigned ? SignedShort : UnsignedShort;
 291   if (getIntWidth() == BitWidth)
 292     return IsSigned ? SignedInt : UnsignedInt;
 293   if (getLongWidth() == BitWidth)
 294     return IsSigned ? SignedLong : UnsignedLong;
 295   if (getLongLongWidth() == BitWidth)
 296     return IsSigned ? SignedLongLong : UnsignedLongLong;
 297   return NoInt;
 298 }
 299
 300 TargetInfo::IntType TargetInfo::getLeastIntTypeByWidth(unsigned BitWidth,
 301                                                        bool IsSigned) const {
 302   if (getCharWidth() >= BitWidth)
 303     return IsSigned ? SignedChar : UnsignedChar;
 304   if (getShortWidth() >= BitWidth)
 305     return IsSigned ? SignedShort : UnsignedShort;
 306   if (getIntWidth() >= BitWidth)
 307     return IsSigned ? SignedInt : UnsignedInt;
 308   if (getLongWidth() >= BitWidth)
 309     return IsSigned ? SignedLong : UnsignedLong;
 310   if (getLongLongWidth() >= BitWidth)
 311     return IsSigned ? SignedLongLong : UnsignedLongLong;
 312   return NoInt;
 313 }
 314
 315 FloatModeKind TargetInfo::getRealTypeByWidth(unsigned BitWidth,
 316                                              FloatModeKind ExplicitType) const {
 317   if (getHalfWidth() == BitWidth)
 318     return FloatModeKind::Half;
 319   if (getFloatWidth() == BitWidth)
 320     return FloatModeKind::Float;
 321   if (getDoubleWidth() == BitWidth)
 322     return FloatModeKind::Double;
 323
 324   switch (BitWidth) {
 325   case 96:
 326     if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended())
 327       return FloatModeKind::LongDouble;
 328     break;
 329   case 128:
 330     // The caller explicitly asked for an IEEE compliant type but we still
 331     // have to check if the target supports it.
 332     if (ExplicitType == FloatModeKind::Float128)
 333       return hasFloat128Type() ? FloatModeKind::Float128
 334                                : FloatModeKind::NoFloat;
 335     if (ExplicitType == FloatModeKind::Ibm128)
 336       return hasIbm128Type() ? FloatModeKind::Ibm128
 337                              : FloatModeKind::NoFloat;
 338     if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble() ||
 339         &getLongDoubleFormat() == &llvm::APFloat::IEEEquad())
 340       return FloatModeKind::LongDouble;
 341     if (hasFloat128Type())
 342       return FloatModeKind::Float128;
 343     break;
 344   }
 345
 346   return FloatModeKind::NoFloat;
 347 }
 348
 349 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
 350 /// enum. For example, SignedInt -> getIntAlign().
 351 unsigned TargetInfo::getTypeAlign(IntType T) const {
 352   switch (T) {
 353   default: llvm_unreachable("not an integer!");
 354   case SignedChar:
 355   case UnsignedChar:     return getCharAlign();
 356   case SignedShort:
 357   case UnsignedShort:    return getShortAlign();
 358   case SignedInt:
 359   case UnsignedInt:      return getIntAlign();
 360   case SignedLong:
 361   case UnsignedLong:     return getLongAlign();
 362   case SignedLongLong:
 363   case UnsignedLongLong: return getLongLongAlign();
 364   };
 365 }
 366
 367 /// isTypeSigned - Return whether an integer types is signed. Returns true if
 368 /// the type is signed; false otherwise.
 369 bool TargetInfo::isTypeSigned(IntType T) {
 370   switch (T) {
 371   default: llvm_unreachable("not an integer!");
 372   case SignedChar:
 373   case SignedShort:
 374   case SignedInt:
 375   case SignedLong:
 376   case SignedLongLong:
 377     return true;
 378   case UnsignedChar:
 379   case UnsignedShort:
 380   case UnsignedInt:
 381   case UnsignedLong:
 382   case UnsignedLongLong:
 383     return false;
 384   };
 385 }
 386
 387 /// adjust - Set forced language options.
 388 /// Apply changes to the target information with respect to certain
 389 /// language options which change the target configuration and adjust
 390 /// the language based on the target options where applicable.
 391 void TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {
 392   if (Opts.NoBitFieldTypeAlign)
 393     UseBitFieldTypeAlignment = false;
 394
 395   switch (Opts.WCharSize) {
 396   default: llvm_unreachable("invalid wchar_t width");
 397   case 0: break;
 398   case 1: WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar; break;
 399   case 2: WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort; break;
 400   case 4: WCharType = Opts.WCharIsSigned ? SignedInt : UnsignedInt; break;
 401   }
 402
 403   if (Opts.AlignDouble) {
 404     DoubleAlign = LongLongAlign = 64;
 405     LongDoubleAlign = 64;
 406   }
 407
 408   if (Opts.OpenCL) {
 409     // OpenCL C requires specific widths for types, irrespective of
 410     // what these normally are for the target.
 411     // We also define long long and long double here, although the
 412     // OpenCL standard only mentions these as "reserved".
 413     IntWidth = IntAlign = 32;
 414     LongWidth = LongAlign = 64;
 415     LongLongWidth = LongLongAlign = 128;
 416     HalfWidth = HalfAlign = 16;
 417     FloatWidth = FloatAlign = 32;
 418
 419     // Embedded 32-bit targets (OpenCL EP) might have double C type
 420     // defined as float. Let's not override this as it might lead
 421     // to generating illegal code that uses 64bit doubles.
 422     if (DoubleWidth != FloatWidth) {
 423       DoubleWidth = DoubleAlign = 64;
 424       DoubleFormat = &llvm::APFloat::IEEEdouble();
 425     }
 426     LongDoubleWidth = LongDoubleAlign = 128;
 427
 428     unsigned MaxPointerWidth = getMaxPointerWidth();
 429     assert(MaxPointerWidth == 32 || MaxPointerWidth == 64);
 430     bool Is32BitArch = MaxPointerWidth == 32;
 431     SizeType = Is32BitArch ? UnsignedInt : UnsignedLong;
 432     PtrDiffType = Is32BitArch ? SignedInt : SignedLong;
 433     IntPtrType = Is32BitArch ? SignedInt : SignedLong;
 434
 435     IntMaxType = SignedLongLong;
 436     Int64Type = SignedLong;
 437
 438     HalfFormat = &llvm::APFloat::IEEEhalf();
 439     FloatFormat = &llvm::APFloat::IEEEsingle();
 440     LongDoubleFormat = &llvm::APFloat::IEEEquad();
 441
 442     // OpenCL C v3.0 s6.7.5 - The generic address space requires support for
 443     // OpenCL C 2.0 or OpenCL C 3.0 with the __opencl_c_generic_address_space
 444     // feature
 445     // OpenCL C v3.0 s6.2.1 - OpenCL pipes require support of OpenCL C 2.0
 446     // or later and __opencl_c_pipes feature
 447     // FIXME: These language options are also defined in setLangDefaults()
 448     // for OpenCL C 2.0 but with no access to target capabilities. Target
 449     // should be immutable once created and thus these language options need
 450     // to be defined only once.
 451     if (Opts.getOpenCLCompatibleVersion() == 300) {
 452       const auto &OpenCLFeaturesMap = getSupportedOpenCLOpts();
 453       Opts.OpenCLGenericAddressSpace = hasFeatureEnabled(
 454           OpenCLFeaturesMap, "__opencl_c_generic_address_space");
 455       Opts.OpenCLPipes =
 456           hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_pipes");
 457       Opts.Blocks =
 458           hasFeatureEnabled(OpenCLFeaturesMap, "__opencl_c_device_enqueue");
 459     }
 460   }
 461
 462   if (Opts.DoubleSize) {
 463     if (Opts.DoubleSize == 32) {
 464       DoubleWidth = 32;
 465       LongDoubleWidth = 32;
 466       DoubleFormat = &llvm::APFloat::IEEEsingle();
 467       LongDoubleFormat = &llvm::APFloat::IEEEsingle();
 468     } else if (Opts.DoubleSize == 64) {
 469       DoubleWidth = 64;
 470       LongDoubleWidth = 64;
 471       DoubleFormat = &llvm::APFloat::IEEEdouble();
 472       LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 473     }
 474   }
 475
 476   if (Opts.LongDoubleSize) {
 477     if (Opts.LongDoubleSize == DoubleWidth) {
 478       LongDoubleWidth = DoubleWidth;
 479       LongDoubleAlign = DoubleAlign;
 480       LongDoubleFormat = DoubleFormat;
 481     } else if (Opts.LongDoubleSize == 128) {
 482       LongDoubleWidth = LongDoubleAlign = 128;
 483       LongDoubleFormat = &llvm::APFloat::IEEEquad();
 484     } else if (Opts.LongDoubleSize == 80) {
 485       LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
 486       if (getTriple().isWindowsMSVCEnvironment()) {
 487         LongDoubleWidth = 128;
 488         LongDoubleAlign = 128;
 489       } else { // Linux
 490         if (getTriple().getArch() == llvm::Triple::x86) {
 491           LongDoubleWidth = 96;
 492           LongDoubleAlign = 32;
 493         } else {
 494           LongDoubleWidth = 128;
 495           LongDoubleAlign = 128;
 496         }
 497       }
 498     }
 499   }
 500
 501   if (Opts.NewAlignOverride)
 502     NewAlign = Opts.NewAlignOverride * getCharWidth();
 503
 504   // Each unsigned fixed point type has the same number of fractional bits as
 505   // its corresponding signed type.
 506   PaddingOnUnsignedFixedPoint |= Opts.PaddingOnUnsignedFixedPoint;
 507   CheckFixedPointBits();
 508
 509   if (Opts.ProtectParens && !checkArithmeticFenceSupported()) {
 510     Diags.Report(diag::err_opt_not_valid_on_target) << "-fprotect-parens";
 511     Opts.ProtectParens = false;
 512   }
 513
 514   if (Opts.MaxBitIntWidth)
 515     MaxBitIntWidth = static_cast<unsigned>(Opts.MaxBitIntWidth);
 516
 517   if (Opts.FakeAddressSpaceMap)
 518     AddrSpaceMap = &FakeAddrSpaceMap;
 519 }
 520
 521 bool TargetInfo::initFeatureMap(
 522     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
 523     const std::vector<std::string> &FeatureVec) const {
 524   for (const auto &F : FeatureVec) {
 525     StringRef Name = F;
 526     if (Name.empty())
 527       continue;
 528     // Apply the feature via the target.
 529     if (Name[0] != '+' && Name[0] != '-')
 530       Diags.Report(diag::warn_fe_backend_invalid_feature_flag) << Name;
 531     else
 532       setFeatureEnabled(Features, Name.substr(1), Name[0] == '+');
 533   }
 534   return true;
 535 }
 536
 537 ParsedTargetAttr TargetInfo::parseTargetAttr(StringRef Features) const {
 538   ParsedTargetAttr Ret;
 539   if (Features == "default")
 540     return Ret;
 541   SmallVector<StringRef, 1> AttrFeatures;
 542   Features.split(AttrFeatures, ",");
 543
 544   // Grab the various features and prepend a "+" to turn on the feature to
 545   // the backend and add them to our existing set of features.
 546   for (auto &Feature : AttrFeatures) {
 547     // Go ahead and trim whitespace rather than either erroring or
 548     // accepting it weirdly.
 549     Feature = Feature.trim();
 550
 551     // TODO: Support the fpmath option. It will require checking
 552     // overall feature validity for the function with the rest of the
 553     // attributes on the function.
 554     if (Feature.startswith("fpmath="))
 555       continue;
 556
 557     if (Feature.startswith("branch-protection=")) {
 558       Ret.BranchProtection = Feature.split('=').second.trim();
 559       continue;
 560     }
 561
 562     // While we're here iterating check for a different target cpu.
 563     if (Feature.startswith("arch=")) {
 564       if (!Ret.CPU.empty())
 565         Ret.Duplicate = "arch=";
 566       else
 567         Ret.CPU = Feature.split("=").second.trim();
 568     } else if (Feature.startswith("tune=")) {
 569       if (!Ret.Tune.empty())
 570         Ret.Duplicate = "tune=";
 571       else
 572         Ret.Tune = Feature.split("=").second.trim();
 573     } else if (Feature.startswith("no-"))
 574       Ret.Features.push_back("-" + Feature.split("-").second.str());
 575     else
 576       Ret.Features.push_back("+" + Feature.str());
 577   }
 578   return Ret;
 579 }
 580
 581 TargetInfo::CallingConvKind
 582 TargetInfo::getCallingConvKind(bool ClangABICompat4) const {
 583   if (getCXXABI() != TargetCXXABI::Microsoft &&
 584       (ClangABICompat4 || getTriple().isPS4()))
 585     return CCK_ClangABI4OrPS4;
 586   return CCK_Default;
 587 }
 588
 589 bool TargetInfo::areDefaultedSMFStillPOD(const LangOptions &LangOpts) const {
 590   return LangOpts.getClangABICompat() > LangOptions::ClangABI::Ver15;
 591 }
 592
 593 LangAS TargetInfo::getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const {
 594   switch (TK) {
 595   case OCLTK_Image:
 596   case OCLTK_Pipe:
 597     return LangAS::opencl_global;
 598
 599   case OCLTK_Sampler:
 600     return LangAS::opencl_constant;
 601
 602   default:
 603     return LangAS::Default;
 604   }
 605 }
 606
 607 //===----------------------------------------------------------------------===//
 608
 609
 610 static StringRef removeGCCRegisterPrefix(StringRef Name) {
 611   if (Name[0] == '%' || Name[0] == '#')
 612     Name = Name.substr(1);
 613
 614   return Name;
 615 }
 616
 617 /// isValidClobber - Returns whether the passed in string is
 618 /// a valid clobber in an inline asm statement. This is used by
 619 /// Sema.
 620 bool TargetInfo::isValidClobber(StringRef Name) const {
 621   return (isValidGCCRegisterName(Name) || Name == "memory" || Name == "cc" ||
 622           Name == "unwind");
 623 }
 624
 625 /// isValidGCCRegisterName - Returns whether the passed in string
 626 /// is a valid register name according to GCC. This is used by Sema for
 627 /// inline asm statements.
 628 bool TargetInfo::isValidGCCRegisterName(StringRef Name) const {
 629   if (Name.empty())
 630     return false;
 631
 632   // Get rid of any register prefix.
 633   Name = removeGCCRegisterPrefix(Name);
 634   if (Name.empty())
 635     return false;
 636
 637   ArrayRef<const char *> Names = getGCCRegNames();
 638
 639   // If we have a number it maps to an entry in the register name array.
 640   if (isDigit(Name[0])) {
 641     unsigned n;
 642     if (!Name.getAsInteger(0, n))
 643       return n < Names.size();
 644   }
 645
 646   // Check register names.
 647   if (llvm::is_contained(Names, Name))
 648     return true;
 649
 650   // Check any additional names that we have.
 651   for (const AddlRegName &ARN : getGCCAddlRegNames())
 652     for (const char *AN : ARN.Names) {
 653       if (!AN)
 654         break;
 655       // Make sure the register that the additional name is for is within
 656       // the bounds of the register names from above.
 657       if (AN == Name && ARN.RegNum < Names.size())
 658         return true;
 659     }
 660
 661   // Now check aliases.
 662   for (const GCCRegAlias &GRA : getGCCRegAliases())
 663     for (const char *A : GRA.Aliases) {
 664       if (!A)
 665         break;
 666       if (A == Name)
 667         return true;
 668     }
 669
 670   return false;
 671 }
 672
 673 StringRef TargetInfo::getNormalizedGCCRegisterName(StringRef Name,
 674                                                    bool ReturnCanonical) const {
 675   assert(isValidGCCRegisterName(Name) && "Invalid register passed in");
 676
 677   // Get rid of any register prefix.
 678   Name = removeGCCRegisterPrefix(Name);
 679
 680   ArrayRef<const char *> Names = getGCCRegNames();
 681
 682   // First, check if we have a number.
 683   if (isDigit(Name[0])) {
 684     unsigned n;
 685     if (!Name.getAsInteger(0, n)) {
 686       assert(n < Names.size() && "Out of bounds register number!");
 687       return Names[n];
 688     }
 689   }
 690
 691   // Check any additional names that we have.
 692   for (const AddlRegName &ARN : getGCCAddlRegNames())
 693     for (const char *AN : ARN.Names) {
 694       if (!AN)
 695         break;
 696       // Make sure the register that the additional name is for is within
 697       // the bounds of the register names from above.
 698       if (AN == Name && ARN.RegNum < Names.size())
 699         return ReturnCanonical ? Names[ARN.RegNum] : Name;
 700     }
 701
 702   // Now check aliases.
 703   for (const GCCRegAlias &RA : getGCCRegAliases())
 704     for (const char *A : RA.Aliases) {
 705       if (!A)
 706         break;
 707       if (A == Name)
 708         return RA.Register;
 709     }
 710
 711   return Name;
 712 }
 713
 714 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
 715   const char *Name = Info.getConstraintStr().c_str();
 716   // An output constraint must start with '=' or '+'
 717   if (*Name != '=' && *Name != '+')
 718     return false;
 719
 720   if (*Name == '+')
 721     Info.setIsReadWrite();
 722
 723   Name++;
 724   while (*Name) {
 725     switch (*Name) {
 726     default:
 727       if (!validateAsmConstraint(Name, Info)) {
 728         // FIXME: We temporarily return false
 729         // so we can add more constraints as we hit it.
 730         // Eventually, an unknown constraint should just be treated as 'g'.
 731         return false;
 732       }
 733       break;
 734     case '&': // early clobber.
 735       Info.setEarlyClobber();
 736       break;
 737     case '%': // commutative.
 738       // FIXME: Check that there is a another register after this one.
 739       break;
 740     case 'r': // general register.
 741       Info.setAllowsRegister();
 742       break;
 743     case 'm': // memory operand.
 744     case 'o': // offsetable memory operand.
 745     case 'V': // non-offsetable memory operand.
 746     case '<': // autodecrement memory operand.
 747     case '>': // autoincrement memory operand.
 748       Info.setAllowsMemory();
 749       break;
 750     case 'g': // general register, memory operand or immediate integer.
 751     case 'X': // any operand.
 752       Info.setAllowsRegister();
 753       Info.setAllowsMemory();
 754       break;
 755     case ',': // multiple alternative constraint.  Pass it.
 756       // Handle additional optional '=' or '+' modifiers.
 757       if (Name[1] == '=' || Name[1] == '+')
 758         Name++;
 759       break;
 760     case '#': // Ignore as constraint.
 761       while (Name[1] && Name[1] != ',')
 762         Name++;
 763       break;
 764     case '?': // Disparage slightly code.
 765     case '!': // Disparage severely.
 766     case '*': // Ignore for choosing register preferences.
 767     case 'i': // Ignore i,n,E,F as output constraints (match from the other
 768               // chars)
 769     case 'n':
 770     case 'E':
 771     case 'F':
 772       break;  // Pass them.
 773     }
 774
 775     Name++;
 776   }
 777
 778   // Early clobber with a read-write constraint which doesn't permit registers
 779   // is invalid.
 780   if (Info.earlyClobber() && Info.isReadWrite() && !Info.allowsRegister())
 781     return false;
 782
 783   // If a constraint allows neither memory nor register operands it contains
 784   // only modifiers. Reject it.
 785   return Info.allowsMemory() || Info.allowsRegister();
 786 }
 787
 788 bool TargetInfo::resolveSymbolicName(const char *&Name,
 789                                      ArrayRef<ConstraintInfo> OutputConstraints,
 790                                      unsigned &Index) const {
 791   assert(*Name == '[' && "Symbolic name did not start with '['");
 792   Name++;
 793   const char *Start = Name;
 794   while (*Name && *Name != ']')
 795     Name++;
 796
 797   if (!*Name) {
 798     // Missing ']'
 799     return false;
 800   }
 801
 802   std::string SymbolicName(Start, Name - Start);
 803
 804   for (Index = 0; Index != OutputConstraints.size(); ++Index)
 805     if (SymbolicName == OutputConstraints[Index].getName())
 806       return true;
 807
 808   return false;
 809 }
 810
 811 bool TargetInfo::validateInputConstraint(
 812                               MutableArrayRef<ConstraintInfo> OutputConstraints,
 813                               ConstraintInfo &Info) const {
 814   const char *Name = Info.ConstraintStr.c_str();
 815
 816   if (!*Name)
 817     return false;
 818
 819   while (*Name) {
 820     switch (*Name) {
 821     default:
 822       // Check if we have a matching constraint
 823       if (*Name >= '0' && *Name <= '9') {
 824         const char *DigitStart = Name;
 825         while (Name[1] >= '0' && Name[1] <= '9')
 826           Name++;
 827         const char *DigitEnd = Name;
 828         unsigned i;
 829         if (StringRef(DigitStart, DigitEnd - DigitStart + 1)
 830                 .getAsInteger(10, i))
 831           return false;
 832
 833         // Check if matching constraint is out of bounds.
 834         if (i >= OutputConstraints.size()) return false;
 835
 836         // A number must refer to an output only operand.
 837         if (OutputConstraints[i].isReadWrite())
 838           return false;
 839
 840         // If the constraint is already tied, it must be tied to the
 841         // same operand referenced to by the number.
 842         if (Info.hasTiedOperand() && Info.getTiedOperand() != i)
 843           return false;
 844
 845         // The constraint should have the same info as the respective
 846         // output constraint.
 847         Info.setTiedOperand(i, OutputConstraints[i]);
 848       } else if (!validateAsmConstraint(Name, Info)) {
 849         // FIXME: This error return is in place temporarily so we can
 850         // add more constraints as we hit it.  Eventually, an unknown
 851         // constraint should just be treated as 'g'.
 852         return false;
 853       }
 854       break;
 855     case '[': {
 856       unsigned Index = 0;
 857       if (!resolveSymbolicName(Name, OutputConstraints, Index))
 858         return false;
 859
 860       // If the constraint is already tied, it must be tied to the
 861       // same operand referenced to by the number.
 862       if (Info.hasTiedOperand() && Info.getTiedOperand() != Index)
 863         return false;
 864
 865       // A number must refer to an output only operand.
 866       if (OutputConstraints[Index].isReadWrite())
 867         return false;
 868
 869       Info.setTiedOperand(Index, OutputConstraints[Index]);
 870       break;
 871     }
 872     case '%': // commutative
 873       // FIXME: Fail if % is used with the last operand.
 874       break;
 875     case 'i': // immediate integer.
 876       break;
 877     case 'n': // immediate integer with a known value.
 878       Info.setRequiresImmediate();
 879       break;
 880     case 'I':  // Various constant constraints with target-specific meanings.
 881     case 'J':
 882     case 'K':
 883     case 'L':
 884     case 'M':
 885     case 'N':
 886     case 'O':
 887     case 'P':
 888       if (!validateAsmConstraint(Name, Info))
 889         return false;
 890       break;
 891     case 'r': // general register.
 892       Info.setAllowsRegister();
 893       break;
 894     case 'm': // memory operand.
 895     case 'o': // offsettable memory operand.
 896     case 'V': // non-offsettable memory operand.
 897     case '<': // autodecrement memory operand.
 898     case '>': // autoincrement memory operand.
 899       Info.setAllowsMemory();
 900       break;
 901     case 'g': // general register, memory operand or immediate integer.
 902     case 'X': // any operand.
 903       Info.setAllowsRegister();
 904       Info.setAllowsMemory();
 905       break;
 906     case 'E': // immediate floating point.
 907     case 'F': // immediate floating point.
 908     case 'p': // address operand.
 909       break;
 910     case ',': // multiple alternative constraint.  Ignore comma.
 911       break;
 912     case '#': // Ignore as constraint.
 913       while (Name[1] && Name[1] != ',')
 914         Name++;
 915       break;
 916     case '?': // Disparage slightly code.
 917     case '!': // Disparage severely.
 918     case '*': // Ignore for choosing register preferences.
 919       break;  // Pass them.
 920     }
 921
 922     Name++;
 923   }
 924
 925   return true;
 926 }
 927
 928 void TargetInfo::CheckFixedPointBits() const {
 929   // Check that the number of fractional and integral bits (and maybe sign) can
 930   // fit into the bits given for a fixed point type.
 931   assert(ShortAccumScale + getShortAccumIBits() + 1 <= ShortAccumWidth);
 932   assert(AccumScale + getAccumIBits() + 1 <= AccumWidth);
 933   assert(LongAccumScale + getLongAccumIBits() + 1 <= LongAccumWidth);
 934   assert(getUnsignedShortAccumScale() + getUnsignedShortAccumIBits() <=
 935          ShortAccumWidth);
 936   assert(getUnsignedAccumScale() + getUnsignedAccumIBits() <= AccumWidth);
 937   assert(getUnsignedLongAccumScale() + getUnsignedLongAccumIBits() <=
 938          LongAccumWidth);
 939
 940   assert(getShortFractScale() + 1 <= ShortFractWidth);
 941   assert(getFractScale() + 1 <= FractWidth);
 942   assert(getLongFractScale() + 1 <= LongFractWidth);
 943   assert(getUnsignedShortFractScale() <= ShortFractWidth);
 944   assert(getUnsignedFractScale() <= FractWidth);
 945   assert(getUnsignedLongFractScale() <= LongFractWidth);
 946
 947   // Each unsigned fract type has either the same number of fractional bits
 948   // as, or one more fractional bit than, its corresponding signed fract type.
 949   assert(getShortFractScale() == getUnsignedShortFractScale() ||
 950          getShortFractScale() == getUnsignedShortFractScale() - 1);
 951   assert(getFractScale() == getUnsignedFractScale() ||
 952          getFractScale() == getUnsignedFractScale() - 1);
 953   assert(getLongFractScale() == getUnsignedLongFractScale() ||
 954          getLongFractScale() == getUnsignedLongFractScale() - 1);
 955
 956   // When arranged in order of increasing rank (see 6.3.1.3a), the number of
 957   // fractional bits is nondecreasing for each of the following sets of
 958   // fixed-point types:
 959   // - signed fract types
 960   // - unsigned fract types
 961   // - signed accum types
 962   // - unsigned accum types.
 963   assert(getLongFractScale() >= getFractScale() &&
 964          getFractScale() >= getShortFractScale());
 965   assert(getUnsignedLongFractScale() >= getUnsignedFractScale() &&
 966          getUnsignedFractScale() >= getUnsignedShortFractScale());
 967   assert(LongAccumScale >= AccumScale && AccumScale >= ShortAccumScale);
 968   assert(getUnsignedLongAccumScale() >= getUnsignedAccumScale() &&
 969          getUnsignedAccumScale() >= getUnsignedShortAccumScale());
 970
 971   // When arranged in order of increasing rank (see 6.3.1.3a), the number of
 972   // integral bits is nondecreasing for each of the following sets of
 973   // fixed-point types:
 974   // - signed accum types
 975   // - unsigned accum types
 976   assert(getLongAccumIBits() >= getAccumIBits() &&
 977          getAccumIBits() >= getShortAccumIBits());
 978   assert(getUnsignedLongAccumIBits() >= getUnsignedAccumIBits() &&
 979          getUnsignedAccumIBits() >= getUnsignedShortAccumIBits());
 980
 981   // Each signed accum type has at least as many integral bits as its
 982   // corresponding unsigned accum type.
 983   assert(getShortAccumIBits() >= getUnsignedShortAccumIBits());
 984   assert(getAccumIBits() >= getUnsignedAccumIBits());
 985   assert(getLongAccumIBits() >= getUnsignedLongAccumIBits());
 986 }
 987
 988 void TargetInfo::copyAuxTarget(const TargetInfo *Aux) {
 989   auto *Target = static_cast<TransferrableTargetInfo*>(this);
 990   auto *Src = static_cast<const TransferrableTargetInfo*>(Aux);
 991   *Target = *Src;
 992 }