1 //===- Support/MachineValueType.h - Machine-Level types ---------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the set of machine-level target independent types which 11 // legal values in the code generator use. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_SUPPORT_MACHINEVALUETYPE_H 16 #define LLVM_SUPPORT_MACHINEVALUETYPE_H 17 18 #include "llvm/ADT/iterator_range.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include "llvm/Support/MathExtras.h" 21 #include <cassert> 22 23 namespace llvm { 24 25 class Type; 26 27 /// Machine Value Type. Every type that is supported natively by some 28 /// processor targeted by LLVM occurs here. This means that any legal value 29 /// type can be represented by an MVT. 30 class MVT { 31 public: 32 enum SimpleValueType : uint8_t { 33 // Simple value types that aren't explicitly part of this enumeration 34 // are considered extended value types. 35 INVALID_SIMPLE_VALUE_TYPE = 0, 36 37 // If you change this numbering, you must change the values in 38 // ValueTypes.td as well! 39 Other = 1, // This is a non-standard value 40 i1 = 2, // This is a 1 bit integer value 41 i8 = 3, // This is an 8 bit integer value 42 i16 = 4, // This is a 16 bit integer value 43 i32 = 5, // This is a 32 bit integer value 44 i64 = 6, // This is a 64 bit integer value 45 i128 = 7, // This is a 128 bit integer value 46 47 FIRST_INTEGER_VALUETYPE = i1, 48 LAST_INTEGER_VALUETYPE = i128, 49 50 f16 = 8, // This is a 16 bit floating point value 51 f32 = 9, // This is a 32 bit floating point value 52 f64 = 10, // This is a 64 bit floating point value 53 f80 = 11, // This is a 80 bit floating point value 54 f128 = 12, // This is a 128 bit floating point value 55 ppcf128 = 13, // This is a PPC 128-bit floating point value 56 57 FIRST_FP_VALUETYPE = f16, 58 LAST_FP_VALUETYPE = ppcf128, 59 60 v1i1 = 14, // 1 x i1 61 v2i1 = 15, // 2 x i1 62 v4i1 = 16, // 4 x i1 63 v8i1 = 17, // 8 x i1 64 v16i1 = 18, // 16 x i1 65 v32i1 = 19, // 32 x i1 66 v64i1 = 20, // 64 x i1 67 v128i1 = 21, // 128 x i1 68 v512i1 = 22, // 512 x i1 69 v1024i1 = 23, // 1024 x i1 70 71 v1i8 = 24, // 1 x i8 72 v2i8 = 25, // 2 x i8 73 v4i8 = 26, // 4 x i8 74 v8i8 = 27, // 8 x i8 75 v16i8 = 28, // 16 x i8 76 v32i8 = 29, // 32 x i8 77 v64i8 = 30, // 64 x i8 78 v128i8 = 31, //128 x i8 79 v256i8 = 32, //256 x i8 80 81 v1i16 = 33, // 1 x i16 82 v2i16 = 34, // 2 x i16 83 v4i16 = 35, // 4 x i16 84 v8i16 = 36, // 8 x i16 85 v16i16 = 37, // 16 x i16 86 v32i16 = 38, // 32 x i16 87 v64i16 = 39, // 64 x i16 88 v128i16 = 40, //128 x i16 89 90 v1i32 = 41, // 1 x i32 91 v2i32 = 42, // 2 x i32 92 v4i32 = 43, // 4 x i32 93 v8i32 = 44, // 8 x i32 94 v16i32 = 45, // 16 x i32 95 v32i32 = 46, // 32 x i32 96 v64i32 = 47, // 64 x i32 97 98 v1i64 = 48, // 1 x i64 99 v2i64 = 49, // 2 x i64 100 v4i64 = 50, // 4 x i64 101 v8i64 = 51, // 8 x i64 102 v16i64 = 52, // 16 x i64 103 v32i64 = 53, // 32 x i64 104 105 v1i128 = 54, // 1 x i128 106 107 // Scalable integer types 108 nxv1i1 = 55, // n x 1 x i1 109 nxv2i1 = 56, // n x 2 x i1 110 nxv4i1 = 57, // n x 4 x i1 111 nxv8i1 = 58, // n x 8 x i1 112 nxv16i1 = 59, // n x 16 x i1 113 nxv32i1 = 60, // n x 32 x i1 114 115 nxv1i8 = 61, // n x 1 x i8 116 nxv2i8 = 62, // n x 2 x i8 117 nxv4i8 = 63, // n x 4 x i8 118 nxv8i8 = 64, // n x 8 x i8 119 nxv16i8 = 65, // n x 16 x i8 120 nxv32i8 = 66, // n x 32 x i8 121 122 nxv1i16 = 67, // n x 1 x i16 123 nxv2i16 = 68, // n x 2 x i16 124 nxv4i16 = 69, // n x 4 x i16 125 nxv8i16 = 70, // n x 8 x i16 126 nxv16i16 = 71, // n x 16 x i16 127 nxv32i16 = 72, // n x 32 x i16 128 129 nxv1i32 = 73, // n x 1 x i32 130 nxv2i32 = 74, // n x 2 x i32 131 nxv4i32 = 75, // n x 4 x i32 132 nxv8i32 = 76, // n x 8 x i32 133 nxv16i32 = 77, // n x 16 x i32 134 nxv32i32 = 78, // n x 32 x i32 135 136 nxv1i64 = 79, // n x 1 x i64 137 nxv2i64 = 80, // n x 2 x i64 138 nxv4i64 = 81, // n x 4 x i64 139 nxv8i64 = 82, // n x 8 x i64 140 nxv16i64 = 83, // n x 16 x i64 141 nxv32i64 = 84, // n x 32 x i64 142 143 FIRST_INTEGER_VECTOR_VALUETYPE = v1i1, 144 LAST_INTEGER_VECTOR_VALUETYPE = nxv32i64, 145 146 FIRST_INTEGER_SCALABLE_VALUETYPE = nxv1i1, 147 LAST_INTEGER_SCALABLE_VALUETYPE = nxv32i64, 148 149 v2f16 = 85, // 2 x f16 150 v4f16 = 86, // 4 x f16 151 v8f16 = 87, // 8 x f16 152 v1f32 = 88, // 1 x f32 153 v2f32 = 89, // 2 x f32 154 v4f32 = 90, // 4 x f32 155 v8f32 = 91, // 8 x f32 156 v16f32 = 92, // 16 x f32 157 v1f64 = 93, // 1 x f64 158 v2f64 = 94, // 2 x f64 159 v4f64 = 95, // 4 x f64 160 v8f64 = 96, // 8 x f64 161 162 nxv2f16 = 97, // n x 2 x f16 163 nxv4f16 = 98, // n x 4 x f16 164 nxv8f16 = 99, // n x 8 x f16 165 nxv1f32 = 100, // n x 1 x f32 166 nxv2f32 = 101, // n x 2 x f32 167 nxv4f32 = 102, // n x 4 x f32 168 nxv8f32 = 103, // n x 8 x f32 169 nxv16f32 = 104, // n x 16 x f32 170 nxv1f64 = 105, // n x 1 x f64 171 nxv2f64 = 106, // n x 2 x f64 172 nxv4f64 = 107, // n x 4 x f64 173 nxv8f64 = 108, // n x 8 x f64 174 175 FIRST_FP_VECTOR_VALUETYPE = v2f16, 176 LAST_FP_VECTOR_VALUETYPE = nxv8f64, 177 178 FIRST_FP_SCALABLE_VALUETYPE = nxv2f16, 179 LAST_FP_SCALABLE_VALUETYPE = nxv8f64, 180 181 FIRST_VECTOR_VALUETYPE = v1i1, 182 LAST_VECTOR_VALUETYPE = nxv8f64, 183 184 x86mmx = 109, // This is an X86 MMX value 185 186 Glue = 110, // This glues nodes together during pre-RA sched 187 188 isVoid = 111, // This has no value 189 190 Untyped = 112, // This value takes a register, but has 191 // unspecified type. The register class 192 // will be determined by the opcode. 193 194 ExceptRef = 113, // WebAssembly's except_ref type 195 196 FIRST_VALUETYPE = 1, // This is always the beginning of the list. 197 LAST_VALUETYPE = 114, // This always remains at the end of the list. 198 199 // This is the current maximum for LAST_VALUETYPE. 200 // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors 201 // This value must be a multiple of 32. 202 MAX_ALLOWED_VALUETYPE = 128, 203 204 // A value of type llvm::TokenTy 205 token = 248, 206 207 // This is MDNode or MDString. 208 Metadata = 249, 209 210 // An int value the size of the pointer of the current 211 // target to any address space. This must only be used internal to 212 // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR. 213 iPTRAny = 250, 214 215 // A vector with any length and element size. This is used 216 // for intrinsics that have overloadings based on vector types. 217 // This is only for tblgen's consumption! 218 vAny = 251, 219 220 // Any floating-point or vector floating-point value. This is used 221 // for intrinsics that have overloadings based on floating-point types. 222 // This is only for tblgen's consumption! 223 fAny = 252, 224 225 // An integer or vector integer value of any bit width. This is 226 // used for intrinsics that have overloadings based on integer bit widths. 227 // This is only for tblgen's consumption! 228 iAny = 253, 229 230 // An int value the size of the pointer of the current 231 // target. This should only be used internal to tblgen! 232 iPTR = 254, 233 234 // Any type. This is used for intrinsics that have overloadings. 235 // This is only for tblgen's consumption! 236 Any = 255 237 }; 238 239 SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE; 240 241 // A class to represent the number of elements in a vector 242 // 243 // For fixed-length vectors, the total number of elements is equal to 'Min' 244 // For scalable vectors, the total number of elements is a multiple of 'Min' 245 class ElementCount { 246 public: 247 unsigned Min; 248 bool Scalable; 249 ElementCount(unsigned Min,bool Scalable)250 ElementCount(unsigned Min, bool Scalable) 251 : Min(Min), Scalable(Scalable) {} 252 253 ElementCount operator*(unsigned RHS) { 254 return { Min * RHS, Scalable }; 255 } 256 257 ElementCount& operator*=(unsigned RHS) { 258 Min *= RHS; 259 return *this; 260 } 261 262 ElementCount operator/(unsigned RHS) { 263 return { Min / RHS, Scalable }; 264 } 265 266 ElementCount& operator/=(unsigned RHS) { 267 Min /= RHS; 268 return *this; 269 } 270 271 bool operator==(const ElementCount& RHS) { 272 return Min == RHS.Min && Scalable == RHS.Scalable; 273 } 274 }; 275 276 constexpr MVT() = default; MVT(SimpleValueType SVT)277 constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {} 278 279 bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; } 280 bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; } 281 bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; } 282 bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; } 283 bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; } 284 bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; } 285 286 /// Return true if this is a valid simple valuetype. isValid()287 bool isValid() const { 288 return (SimpleTy >= MVT::FIRST_VALUETYPE && 289 SimpleTy < MVT::LAST_VALUETYPE); 290 } 291 292 /// Return true if this is a FP or a vector FP type. isFloatingPoint()293 bool isFloatingPoint() const { 294 return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE && 295 SimpleTy <= MVT::LAST_FP_VALUETYPE) || 296 (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE && 297 SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE)); 298 } 299 300 /// Return true if this is an integer or a vector integer type. isInteger()301 bool isInteger() const { 302 return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && 303 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) || 304 (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE && 305 SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE)); 306 } 307 308 /// Return true if this is an integer, not including vectors. isScalarInteger()309 bool isScalarInteger() const { 310 return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && 311 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE); 312 } 313 314 /// Return true if this is a vector value type. isVector()315 bool isVector() const { 316 return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE && 317 SimpleTy <= MVT::LAST_VECTOR_VALUETYPE); 318 } 319 320 /// Return true if this is a vector value type where the 321 /// runtime length is machine dependent isScalableVector()322 bool isScalableVector() const { 323 return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE && 324 SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VALUETYPE) || 325 (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE && 326 SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE)); 327 } 328 329 /// Return true if this is a 16-bit vector type. is16BitVector()330 bool is16BitVector() const { 331 return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 || 332 SimpleTy == MVT::v16i1); 333 } 334 335 /// Return true if this is a 32-bit vector type. is32BitVector()336 bool is32BitVector() const { 337 return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8 || 338 SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 || 339 SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32); 340 } 341 342 /// Return true if this is a 64-bit vector type. is64BitVector()343 bool is64BitVector() const { 344 return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8 || 345 SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 || 346 SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 || 347 SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64); 348 } 349 350 /// Return true if this is a 128-bit vector type. is128BitVector()351 bool is128BitVector() const { 352 return (SimpleTy == MVT::v128i1 || SimpleTy == MVT::v16i8 || 353 SimpleTy == MVT::v8i16 || SimpleTy == MVT::v4i32 || 354 SimpleTy == MVT::v2i64 || SimpleTy == MVT::v1i128 || 355 SimpleTy == MVT::v8f16 || SimpleTy == MVT::v4f32 || 356 SimpleTy == MVT::v2f64); 357 } 358 359 /// Return true if this is a 256-bit vector type. is256BitVector()360 bool is256BitVector() const { 361 return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 || 362 SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 || 363 SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64); 364 } 365 366 /// Return true if this is a 512-bit vector type. is512BitVector()367 bool is512BitVector() const { 368 return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64 || 369 SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8 || 370 SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 || 371 SimpleTy == MVT::v8i64); 372 } 373 374 /// Return true if this is a 1024-bit vector type. is1024BitVector()375 bool is1024BitVector() const { 376 return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 || 377 SimpleTy == MVT::v64i16 || SimpleTy == MVT::v32i32 || 378 SimpleTy == MVT::v16i64); 379 } 380 381 /// Return true if this is a 2048-bit vector type. is2048BitVector()382 bool is2048BitVector() const { 383 return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 || 384 SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64); 385 } 386 387 /// Return true if this is an overloaded type for TableGen. isOverloaded()388 bool isOverloaded() const { 389 return (SimpleTy==MVT::Any || 390 SimpleTy==MVT::iAny || SimpleTy==MVT::fAny || 391 SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny); 392 } 393 394 /// Returns true if the given vector is a power of 2. isPow2VectorType()395 bool isPow2VectorType() const { 396 unsigned NElts = getVectorNumElements(); 397 return !(NElts & (NElts - 1)); 398 } 399 400 /// Widens the length of the given vector MVT up to the nearest power of 2 401 /// and returns that type. getPow2VectorType()402 MVT getPow2VectorType() const { 403 if (isPow2VectorType()) 404 return *this; 405 406 unsigned NElts = getVectorNumElements(); 407 unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts); 408 return MVT::getVectorVT(getVectorElementType(), Pow2NElts); 409 } 410 411 /// If this is a vector, return the element type, otherwise return this. getScalarType()412 MVT getScalarType() const { 413 return isVector() ? getVectorElementType() : *this; 414 } 415 getVectorElementType()416 MVT getVectorElementType() const { 417 switch (SimpleTy) { 418 default: 419 llvm_unreachable("Not a vector MVT!"); 420 case v1i1: 421 case v2i1: 422 case v4i1: 423 case v8i1: 424 case v16i1: 425 case v32i1: 426 case v64i1: 427 case v128i1: 428 case v512i1: 429 case v1024i1: 430 case nxv1i1: 431 case nxv2i1: 432 case nxv4i1: 433 case nxv8i1: 434 case nxv16i1: 435 case nxv32i1: return i1; 436 case v1i8: 437 case v2i8: 438 case v4i8: 439 case v8i8: 440 case v16i8: 441 case v32i8: 442 case v64i8: 443 case v128i8: 444 case v256i8: 445 case nxv1i8: 446 case nxv2i8: 447 case nxv4i8: 448 case nxv8i8: 449 case nxv16i8: 450 case nxv32i8: return i8; 451 case v1i16: 452 case v2i16: 453 case v4i16: 454 case v8i16: 455 case v16i16: 456 case v32i16: 457 case v64i16: 458 case v128i16: 459 case nxv1i16: 460 case nxv2i16: 461 case nxv4i16: 462 case nxv8i16: 463 case nxv16i16: 464 case nxv32i16: return i16; 465 case v1i32: 466 case v2i32: 467 case v4i32: 468 case v8i32: 469 case v16i32: 470 case v32i32: 471 case v64i32: 472 case nxv1i32: 473 case nxv2i32: 474 case nxv4i32: 475 case nxv8i32: 476 case nxv16i32: 477 case nxv32i32: return i32; 478 case v1i64: 479 case v2i64: 480 case v4i64: 481 case v8i64: 482 case v16i64: 483 case v32i64: 484 case nxv1i64: 485 case nxv2i64: 486 case nxv4i64: 487 case nxv8i64: 488 case nxv16i64: 489 case nxv32i64: return i64; 490 case v1i128: return i128; 491 case v2f16: 492 case v4f16: 493 case v8f16: 494 case nxv2f16: 495 case nxv4f16: 496 case nxv8f16: return f16; 497 case v1f32: 498 case v2f32: 499 case v4f32: 500 case v8f32: 501 case v16f32: 502 case nxv1f32: 503 case nxv2f32: 504 case nxv4f32: 505 case nxv8f32: 506 case nxv16f32: return f32; 507 case v1f64: 508 case v2f64: 509 case v4f64: 510 case v8f64: 511 case nxv1f64: 512 case nxv2f64: 513 case nxv4f64: 514 case nxv8f64: return f64; 515 } 516 } 517 getVectorNumElements()518 unsigned getVectorNumElements() const { 519 switch (SimpleTy) { 520 default: 521 llvm_unreachable("Not a vector MVT!"); 522 case v1024i1: return 1024; 523 case v512i1: return 512; 524 case v256i8: return 256; 525 case v128i1: 526 case v128i8: 527 case v128i16: return 128; 528 case v64i1: 529 case v64i8: 530 case v64i16: 531 case v64i32: return 64; 532 case v32i1: 533 case v32i8: 534 case v32i16: 535 case v32i32: 536 case v32i64: 537 case nxv32i1: 538 case nxv32i8: 539 case nxv32i16: 540 case nxv32i32: 541 case nxv32i64: return 32; 542 case v16i1: 543 case v16i8: 544 case v16i16: 545 case v16i32: 546 case v16i64: 547 case v16f32: 548 case nxv16i1: 549 case nxv16i8: 550 case nxv16i16: 551 case nxv16i32: 552 case nxv16i64: 553 case nxv16f32: return 16; 554 case v8i1: 555 case v8i8: 556 case v8i16: 557 case v8i32: 558 case v8i64: 559 case v8f16: 560 case v8f32: 561 case v8f64: 562 case nxv8i1: 563 case nxv8i8: 564 case nxv8i16: 565 case nxv8i32: 566 case nxv8i64: 567 case nxv8f16: 568 case nxv8f32: 569 case nxv8f64: return 8; 570 case v4i1: 571 case v4i8: 572 case v4i16: 573 case v4i32: 574 case v4i64: 575 case v4f16: 576 case v4f32: 577 case v4f64: 578 case nxv4i1: 579 case nxv4i8: 580 case nxv4i16: 581 case nxv4i32: 582 case nxv4i64: 583 case nxv4f16: 584 case nxv4f32: 585 case nxv4f64: return 4; 586 case v2i1: 587 case v2i8: 588 case v2i16: 589 case v2i32: 590 case v2i64: 591 case v2f16: 592 case v2f32: 593 case v2f64: 594 case nxv2i1: 595 case nxv2i8: 596 case nxv2i16: 597 case nxv2i32: 598 case nxv2i64: 599 case nxv2f16: 600 case nxv2f32: 601 case nxv2f64: return 2; 602 case v1i1: 603 case v1i8: 604 case v1i16: 605 case v1i32: 606 case v1i64: 607 case v1i128: 608 case v1f32: 609 case v1f64: 610 case nxv1i1: 611 case nxv1i8: 612 case nxv1i16: 613 case nxv1i32: 614 case nxv1i64: 615 case nxv1f32: 616 case nxv1f64: return 1; 617 } 618 } 619 getVectorElementCount()620 MVT::ElementCount getVectorElementCount() const { 621 return { getVectorNumElements(), isScalableVector() }; 622 } 623 getSizeInBits()624 unsigned getSizeInBits() const { 625 switch (SimpleTy) { 626 default: 627 llvm_unreachable("getSizeInBits called on extended MVT."); 628 case Other: 629 llvm_unreachable("Value type is non-standard value, Other."); 630 case iPTR: 631 llvm_unreachable("Value type size is target-dependent. Ask TLI."); 632 case iPTRAny: 633 case iAny: 634 case fAny: 635 case vAny: 636 case Any: 637 llvm_unreachable("Value type is overloaded."); 638 case token: 639 llvm_unreachable("Token type is a sentinel that cannot be used " 640 "in codegen and has no size"); 641 case Metadata: 642 llvm_unreachable("Value type is metadata."); 643 case i1: 644 case v1i1: 645 case nxv1i1: return 1; 646 case v2i1: 647 case nxv2i1: return 2; 648 case v4i1: 649 case nxv4i1: return 4; 650 case i8 : 651 case v1i8: 652 case v8i1: 653 case nxv1i8: 654 case nxv8i1: return 8; 655 case i16 : 656 case f16: 657 case v16i1: 658 case v2i8: 659 case v1i16: 660 case nxv16i1: 661 case nxv2i8: 662 case nxv1i16: return 16; 663 case f32 : 664 case i32 : 665 case v32i1: 666 case v4i8: 667 case v2i16: 668 case v2f16: 669 case v1f32: 670 case v1i32: 671 case nxv32i1: 672 case nxv4i8: 673 case nxv2i16: 674 case nxv1i32: 675 case nxv2f16: 676 case nxv1f32: return 32; 677 case x86mmx: 678 case f64 : 679 case i64 : 680 case v64i1: 681 case v8i8: 682 case v4i16: 683 case v2i32: 684 case v1i64: 685 case v4f16: 686 case v2f32: 687 case v1f64: 688 case nxv8i8: 689 case nxv4i16: 690 case nxv2i32: 691 case nxv1i64: 692 case nxv4f16: 693 case nxv2f32: 694 case nxv1f64: return 64; 695 case f80 : return 80; 696 case f128: 697 case ppcf128: 698 case i128: 699 case v128i1: 700 case v16i8: 701 case v8i16: 702 case v4i32: 703 case v2i64: 704 case v1i128: 705 case v8f16: 706 case v4f32: 707 case v2f64: 708 case nxv16i8: 709 case nxv8i16: 710 case nxv4i32: 711 case nxv2i64: 712 case nxv8f16: 713 case nxv4f32: 714 case nxv2f64: return 128; 715 case v32i8: 716 case v16i16: 717 case v8i32: 718 case v4i64: 719 case v8f32: 720 case v4f64: 721 case nxv32i8: 722 case nxv16i16: 723 case nxv8i32: 724 case nxv4i64: 725 case nxv8f32: 726 case nxv4f64: return 256; 727 case v512i1: 728 case v64i8: 729 case v32i16: 730 case v16i32: 731 case v8i64: 732 case v16f32: 733 case v8f64: 734 case nxv32i16: 735 case nxv16i32: 736 case nxv8i64: 737 case nxv16f32: 738 case nxv8f64: return 512; 739 case v1024i1: 740 case v128i8: 741 case v64i16: 742 case v32i32: 743 case v16i64: 744 case nxv32i32: 745 case nxv16i64: return 1024; 746 case v256i8: 747 case v128i16: 748 case v64i32: 749 case v32i64: 750 case nxv32i64: return 2048; 751 case ExceptRef: return 0; // opaque type 752 } 753 } 754 getScalarSizeInBits()755 unsigned getScalarSizeInBits() const { 756 return getScalarType().getSizeInBits(); 757 } 758 759 /// Return the number of bytes overwritten by a store of the specified value 760 /// type. getStoreSize()761 unsigned getStoreSize() const { 762 return (getSizeInBits() + 7) / 8; 763 } 764 765 /// Return the number of bits overwritten by a store of the specified value 766 /// type. getStoreSizeInBits()767 unsigned getStoreSizeInBits() const { 768 return getStoreSize() * 8; 769 } 770 771 /// Return true if this has more bits than VT. bitsGT(MVT VT)772 bool bitsGT(MVT VT) const { 773 return getSizeInBits() > VT.getSizeInBits(); 774 } 775 776 /// Return true if this has no less bits than VT. bitsGE(MVT VT)777 bool bitsGE(MVT VT) const { 778 return getSizeInBits() >= VT.getSizeInBits(); 779 } 780 781 /// Return true if this has less bits than VT. bitsLT(MVT VT)782 bool bitsLT(MVT VT) const { 783 return getSizeInBits() < VT.getSizeInBits(); 784 } 785 786 /// Return true if this has no more bits than VT. bitsLE(MVT VT)787 bool bitsLE(MVT VT) const { 788 return getSizeInBits() <= VT.getSizeInBits(); 789 } 790 getFloatingPointVT(unsigned BitWidth)791 static MVT getFloatingPointVT(unsigned BitWidth) { 792 switch (BitWidth) { 793 default: 794 llvm_unreachable("Bad bit width!"); 795 case 16: 796 return MVT::f16; 797 case 32: 798 return MVT::f32; 799 case 64: 800 return MVT::f64; 801 case 80: 802 return MVT::f80; 803 case 128: 804 return MVT::f128; 805 } 806 } 807 getIntegerVT(unsigned BitWidth)808 static MVT getIntegerVT(unsigned BitWidth) { 809 switch (BitWidth) { 810 default: 811 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 812 case 1: 813 return MVT::i1; 814 case 8: 815 return MVT::i8; 816 case 16: 817 return MVT::i16; 818 case 32: 819 return MVT::i32; 820 case 64: 821 return MVT::i64; 822 case 128: 823 return MVT::i128; 824 } 825 } 826 getVectorVT(MVT VT,unsigned NumElements)827 static MVT getVectorVT(MVT VT, unsigned NumElements) { 828 switch (VT.SimpleTy) { 829 default: 830 break; 831 case MVT::i1: 832 if (NumElements == 1) return MVT::v1i1; 833 if (NumElements == 2) return MVT::v2i1; 834 if (NumElements == 4) return MVT::v4i1; 835 if (NumElements == 8) return MVT::v8i1; 836 if (NumElements == 16) return MVT::v16i1; 837 if (NumElements == 32) return MVT::v32i1; 838 if (NumElements == 64) return MVT::v64i1; 839 if (NumElements == 128) return MVT::v128i1; 840 if (NumElements == 512) return MVT::v512i1; 841 if (NumElements == 1024) return MVT::v1024i1; 842 break; 843 case MVT::i8: 844 if (NumElements == 1) return MVT::v1i8; 845 if (NumElements == 2) return MVT::v2i8; 846 if (NumElements == 4) return MVT::v4i8; 847 if (NumElements == 8) return MVT::v8i8; 848 if (NumElements == 16) return MVT::v16i8; 849 if (NumElements == 32) return MVT::v32i8; 850 if (NumElements == 64) return MVT::v64i8; 851 if (NumElements == 128) return MVT::v128i8; 852 if (NumElements == 256) return MVT::v256i8; 853 break; 854 case MVT::i16: 855 if (NumElements == 1) return MVT::v1i16; 856 if (NumElements == 2) return MVT::v2i16; 857 if (NumElements == 4) return MVT::v4i16; 858 if (NumElements == 8) return MVT::v8i16; 859 if (NumElements == 16) return MVT::v16i16; 860 if (NumElements == 32) return MVT::v32i16; 861 if (NumElements == 64) return MVT::v64i16; 862 if (NumElements == 128) return MVT::v128i16; 863 break; 864 case MVT::i32: 865 if (NumElements == 1) return MVT::v1i32; 866 if (NumElements == 2) return MVT::v2i32; 867 if (NumElements == 4) return MVT::v4i32; 868 if (NumElements == 8) return MVT::v8i32; 869 if (NumElements == 16) return MVT::v16i32; 870 if (NumElements == 32) return MVT::v32i32; 871 if (NumElements == 64) return MVT::v64i32; 872 break; 873 case MVT::i64: 874 if (NumElements == 1) return MVT::v1i64; 875 if (NumElements == 2) return MVT::v2i64; 876 if (NumElements == 4) return MVT::v4i64; 877 if (NumElements == 8) return MVT::v8i64; 878 if (NumElements == 16) return MVT::v16i64; 879 if (NumElements == 32) return MVT::v32i64; 880 break; 881 case MVT::i128: 882 if (NumElements == 1) return MVT::v1i128; 883 break; 884 case MVT::f16: 885 if (NumElements == 2) return MVT::v2f16; 886 if (NumElements == 4) return MVT::v4f16; 887 if (NumElements == 8) return MVT::v8f16; 888 break; 889 case MVT::f32: 890 if (NumElements == 1) return MVT::v1f32; 891 if (NumElements == 2) return MVT::v2f32; 892 if (NumElements == 4) return MVT::v4f32; 893 if (NumElements == 8) return MVT::v8f32; 894 if (NumElements == 16) return MVT::v16f32; 895 break; 896 case MVT::f64: 897 if (NumElements == 1) return MVT::v1f64; 898 if (NumElements == 2) return MVT::v2f64; 899 if (NumElements == 4) return MVT::v4f64; 900 if (NumElements == 8) return MVT::v8f64; 901 break; 902 } 903 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 904 } 905 getScalableVectorVT(MVT VT,unsigned NumElements)906 static MVT getScalableVectorVT(MVT VT, unsigned NumElements) { 907 switch(VT.SimpleTy) { 908 default: 909 break; 910 case MVT::i1: 911 if (NumElements == 1) return MVT::nxv1i1; 912 if (NumElements == 2) return MVT::nxv2i1; 913 if (NumElements == 4) return MVT::nxv4i1; 914 if (NumElements == 8) return MVT::nxv8i1; 915 if (NumElements == 16) return MVT::nxv16i1; 916 if (NumElements == 32) return MVT::nxv32i1; 917 break; 918 case MVT::i8: 919 if (NumElements == 1) return MVT::nxv1i8; 920 if (NumElements == 2) return MVT::nxv2i8; 921 if (NumElements == 4) return MVT::nxv4i8; 922 if (NumElements == 8) return MVT::nxv8i8; 923 if (NumElements == 16) return MVT::nxv16i8; 924 if (NumElements == 32) return MVT::nxv32i8; 925 break; 926 case MVT::i16: 927 if (NumElements == 1) return MVT::nxv1i16; 928 if (NumElements == 2) return MVT::nxv2i16; 929 if (NumElements == 4) return MVT::nxv4i16; 930 if (NumElements == 8) return MVT::nxv8i16; 931 if (NumElements == 16) return MVT::nxv16i16; 932 if (NumElements == 32) return MVT::nxv32i16; 933 break; 934 case MVT::i32: 935 if (NumElements == 1) return MVT::nxv1i32; 936 if (NumElements == 2) return MVT::nxv2i32; 937 if (NumElements == 4) return MVT::nxv4i32; 938 if (NumElements == 8) return MVT::nxv8i32; 939 if (NumElements == 16) return MVT::nxv16i32; 940 if (NumElements == 32) return MVT::nxv32i32; 941 break; 942 case MVT::i64: 943 if (NumElements == 1) return MVT::nxv1i64; 944 if (NumElements == 2) return MVT::nxv2i64; 945 if (NumElements == 4) return MVT::nxv4i64; 946 if (NumElements == 8) return MVT::nxv8i64; 947 if (NumElements == 16) return MVT::nxv16i64; 948 if (NumElements == 32) return MVT::nxv32i64; 949 break; 950 case MVT::f16: 951 if (NumElements == 2) return MVT::nxv2f16; 952 if (NumElements == 4) return MVT::nxv4f16; 953 if (NumElements == 8) return MVT::nxv8f16; 954 break; 955 case MVT::f32: 956 if (NumElements == 1) return MVT::nxv1f32; 957 if (NumElements == 2) return MVT::nxv2f32; 958 if (NumElements == 4) return MVT::nxv4f32; 959 if (NumElements == 8) return MVT::nxv8f32; 960 if (NumElements == 16) return MVT::nxv16f32; 961 break; 962 case MVT::f64: 963 if (NumElements == 1) return MVT::nxv1f64; 964 if (NumElements == 2) return MVT::nxv2f64; 965 if (NumElements == 4) return MVT::nxv4f64; 966 if (NumElements == 8) return MVT::nxv8f64; 967 break; 968 } 969 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 970 } 971 getVectorVT(MVT VT,unsigned NumElements,bool IsScalable)972 static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) { 973 if (IsScalable) 974 return getScalableVectorVT(VT, NumElements); 975 return getVectorVT(VT, NumElements); 976 } 977 getVectorVT(MVT VT,MVT::ElementCount EC)978 static MVT getVectorVT(MVT VT, MVT::ElementCount EC) { 979 if (EC.Scalable) 980 return getScalableVectorVT(VT, EC.Min); 981 return getVectorVT(VT, EC.Min); 982 } 983 984 /// Return the value type corresponding to the specified type. This returns 985 /// all pointers as iPTR. If HandleUnknown is true, unknown types are 986 /// returned as Other, otherwise they are invalid. 987 static MVT getVT(Type *Ty, bool HandleUnknown = false); 988 989 private: 990 /// A simple iterator over the MVT::SimpleValueType enum. 991 struct mvt_iterator { 992 SimpleValueType VT; 993 mvt_iteratormvt_iterator994 mvt_iterator(SimpleValueType VT) : VT(VT) {} 995 996 MVT operator*() const { return VT; } 997 bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; } 998 999 mvt_iterator& operator++() { 1000 VT = (MVT::SimpleValueType)((int)VT + 1); 1001 assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE && 1002 "MVT iterator overflowed."); 1003 return *this; 1004 } 1005 }; 1006 1007 /// A range of the MVT::SimpleValueType enum. 1008 using mvt_range = iterator_range<mvt_iterator>; 1009 1010 public: 1011 /// SimpleValueType Iteration 1012 /// @{ all_valuetypes()1013 static mvt_range all_valuetypes() { 1014 return mvt_range(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE); 1015 } 1016 integer_valuetypes()1017 static mvt_range integer_valuetypes() { 1018 return mvt_range(MVT::FIRST_INTEGER_VALUETYPE, 1019 (MVT::SimpleValueType)(MVT::LAST_INTEGER_VALUETYPE + 1)); 1020 } 1021 fp_valuetypes()1022 static mvt_range fp_valuetypes() { 1023 return mvt_range(MVT::FIRST_FP_VALUETYPE, 1024 (MVT::SimpleValueType)(MVT::LAST_FP_VALUETYPE + 1)); 1025 } 1026 vector_valuetypes()1027 static mvt_range vector_valuetypes() { 1028 return mvt_range(MVT::FIRST_VECTOR_VALUETYPE, 1029 (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1)); 1030 } 1031 integer_vector_valuetypes()1032 static mvt_range integer_vector_valuetypes() { 1033 return mvt_range( 1034 MVT::FIRST_INTEGER_VECTOR_VALUETYPE, 1035 (MVT::SimpleValueType)(MVT::LAST_INTEGER_VECTOR_VALUETYPE + 1)); 1036 } 1037 fp_vector_valuetypes()1038 static mvt_range fp_vector_valuetypes() { 1039 return mvt_range( 1040 MVT::FIRST_FP_VECTOR_VALUETYPE, 1041 (MVT::SimpleValueType)(MVT::LAST_FP_VECTOR_VALUETYPE + 1)); 1042 } 1043 integer_scalable_vector_valuetypes()1044 static mvt_range integer_scalable_vector_valuetypes() { 1045 return mvt_range(MVT::FIRST_INTEGER_SCALABLE_VALUETYPE, 1046 (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VALUETYPE + 1)); 1047 } 1048 fp_scalable_vector_valuetypes()1049 static mvt_range fp_scalable_vector_valuetypes() { 1050 return mvt_range(MVT::FIRST_FP_SCALABLE_VALUETYPE, 1051 (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VALUETYPE + 1)); 1052 } 1053 /// @} 1054 }; 1055 1056 } // end namespace llvm 1057 1058 #endif // LLVM_CODEGEN_MACHINEVALUETYPE_H 1059