1//===- CodeGen/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_CODEGEN_MACHINEVALUETYPE_H 16#define LLVM_CODEGEN_MACHINEVALUETYPE_H 17 18#include "llvm/Support/ErrorHandling.h" 19#include "llvm/Support/MathExtras.h" 20 21namespace llvm { 22 23 class Type; 24 25 /// MVT - Machine Value Type. Every type that is supported natively by some 26 /// processor targeted by LLVM occurs here. This means that any legal value 27 /// type can be represented by an MVT. 28 class MVT { 29 public: 30 enum SimpleValueType { 31 // INVALID_SIMPLE_VALUE_TYPE - Simple value types less than zero are 32 // considered extended value types. 33 INVALID_SIMPLE_VALUE_TYPE = -1, 34 35 // If you change this numbering, you must change the values in 36 // ValueTypes.td as well! 37 Other = 0, // This is a non-standard value 38 i1 = 1, // This is a 1 bit integer value 39 i8 = 2, // This is an 8 bit integer value 40 i16 = 3, // This is a 16 bit integer value 41 i32 = 4, // This is a 32 bit integer value 42 i64 = 5, // This is a 64 bit integer value 43 i128 = 6, // This is a 128 bit integer value 44 45 FIRST_INTEGER_VALUETYPE = i1, 46 LAST_INTEGER_VALUETYPE = i128, 47 48 f16 = 7, // This is a 16 bit floating point value 49 f32 = 8, // This is a 32 bit floating point value 50 f64 = 9, // This is a 64 bit floating point value 51 f80 = 10, // This is a 80 bit floating point value 52 f128 = 11, // This is a 128 bit floating point value 53 ppcf128 = 12, // This is a PPC 128-bit floating point value 54 55 FIRST_FP_VALUETYPE = f16, 56 LAST_FP_VALUETYPE = ppcf128, 57 58 v2i1 = 13, // 2 x i1 59 v4i1 = 14, // 4 x i1 60 v8i1 = 15, // 8 x i1 61 v16i1 = 16, // 16 x i1 62 v32i1 = 17, // 32 x i1 63 v64i1 = 18, // 64 x i1 64 65 v1i8 = 19, // 1 x i8 66 v2i8 = 20, // 2 x i8 67 v4i8 = 21, // 4 x i8 68 v8i8 = 22, // 8 x i8 69 v16i8 = 23, // 16 x i8 70 v32i8 = 24, // 32 x i8 71 v64i8 = 25, // 64 x i8 72 v1i16 = 26, // 1 x i16 73 v2i16 = 27, // 2 x i16 74 v4i16 = 28, // 4 x i16 75 v8i16 = 29, // 8 x i16 76 v16i16 = 30, // 16 x i16 77 v32i16 = 31, // 32 x i16 78 v1i32 = 32, // 1 x i32 79 v2i32 = 33, // 2 x i32 80 v4i32 = 34, // 4 x i32 81 v8i32 = 35, // 8 x i32 82 v16i32 = 36, // 16 x i32 83 v1i64 = 37, // 1 x i64 84 v2i64 = 38, // 2 x i64 85 v4i64 = 39, // 4 x i64 86 v8i64 = 40, // 8 x i64 87 v16i64 = 41, // 16 x i64 88 89 FIRST_INTEGER_VECTOR_VALUETYPE = v2i1, 90 LAST_INTEGER_VECTOR_VALUETYPE = v16i64, 91 92 v2f16 = 42, // 2 x f16 93 v4f16 = 43, // 4 x f16 94 v8f16 = 44, // 8 x f16 95 v1f32 = 45, // 1 x f32 96 v2f32 = 46, // 2 x f32 97 v4f32 = 47, // 4 x f32 98 v8f32 = 48, // 8 x f32 99 v16f32 = 49, // 16 x f32 100 v1f64 = 50, // 1 x f64 101 v2f64 = 51, // 2 x f64 102 v4f64 = 52, // 4 x f64 103 v8f64 = 53, // 8 x f64 104 105 FIRST_FP_VECTOR_VALUETYPE = v2f16, 106 LAST_FP_VECTOR_VALUETYPE = v8f64, 107 108 FIRST_VECTOR_VALUETYPE = v2i1, 109 LAST_VECTOR_VALUETYPE = v8f64, 110 111 x86mmx = 54, // This is an X86 MMX value 112 113 Glue = 55, // This glues nodes together during pre-RA sched 114 115 isVoid = 56, // This has no value 116 117 Untyped = 57, // This value takes a register, but has 118 // unspecified type. The register class 119 // will be determined by the opcode. 120 121 LAST_VALUETYPE = 58, // This always remains at the end of the list. 122 123 // This is the current maximum for LAST_VALUETYPE. 124 // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors 125 // This value must be a multiple of 32. 126 MAX_ALLOWED_VALUETYPE = 64, 127 128 // Metadata - This is MDNode or MDString. 129 Metadata = 250, 130 131 // iPTRAny - An int value the size of the pointer of the current 132 // target to any address space. This must only be used internal to 133 // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR. 134 iPTRAny = 251, 135 136 // vAny - A vector with any length and element size. This is used 137 // for intrinsics that have overloadings based on vector types. 138 // This is only for tblgen's consumption! 139 vAny = 252, 140 141 // fAny - Any floating-point or vector floating-point value. This is used 142 // for intrinsics that have overloadings based on floating-point types. 143 // This is only for tblgen's consumption! 144 fAny = 253, 145 146 // iAny - An integer or vector integer value of any bit width. This is 147 // used for intrinsics that have overloadings based on integer bit widths. 148 // This is only for tblgen's consumption! 149 iAny = 254, 150 151 // iPTR - An int value the size of the pointer of the current 152 // target. This should only be used internal to tblgen! 153 iPTR = 255 154 }; 155 156 SimpleValueType SimpleTy; 157 158 MVT() : SimpleTy((SimpleValueType)(INVALID_SIMPLE_VALUE_TYPE)) {} 159 MVT(SimpleValueType SVT) : SimpleTy(SVT) { } 160 161 bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; } 162 bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; } 163 bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; } 164 bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; } 165 bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; } 166 bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; } 167 168 /// isFloatingPoint - Return true if this is a FP, or a vector FP type. 169 bool isFloatingPoint() const { 170 return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE && 171 SimpleTy <= MVT::LAST_FP_VALUETYPE) || 172 (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE && 173 SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE)); 174 } 175 176 /// isInteger - Return true if this is an integer, or a vector integer type. 177 bool isInteger() const { 178 return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && 179 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) || 180 (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE && 181 SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE)); 182 } 183 184 /// isVector - Return true if this is a vector value type. 185 bool isVector() const { 186 return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE && 187 SimpleTy <= MVT::LAST_VECTOR_VALUETYPE); 188 } 189 190 /// is16BitVector - Return true if this is a 16-bit vector type. 191 bool is16BitVector() const { 192 return (SimpleTy == MVT::v2i8 || SimpleTy == MVT::v1i16 || 193 SimpleTy == MVT::v16i1); 194 } 195 196 /// is32BitVector - Return true if this is a 32-bit vector type. 197 bool is32BitVector() const { 198 return (SimpleTy == MVT::v4i8 || SimpleTy == MVT::v2i16 || 199 SimpleTy == MVT::v1i32); 200 } 201 202 /// is64BitVector - Return true if this is a 64-bit vector type. 203 bool is64BitVector() const { 204 return (SimpleTy == MVT::v8i8 || SimpleTy == MVT::v4i16 || 205 SimpleTy == MVT::v2i32 || SimpleTy == MVT::v1i64 || 206 SimpleTy == MVT::v1f64 || SimpleTy == MVT::v2f32); 207 } 208 209 /// is128BitVector - Return true if this is a 128-bit vector type. 210 bool is128BitVector() const { 211 return (SimpleTy == MVT::v16i8 || SimpleTy == MVT::v8i16 || 212 SimpleTy == MVT::v4i32 || SimpleTy == MVT::v2i64 || 213 SimpleTy == MVT::v4f32 || SimpleTy == MVT::v2f64); 214 } 215 216 /// is256BitVector - Return true if this is a 256-bit vector type. 217 bool is256BitVector() const { 218 return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64 || 219 SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 || 220 SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64); 221 } 222 223 /// is512BitVector - Return true if this is a 512-bit vector type. 224 bool is512BitVector() const { 225 return (SimpleTy == MVT::v8f64 || SimpleTy == MVT::v16f32 || 226 SimpleTy == MVT::v64i8 || SimpleTy == MVT::v32i16 || 227 SimpleTy == MVT::v8i64 || SimpleTy == MVT::v16i32); 228 } 229 230 /// is1024BitVector - Return true if this is a 1024-bit vector type. 231 bool is1024BitVector() const { 232 return (SimpleTy == MVT::v16i64); 233 } 234 235 /// isOverloaded - Return true if this is an overloaded type for TableGen. 236 bool isOverloaded() const { 237 return (SimpleTy==MVT::iAny || SimpleTy==MVT::fAny || 238 SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny); 239 } 240 241 /// isPow2VectorType - Returns true if the given vector is a power of 2. 242 bool isPow2VectorType() const { 243 unsigned NElts = getVectorNumElements(); 244 return !(NElts & (NElts - 1)); 245 } 246 247 /// getPow2VectorType - Widens the length of the given vector MVT up to 248 /// the nearest power of 2 and returns that type. 249 MVT getPow2VectorType() const { 250 if (isPow2VectorType()) 251 return *this; 252 253 unsigned NElts = getVectorNumElements(); 254 unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts); 255 return MVT::getVectorVT(getVectorElementType(), Pow2NElts); 256 } 257 258 /// getScalarType - If this is a vector type, return the element type, 259 /// otherwise return this. 260 MVT getScalarType() const { 261 return isVector() ? getVectorElementType() : *this; 262 } 263 264 MVT getVectorElementType() const { 265 switch (SimpleTy) { 266 default: 267 llvm_unreachable("Not a vector MVT!"); 268 case v2i1 : 269 case v4i1 : 270 case v8i1 : 271 case v16i1 : 272 case v32i1 : 273 case v64i1: return i1; 274 case v1i8 : 275 case v2i8 : 276 case v4i8 : 277 case v8i8 : 278 case v16i8: 279 case v32i8: 280 case v64i8: return i8; 281 case v1i16: 282 case v2i16: 283 case v4i16: 284 case v8i16: 285 case v16i16: 286 case v32i16: return i16; 287 case v1i32: 288 case v2i32: 289 case v4i32: 290 case v8i32: 291 case v16i32: return i32; 292 case v1i64: 293 case v2i64: 294 case v4i64: 295 case v8i64: 296 case v16i64: return i64; 297 case v2f16: 298 case v4f16: 299 case v8f16: return f16; 300 case v1f32: 301 case v2f32: 302 case v4f32: 303 case v8f32: 304 case v16f32: return f32; 305 case v1f64: 306 case v2f64: 307 case v4f64: 308 case v8f64: return f64; 309 } 310 } 311 312 unsigned getVectorNumElements() const { 313 switch (SimpleTy) { 314 default: 315 llvm_unreachable("Not a vector MVT!"); 316 case v32i1: 317 case v32i8: 318 case v32i16: return 32; 319 case v64i1: 320 case v64i8: return 64; 321 case v16i1: 322 case v16i8: 323 case v16i16: 324 case v16i32: 325 case v16i64: 326 case v16f32: return 16; 327 case v8i1 : 328 case v8i8 : 329 case v8i16: 330 case v8i32: 331 case v8i64: 332 case v8f16: 333 case v8f32: 334 case v8f64: return 8; 335 case v4i1: 336 case v4i8: 337 case v4i16: 338 case v4i32: 339 case v4i64: 340 case v4f16: 341 case v4f32: 342 case v4f64: return 4; 343 case v2i1: 344 case v2i8: 345 case v2i16: 346 case v2i32: 347 case v2i64: 348 case v2f16: 349 case v2f32: 350 case v2f64: return 2; 351 case v1i8: 352 case v1i16: 353 case v1i32: 354 case v1i64: 355 case v1f32: 356 case v1f64: return 1; 357 } 358 } 359 360 unsigned getSizeInBits() const { 361 switch (SimpleTy) { 362 default: 363 llvm_unreachable("getSizeInBits called on extended MVT."); 364 case Other: 365 llvm_unreachable("Value type is non-standard value, Other."); 366 case iPTR: 367 llvm_unreachable("Value type size is target-dependent. Ask TLI."); 368 case iPTRAny: 369 case iAny: 370 case fAny: 371 case vAny: 372 llvm_unreachable("Value type is overloaded."); 373 case Metadata: 374 llvm_unreachable("Value type is metadata."); 375 case i1 : return 1; 376 case v2i1: return 2; 377 case v4i1: return 4; 378 case i8 : 379 case v1i8: 380 case v8i1: return 8; 381 case i16 : 382 case f16: 383 case v16i1: 384 case v2i8: 385 case v1i16: return 16; 386 case f32 : 387 case i32 : 388 case v32i1: 389 case v4i8: 390 case v2i16: 391 case v2f16: 392 case v1f32: 393 case v1i32: return 32; 394 case x86mmx: 395 case f64 : 396 case i64 : 397 case v64i1: 398 case v8i8: 399 case v4i16: 400 case v2i32: 401 case v1i64: 402 case v4f16: 403 case v2f32: 404 case v1f64: return 64; 405 case f80 : return 80; 406 case f128: 407 case ppcf128: 408 case i128: 409 case v16i8: 410 case v8i16: 411 case v4i32: 412 case v2i64: 413 case v8f16: 414 case v4f32: 415 case v2f64: return 128; 416 case v32i8: 417 case v16i16: 418 case v8i32: 419 case v4i64: 420 case v8f32: 421 case v4f64: return 256; 422 case v64i8: 423 case v32i16: 424 case v16i32: 425 case v8i64: 426 case v16f32: 427 case v8f64: return 512; 428 case v16i64:return 1024; 429 } 430 } 431 432 unsigned getScalarSizeInBits() const { 433 return getScalarType().getSizeInBits(); 434 } 435 436 /// getStoreSize - Return the number of bytes overwritten by a store 437 /// of the specified value type. 438 unsigned getStoreSize() const { 439 return (getSizeInBits() + 7) / 8; 440 } 441 442 /// getStoreSizeInBits - Return the number of bits overwritten by a store 443 /// of the specified value type. 444 unsigned getStoreSizeInBits() const { 445 return getStoreSize() * 8; 446 } 447 448 /// Return true if this has more bits than VT. 449 bool bitsGT(MVT VT) const { 450 return getSizeInBits() > VT.getSizeInBits(); 451 } 452 453 /// Return true if this has no less bits than VT. 454 bool bitsGE(MVT VT) const { 455 return getSizeInBits() >= VT.getSizeInBits(); 456 } 457 458 /// Return true if this has less bits than VT. 459 bool bitsLT(MVT VT) const { 460 return getSizeInBits() < VT.getSizeInBits(); 461 } 462 463 /// Return true if this has no more bits than VT. 464 bool bitsLE(MVT VT) const { 465 return getSizeInBits() <= VT.getSizeInBits(); 466 } 467 468 469 static MVT getFloatingPointVT(unsigned BitWidth) { 470 switch (BitWidth) { 471 default: 472 llvm_unreachable("Bad bit width!"); 473 case 16: 474 return MVT::f16; 475 case 32: 476 return MVT::f32; 477 case 64: 478 return MVT::f64; 479 case 80: 480 return MVT::f80; 481 case 128: 482 return MVT::f128; 483 } 484 } 485 486 static MVT getIntegerVT(unsigned BitWidth) { 487 switch (BitWidth) { 488 default: 489 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 490 case 1: 491 return MVT::i1; 492 case 8: 493 return MVT::i8; 494 case 16: 495 return MVT::i16; 496 case 32: 497 return MVT::i32; 498 case 64: 499 return MVT::i64; 500 case 128: 501 return MVT::i128; 502 } 503 } 504 505 static MVT getVectorVT(MVT VT, unsigned NumElements) { 506 switch (VT.SimpleTy) { 507 default: 508 break; 509 case MVT::i1: 510 if (NumElements == 2) return MVT::v2i1; 511 if (NumElements == 4) return MVT::v4i1; 512 if (NumElements == 8) return MVT::v8i1; 513 if (NumElements == 16) return MVT::v16i1; 514 if (NumElements == 32) return MVT::v32i1; 515 if (NumElements == 64) return MVT::v64i1; 516 break; 517 case MVT::i8: 518 if (NumElements == 1) return MVT::v1i8; 519 if (NumElements == 2) return MVT::v2i8; 520 if (NumElements == 4) return MVT::v4i8; 521 if (NumElements == 8) return MVT::v8i8; 522 if (NumElements == 16) return MVT::v16i8; 523 if (NumElements == 32) return MVT::v32i8; 524 if (NumElements == 64) return MVT::v64i8; 525 break; 526 case MVT::i16: 527 if (NumElements == 1) return MVT::v1i16; 528 if (NumElements == 2) return MVT::v2i16; 529 if (NumElements == 4) return MVT::v4i16; 530 if (NumElements == 8) return MVT::v8i16; 531 if (NumElements == 16) return MVT::v16i16; 532 if (NumElements == 32) return MVT::v32i16; 533 break; 534 case MVT::i32: 535 if (NumElements == 1) return MVT::v1i32; 536 if (NumElements == 2) return MVT::v2i32; 537 if (NumElements == 4) return MVT::v4i32; 538 if (NumElements == 8) return MVT::v8i32; 539 if (NumElements == 16) return MVT::v16i32; 540 break; 541 case MVT::i64: 542 if (NumElements == 1) return MVT::v1i64; 543 if (NumElements == 2) return MVT::v2i64; 544 if (NumElements == 4) return MVT::v4i64; 545 if (NumElements == 8) return MVT::v8i64; 546 if (NumElements == 16) return MVT::v16i64; 547 break; 548 case MVT::f16: 549 if (NumElements == 2) return MVT::v2f16; 550 if (NumElements == 4) return MVT::v4f16; 551 if (NumElements == 8) return MVT::v8f16; 552 break; 553 case MVT::f32: 554 if (NumElements == 1) return MVT::v1f32; 555 if (NumElements == 2) return MVT::v2f32; 556 if (NumElements == 4) return MVT::v4f32; 557 if (NumElements == 8) return MVT::v8f32; 558 if (NumElements == 16) return MVT::v16f32; 559 break; 560 case MVT::f64: 561 if (NumElements == 1) return MVT::v1f64; 562 if (NumElements == 2) return MVT::v2f64; 563 if (NumElements == 4) return MVT::v4f64; 564 if (NumElements == 8) return MVT::v8f64; 565 break; 566 } 567 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 568 } 569 570 /// Return the value type corresponding to the specified type. This returns 571 /// all pointers as iPTR. If HandleUnknown is true, unknown types are 572 /// returned as Other, otherwise they are invalid. 573 static MVT getVT(Type *Ty, bool HandleUnknown = false); 574 575 }; 576 577} // End llvm namespace 578 579#endif 580