1 //===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- C++ -*-===// 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 defines the set of low-level target independent types which various 10 // values in the code generator are. This allows the target specific behavior 11 // of instructions to be described to target independent passes. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CODEGEN_VALUETYPES_H 16 #define LLVM_CODEGEN_VALUETYPES_H 17 18 #include "llvm/CodeGenTypes/MachineValueType.h" 19 #include "llvm/Support/Compiler.h" 20 #include "llvm/Support/MathExtras.h" 21 #include "llvm/Support/TypeSize.h" 22 #include <cassert> 23 #include <cstdint> 24 #include <string> 25 26 namespace llvm { 27 28 class LLVMContext; 29 class Type; 30 struct fltSemantics; 31 32 /// Extended Value Type. Capable of holding value types which are not native 33 /// for any processor (such as the i12345 type), as well as the types an MVT 34 /// can represent. 35 struct EVT { 36 private: 37 MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE; 38 Type *LLVMTy = nullptr; 39 40 public: 41 constexpr EVT() = default; 42 constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {} 43 constexpr EVT(MVT S) : V(S) {} 44 45 bool operator==(EVT VT) const { 46 return !(*this != VT); 47 } 48 bool operator!=(EVT VT) const { 49 if (V.SimpleTy != VT.V.SimpleTy) 50 return true; 51 if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 52 return LLVMTy != VT.LLVMTy; 53 return false; 54 } 55 56 /// Returns the EVT that represents a floating-point type with the given 57 /// number of bits. There are two floating-point types with 128 bits - this 58 /// returns f128 rather than ppcf128. 59 static EVT getFloatingPointVT(unsigned BitWidth) { 60 return MVT::getFloatingPointVT(BitWidth); 61 } 62 63 /// Returns the EVT that represents an integer with the given number of 64 /// bits. 65 static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) { 66 MVT M = MVT::getIntegerVT(BitWidth); 67 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 68 return M; 69 return getExtendedIntegerVT(Context, BitWidth); 70 } 71 72 /// Returns the EVT that represents a vector NumElements in length, where 73 /// each element is of type VT. 74 static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements, 75 bool IsScalable = false) { 76 MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable); 77 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 78 return M; 79 return getExtendedVectorVT(Context, VT, NumElements, IsScalable); 80 } 81 82 /// Returns the EVT that represents a vector EC.Min elements in length, 83 /// where each element is of type VT. 84 static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) { 85 MVT M = MVT::getVectorVT(VT.V, EC); 86 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 87 return M; 88 return getExtendedVectorVT(Context, VT, EC); 89 } 90 91 /// Return a vector with the same number of elements as this vector, but 92 /// with the element type converted to an integer type with the same 93 /// bitwidth. 94 EVT changeVectorElementTypeToInteger() const { 95 if (isSimple()) 96 return getSimpleVT().changeVectorElementTypeToInteger(); 97 return changeExtendedVectorElementTypeToInteger(); 98 } 99 100 /// Return a VT for a vector type whose attributes match ourselves 101 /// with the exception of the element type that is chosen by the caller. 102 EVT changeVectorElementType(EVT EltVT) const { 103 if (isSimple()) { 104 assert(EltVT.isSimple() && 105 "Can't change simple vector VT to have extended element VT"); 106 return getSimpleVT().changeVectorElementType(EltVT.getSimpleVT()); 107 } 108 return changeExtendedVectorElementType(EltVT); 109 } 110 111 /// Return a VT for a type whose attributes match ourselves with the 112 /// exception of the element type that is chosen by the caller. 113 EVT changeElementType(EVT EltVT) const { 114 EltVT = EltVT.getScalarType(); 115 return isVector() ? changeVectorElementType(EltVT) : EltVT; 116 } 117 118 /// Return the type converted to an equivalently sized integer or vector 119 /// with integer element type. Similar to changeVectorElementTypeToInteger, 120 /// but also handles scalars. 121 EVT changeTypeToInteger() const { 122 if (isVector()) 123 return changeVectorElementTypeToInteger(); 124 125 if (isSimple()) 126 return getSimpleVT().changeTypeToInteger(); 127 return changeExtendedTypeToInteger(); 128 } 129 130 /// Test if the given EVT has zero size, this will fail if called on a 131 /// scalable type 132 bool isZeroSized() const { 133 return getSizeInBits().isZero(); 134 } 135 136 /// Test if the given EVT is simple (as opposed to being extended). 137 bool isSimple() const { 138 return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE; 139 } 140 141 /// Test if the given EVT is extended (as opposed to being simple). 142 bool isExtended() const { 143 return !isSimple(); 144 } 145 146 /// Return true if this is a FP or a vector FP type. 147 bool isFloatingPoint() const { 148 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint(); 149 } 150 151 /// Return true if this is an integer or a vector integer type. 152 bool isInteger() const { 153 return isSimple() ? V.isInteger() : isExtendedInteger(); 154 } 155 156 /// Return true if this is an integer, but not a vector. 157 bool isScalarInteger() const { 158 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger(); 159 } 160 161 /// Return true if this is a vector type where the runtime 162 /// length is machine dependent 163 bool isScalableTargetExtVT() const { 164 return isSimple() && V.isScalableTargetExtVT(); 165 } 166 167 /// Return true if this is a vector value type. 168 bool isVector() const { 169 return isSimple() ? V.isVector() : isExtendedVector(); 170 } 171 172 /// Return true if this is a vector type where the runtime 173 /// length is machine dependent 174 bool isScalableVector() const { 175 return isSimple() ? V.isScalableVector() : isExtendedScalableVector(); 176 } 177 178 /// Return true if this is a vector value type. 179 bool isRISCVVectorTuple() const { return V.isRISCVVectorTuple(); } 180 181 bool isFixedLengthVector() const { 182 return isSimple() ? V.isFixedLengthVector() 183 : isExtendedFixedLengthVector(); 184 } 185 186 /// Return true if the type is a scalable type. 187 bool isScalableVT() const { 188 return isScalableVector() || isScalableTargetExtVT(); 189 } 190 191 /// Return true if this is a 16-bit vector type. 192 bool is16BitVector() const { 193 return isSimple() ? V.is16BitVector() : isExtended16BitVector(); 194 } 195 196 /// Return true if this is a 32-bit vector type. 197 bool is32BitVector() const { 198 return isSimple() ? V.is32BitVector() : isExtended32BitVector(); 199 } 200 201 /// Return true if this is a 64-bit vector type. 202 bool is64BitVector() const { 203 return isSimple() ? V.is64BitVector() : isExtended64BitVector(); 204 } 205 206 /// Return true if this is a 128-bit vector type. 207 bool is128BitVector() const { 208 return isSimple() ? V.is128BitVector() : isExtended128BitVector(); 209 } 210 211 /// Return true if this is a 256-bit vector type. 212 bool is256BitVector() const { 213 return isSimple() ? V.is256BitVector() : isExtended256BitVector(); 214 } 215 216 /// Return true if this is a 512-bit vector type. 217 bool is512BitVector() const { 218 return isSimple() ? V.is512BitVector() : isExtended512BitVector(); 219 } 220 221 /// Return true if this is a 1024-bit vector type. 222 bool is1024BitVector() const { 223 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector(); 224 } 225 226 /// Return true if this is a 2048-bit vector type. 227 bool is2048BitVector() const { 228 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector(); 229 } 230 231 /// Return true if this is an overloaded type for TableGen. 232 bool isOverloaded() const { 233 return (V == MVT::iAny || V == MVT::fAny || V == MVT::vAny || 234 V == MVT::pAny); 235 } 236 237 /// Return true if the bit size is a multiple of 8. 238 bool isByteSized() const { 239 return !isZeroSized() && getSizeInBits().isKnownMultipleOf(8); 240 } 241 242 /// Return true if the size is a power-of-two number of bytes. 243 bool isRound() const { 244 if (isScalableVector()) 245 return false; 246 unsigned BitSize = getSizeInBits(); 247 return BitSize >= 8 && !(BitSize & (BitSize - 1)); 248 } 249 250 /// Return true if this has the same number of bits as VT. 251 bool bitsEq(EVT VT) const { 252 if (EVT::operator==(VT)) return true; 253 return getSizeInBits() == VT.getSizeInBits(); 254 } 255 256 /// Return true if we know at compile time this has more bits than VT. 257 bool knownBitsGT(EVT VT) const { 258 return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits()); 259 } 260 261 /// Return true if we know at compile time this has more than or the same 262 /// bits as VT. 263 bool knownBitsGE(EVT VT) const { 264 return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits()); 265 } 266 267 /// Return true if we know at compile time this has fewer bits than VT. 268 bool knownBitsLT(EVT VT) const { 269 return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits()); 270 } 271 272 /// Return true if we know at compile time this has fewer than or the same 273 /// bits as VT. 274 bool knownBitsLE(EVT VT) const { 275 return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits()); 276 } 277 278 /// Return true if this has more bits than VT. 279 bool bitsGT(EVT VT) const { 280 if (EVT::operator==(VT)) return false; 281 assert(isScalableVector() == VT.isScalableVector() && 282 "Comparison between scalable and fixed types"); 283 return knownBitsGT(VT); 284 } 285 286 /// Return true if this has no less bits than VT. 287 bool bitsGE(EVT VT) const { 288 if (EVT::operator==(VT)) return true; 289 assert(isScalableVector() == VT.isScalableVector() && 290 "Comparison between scalable and fixed types"); 291 return knownBitsGE(VT); 292 } 293 294 /// Return true if this has less bits than VT. 295 bool bitsLT(EVT VT) const { 296 if (EVT::operator==(VT)) return false; 297 assert(isScalableVector() == VT.isScalableVector() && 298 "Comparison between scalable and fixed types"); 299 return knownBitsLT(VT); 300 } 301 302 /// Return true if this has no more bits than VT. 303 bool bitsLE(EVT VT) const { 304 if (EVT::operator==(VT)) return true; 305 assert(isScalableVector() == VT.isScalableVector() && 306 "Comparison between scalable and fixed types"); 307 return knownBitsLE(VT); 308 } 309 310 /// Return the SimpleValueType held in the specified simple EVT. 311 MVT getSimpleVT() const { 312 assert(isSimple() && "Expected a SimpleValueType!"); 313 return V; 314 } 315 316 /// If this is a vector type, return the element type, otherwise return 317 /// this. 318 EVT getScalarType() const { 319 return isVector() ? getVectorElementType() : *this; 320 } 321 322 /// Given a vector type, return the type of each element. 323 EVT getVectorElementType() const { 324 assert(isVector() && "Invalid vector type!"); 325 if (isSimple()) 326 return V.getVectorElementType(); 327 return getExtendedVectorElementType(); 328 } 329 330 /// Given a vector type, return the number of elements it contains. 331 unsigned getVectorNumElements() const { 332 assert(isVector() && "Invalid vector type!"); 333 334 if (isScalableVector()) 335 llvm::reportInvalidSizeRequest( 336 "Possible incorrect use of EVT::getVectorNumElements() for " 337 "scalable vector. Scalable flag may be dropped, use " 338 "EVT::getVectorElementCount() instead"); 339 340 return isSimple() ? V.getVectorNumElements() 341 : getExtendedVectorNumElements(); 342 } 343 344 // Given a (possibly scalable) vector type, return the ElementCount 345 ElementCount getVectorElementCount() const { 346 assert((isVector()) && "Invalid vector type!"); 347 if (isSimple()) 348 return V.getVectorElementCount(); 349 350 return getExtendedVectorElementCount(); 351 } 352 353 /// Given a vector type, return the minimum number of elements it contains. 354 unsigned getVectorMinNumElements() const { 355 return getVectorElementCount().getKnownMinValue(); 356 } 357 358 /// Given a RISCV vector tuple type, return the num_fields. 359 unsigned getRISCVVectorTupleNumFields() const { 360 return V.getRISCVVectorTupleNumFields(); 361 } 362 363 /// Return the size of the specified value type in bits. 364 /// 365 /// If the value type is a scalable vector type, the scalable property will 366 /// be set and the runtime size will be a positive integer multiple of the 367 /// base size. 368 TypeSize getSizeInBits() const { 369 if (isSimple()) 370 return V.getSizeInBits(); 371 return getExtendedSizeInBits(); 372 } 373 374 /// Return the size of the specified fixed width value type in bits. The 375 /// function will assert if the type is scalable. 376 uint64_t getFixedSizeInBits() const { 377 return getSizeInBits().getFixedValue(); 378 } 379 380 uint64_t getScalarSizeInBits() const { 381 return getScalarType().getSizeInBits().getFixedValue(); 382 } 383 384 /// Return the number of bytes overwritten by a store of the specified value 385 /// type. 386 /// 387 /// If the value type is a scalable vector type, the scalable property will 388 /// be set and the runtime size will be a positive integer multiple of the 389 /// base size. 390 TypeSize getStoreSize() const { 391 TypeSize BaseSize = getSizeInBits(); 392 return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()}; 393 } 394 395 // Return the number of bytes overwritten by a store of this value type or 396 // this value type's element type in the case of a vector. 397 uint64_t getScalarStoreSize() const { 398 return getScalarType().getStoreSize().getFixedValue(); 399 } 400 401 /// Return the number of bits overwritten by a store of the specified value 402 /// type. 403 /// 404 /// If the value type is a scalable vector type, the scalable property will 405 /// be set and the runtime size will be a positive integer multiple of the 406 /// base size. 407 TypeSize getStoreSizeInBits() const { 408 return getStoreSize() * 8; 409 } 410 411 /// Rounds the bit-width of the given integer EVT up to the nearest power of 412 /// two (and at least to eight), and returns the integer EVT with that 413 /// number of bits. 414 EVT getRoundIntegerType(LLVMContext &Context) const { 415 assert(isInteger() && !isVector() && "Invalid integer type!"); 416 unsigned BitWidth = getSizeInBits(); 417 if (BitWidth <= 8) 418 return EVT(MVT::i8); 419 return getIntegerVT(Context, llvm::bit_ceil(BitWidth)); 420 } 421 422 /// Finds the smallest simple value type that is greater than or equal to 423 /// half the width of this EVT. If no simple value type can be found, an 424 /// extended integer value type of half the size (rounded up) is returned. 425 EVT getHalfSizedIntegerVT(LLVMContext &Context) const { 426 assert(isInteger() && !isVector() && "Invalid integer type!"); 427 unsigned EVTSize = getSizeInBits(); 428 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE; 429 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) { 430 EVT HalfVT = EVT((MVT::SimpleValueType)IntVT); 431 if (HalfVT.getSizeInBits() * 2 >= EVTSize) 432 return HalfVT; 433 } 434 return getIntegerVT(Context, (EVTSize + 1) / 2); 435 } 436 437 /// Return a VT for an integer vector type with the size of the 438 /// elements doubled. The typed returned may be an extended type. 439 EVT widenIntegerVectorElementType(LLVMContext &Context) const { 440 EVT EltVT = getVectorElementType(); 441 EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits()); 442 return EVT::getVectorVT(Context, EltVT, getVectorElementCount()); 443 } 444 445 // Return a VT for a vector type with the same element type but 446 // half the number of elements. The type returned may be an 447 // extended type. 448 EVT getHalfNumVectorElementsVT(LLVMContext &Context) const { 449 EVT EltVT = getVectorElementType(); 450 auto EltCnt = getVectorElementCount(); 451 assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!"); 452 return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2)); 453 } 454 455 // Return a VT for a vector type with the same element type but 456 // double the number of elements. The type returned may be an 457 // extended type. 458 EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const { 459 EVT EltVT = getVectorElementType(); 460 auto EltCnt = getVectorElementCount(); 461 return EVT::getVectorVT(Context, EltVT, EltCnt * 2); 462 } 463 464 /// Returns true if the given vector is a power of 2. 465 bool isPow2VectorType() const { 466 unsigned NElts = getVectorMinNumElements(); 467 return !(NElts & (NElts - 1)); 468 } 469 470 /// Widens the length of the given vector EVT up to the nearest power of 2 471 /// and returns that type. 472 EVT getPow2VectorType(LLVMContext &Context) const { 473 if (!isPow2VectorType()) { 474 ElementCount NElts = getVectorElementCount(); 475 unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue()); 476 NElts = ElementCount::get(NewMinCount, NElts.isScalable()); 477 return EVT::getVectorVT(Context, getVectorElementType(), NElts); 478 } 479 else { 480 return *this; 481 } 482 } 483 484 /// This function returns value type as a string, e.g. "i32". 485 std::string getEVTString() const; 486 487 /// Support for debugging, callable in GDB: VT.dump() 488 void dump() const; 489 490 /// Implement operator<<. 491 void print(raw_ostream &OS) const { 492 OS << getEVTString(); 493 } 494 495 /// This method returns an LLVM type corresponding to the specified EVT. 496 /// For integer types, this returns an unsigned type. Note that this will 497 /// abort for types that cannot be represented. 498 Type *getTypeForEVT(LLVMContext &Context) const; 499 500 /// Return the value type corresponding to the specified type. 501 /// If HandleUnknown is true, unknown types are returned as Other, 502 /// otherwise they are invalid. 503 /// NB: This includes pointer types, which require a DataLayout to convert 504 /// to a concrete value type. 505 static EVT getEVT(Type *Ty, bool HandleUnknown = false); 506 507 intptr_t getRawBits() const { 508 if (isSimple()) 509 return V.SimpleTy; 510 else 511 return (intptr_t)(LLVMTy); 512 } 513 514 /// A meaningless but well-behaved order, useful for constructing 515 /// containers. 516 struct compareRawBits { 517 bool operator()(EVT L, EVT R) const { 518 if (L.V.SimpleTy == R.V.SimpleTy) 519 return L.LLVMTy < R.LLVMTy; 520 else 521 return L.V.SimpleTy < R.V.SimpleTy; 522 } 523 }; 524 525 /// Returns an APFloat semantics tag appropriate for the value type. If this 526 /// is a vector type, the element semantics are returned. 527 const fltSemantics &getFltSemantics() const; 528 529 private: 530 // Methods for handling the Extended-type case in functions above. 531 // These are all out-of-line to prevent users of this header file 532 // from having a dependency on Type.h. 533 EVT changeExtendedTypeToInteger() const; 534 EVT changeExtendedVectorElementType(EVT EltVT) const; 535 EVT changeExtendedVectorElementTypeToInteger() const; 536 static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth); 537 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements, 538 bool IsScalable); 539 static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT, 540 ElementCount EC); 541 bool isExtendedFloatingPoint() const LLVM_READONLY; 542 bool isExtendedInteger() const LLVM_READONLY; 543 bool isExtendedScalarInteger() const LLVM_READONLY; 544 bool isExtendedVector() const LLVM_READONLY; 545 bool isExtended16BitVector() const LLVM_READONLY; 546 bool isExtended32BitVector() const LLVM_READONLY; 547 bool isExtended64BitVector() const LLVM_READONLY; 548 bool isExtended128BitVector() const LLVM_READONLY; 549 bool isExtended256BitVector() const LLVM_READONLY; 550 bool isExtended512BitVector() const LLVM_READONLY; 551 bool isExtended1024BitVector() const LLVM_READONLY; 552 bool isExtended2048BitVector() const LLVM_READONLY; 553 bool isExtendedFixedLengthVector() const LLVM_READONLY; 554 bool isExtendedScalableVector() const LLVM_READONLY; 555 EVT getExtendedVectorElementType() const; 556 unsigned getExtendedVectorNumElements() const LLVM_READONLY; 557 ElementCount getExtendedVectorElementCount() const LLVM_READONLY; 558 TypeSize getExtendedSizeInBits() const LLVM_READONLY; 559 }; 560 561 inline raw_ostream &operator<<(raw_ostream &OS, const EVT &V) { 562 V.print(OS); 563 return OS; 564 } 565 } // end namespace llvm 566 567 #endif // LLVM_CODEGEN_VALUETYPES_H 568