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 } 993