LLVM API Documentation
00001 //===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file defines the set of low-level target independent types which various 00011 // values in the code generator are. This allows the target specific behavior 00012 // of instructions to be described to target independent passes. 00013 // 00014 //===----------------------------------------------------------------------===// 00015 00016 #ifndef LLVM_CODEGEN_VALUETYPES_H 00017 #define LLVM_CODEGEN_VALUETYPES_H 00018 00019 #include <cassert> 00020 #include <string> 00021 #include "llvm/Support/DataTypes.h" 00022 #include "llvm/Support/MathExtras.h" 00023 00024 namespace llvm { 00025 class Type; 00026 class LLVMContext; 00027 struct EVT; 00028 00029 class MVT { // MVT = Machine Value Type 00030 public: 00031 enum SimpleValueType { 00032 // If you change this numbering, you must change the values in 00033 // ValueTypes.td as well! 00034 Other = 0, // This is a non-standard value 00035 i1 = 1, // This is a 1 bit integer value 00036 i8 = 2, // This is an 8 bit integer value 00037 i16 = 3, // This is a 16 bit integer value 00038 i32 = 4, // This is a 32 bit integer value 00039 i64 = 5, // This is a 64 bit integer value 00040 i128 = 6, // This is a 128 bit integer value 00041 00042 FIRST_INTEGER_VALUETYPE = i1, 00043 LAST_INTEGER_VALUETYPE = i128, 00044 00045 f32 = 7, // This is a 32 bit floating point value 00046 f64 = 8, // This is a 64 bit floating point value 00047 f80 = 9, // This is a 80 bit floating point value 00048 f128 = 10, // This is a 128 bit floating point value 00049 ppcf128 = 11, // This is a PPC 128-bit floating point value 00050 Flag = 12, // This is a condition code or machine flag. 00051 00052 isVoid = 13, // This has no value 00053 00054 v2i8 = 14, // 2 x i8 00055 v4i8 = 15, // 4 x i8 00056 v8i8 = 16, // 8 x i8 00057 v16i8 = 17, // 16 x i8 00058 v32i8 = 18, // 32 x i8 00059 v2i16 = 19, // 2 x i16 00060 v4i16 = 20, // 4 x i16 00061 v8i16 = 21, // 8 x i16 00062 v16i16 = 22, // 16 x i16 00063 v2i32 = 23, // 2 x i32 00064 v4i32 = 24, // 4 x i32 00065 v8i32 = 25, // 8 x i32 00066 v1i64 = 26, // 1 x i64 00067 v2i64 = 27, // 2 x i64 00068 v4i64 = 28, // 4 x i64 00069 00070 v2f32 = 29, // 2 x f32 00071 v4f32 = 30, // 4 x f32 00072 v8f32 = 31, // 8 x f32 00073 v2f64 = 32, // 2 x f64 00074 v4f64 = 33, // 4 x f64 00075 00076 FIRST_VECTOR_VALUETYPE = v2i8, 00077 LAST_VECTOR_VALUETYPE = v4f64, 00078 00079 LAST_VALUETYPE = 34, // This always remains at the end of the list. 00080 00081 // This is the current maximum for LAST_VALUETYPE. 00082 // EVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors 00083 // This value must be a multiple of 32. 00084 MAX_ALLOWED_VALUETYPE = 64, 00085 00086 // Metadata - This is MDNode or MDString. 00087 Metadata = 250, 00088 00089 // iPTRAny - An int value the size of the pointer of the current 00090 // target to any address space. This must only be used internal to 00091 // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR. 00092 iPTRAny = 251, 00093 00094 // vAny - A vector with any length and element size. This is used 00095 // for intrinsics that have overloadings based on vector types. 00096 // This is only for tblgen's consumption! 00097 vAny = 252, 00098 00099 // fAny - Any floating-point or vector floating-point value. This is used 00100 // for intrinsics that have overloadings based on floating-point types. 00101 // This is only for tblgen's consumption! 00102 fAny = 253, 00103 00104 // iAny - An integer or vector integer value of any bit width. This is 00105 // used for intrinsics that have overloadings based on integer bit widths. 00106 // This is only for tblgen's consumption! 00107 iAny = 254, 00108 00109 // iPTR - An int value the size of the pointer of the current 00110 // target. This should only be used internal to tblgen! 00111 iPTR = 255, 00112 00113 // LastSimpleValueType - The greatest valid SimpleValueType value. 00114 LastSimpleValueType = 255, 00115 00116 // INVALID_SIMPLE_VALUE_TYPE - Simple value types greater than or equal 00117 // to this are considered extended value types. 00118 INVALID_SIMPLE_VALUE_TYPE = LastSimpleValueType + 1 00119 }; 00120 00121 SimpleValueType SimpleTy; 00122 00123 MVT() : SimpleTy((SimpleValueType)(INVALID_SIMPLE_VALUE_TYPE)) {} 00124 MVT(SimpleValueType SVT) : SimpleTy(SVT) { } 00125 00126 bool operator>(const MVT& S) const { return SimpleTy > S.SimpleTy; } 00127 bool operator<(const MVT& S) const { return SimpleTy < S.SimpleTy; } 00128 bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; } 00129 bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; } 00130 bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; } 00131 00132 /// isFloatingPoint - Return true if this is a FP, or a vector FP type. 00133 bool isFloatingPoint() const { 00134 return ((SimpleTy >= MVT::f32 && SimpleTy <= MVT::ppcf128) || 00135 (SimpleTy >= MVT::v2f32 && SimpleTy <= MVT::v4f64)); 00136 } 00137 00138 /// isInteger - Return true if this is an integer, or a vector integer type. 00139 bool isInteger() const { 00140 return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE && 00141 SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) || 00142 (SimpleTy >= MVT::v2i8 && SimpleTy <= MVT::v4i64)); 00143 } 00144 00145 /// isVector - Return true if this is a vector value type. 00146 bool isVector() const { 00147 return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE && 00148 SimpleTy <= MVT::LAST_VECTOR_VALUETYPE); 00149 } 00150 00151 /// isPow2VectorType - Retuns true if the given vector is a power of 2. 00152 bool isPow2VectorType() const { 00153 unsigned NElts = getVectorNumElements(); 00154 return !(NElts & (NElts - 1)); 00155 } 00156 00157 /// getPow2VectorType - Widens the length of the given vector EVT up to 00158 /// the nearest power of 2 and returns that type. 00159 MVT getPow2VectorType() const { 00160 if (!isPow2VectorType()) { 00161 unsigned NElts = getVectorNumElements(); 00162 unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts); 00163 return MVT::getVectorVT(getVectorElementType(), Pow2NElts); 00164 } 00165 else { 00166 return *this; 00167 } 00168 } 00169 00170 MVT getVectorElementType() const { 00171 switch (SimpleTy) { 00172 default: 00173 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 00174 case v2i8 : 00175 case v4i8 : 00176 case v8i8 : 00177 case v16i8: 00178 case v32i8: return i8; 00179 case v2i16: 00180 case v4i16: 00181 case v8i16: 00182 case v16i16: return i16; 00183 case v2i32: 00184 case v4i32: 00185 case v8i32: return i32; 00186 case v1i64: 00187 case v2i64: 00188 case v4i64: return i64; 00189 case v2f32: 00190 case v4f32: 00191 case v8f32: return f32; 00192 case v2f64: 00193 case v4f64: return f64; 00194 } 00195 } 00196 00197 unsigned getVectorNumElements() const { 00198 switch (SimpleTy) { 00199 default: 00200 return ~0U; 00201 case v32i8: return 32; 00202 case v16i8: 00203 case v16i16: return 16; 00204 case v8i8 : 00205 case v8i16: 00206 case v8i32: 00207 case v8f32: return 8; 00208 case v4i8: 00209 case v4i16: 00210 case v4i32: 00211 case v4i64: 00212 case v4f32: 00213 case v4f64: return 4; 00214 case v2i8: 00215 case v2i16: 00216 case v2i32: 00217 case v2i64: 00218 case v2f32: 00219 case v2f64: return 2; 00220 case v1i64: return 1; 00221 } 00222 } 00223 00224 unsigned getSizeInBits() const { 00225 switch (SimpleTy) { 00226 case iPTR: 00227 assert(0 && "Value type size is target-dependent. Ask TLI."); 00228 case iPTRAny: 00229 case iAny: 00230 case fAny: 00231 assert(0 && "Value type is overloaded."); 00232 default: 00233 assert(0 && "getSizeInBits called on extended MVT."); 00234 case i1 : return 1; 00235 case i8 : return 8; 00236 case i16 : 00237 case v2i8: return 16; 00238 case f32 : 00239 case i32 : 00240 case v4i8: 00241 case v2i16: return 32; 00242 case f64 : 00243 case i64 : 00244 case v8i8: 00245 case v4i16: 00246 case v2i32: 00247 case v1i64: 00248 case v2f32: return 64; 00249 case f80 : return 80; 00250 case f128: 00251 case ppcf128: 00252 case i128: 00253 case v16i8: 00254 case v8i16: 00255 case v4i32: 00256 case v2i64: 00257 case v4f32: 00258 case v2f64: return 128; 00259 case v32i8: 00260 case v16i16: 00261 case v8i32: 00262 case v4i64: 00263 case v8f32: 00264 case v4f64: return 256; 00265 } 00266 } 00267 00268 static MVT getFloatingPointVT(unsigned BitWidth) { 00269 switch (BitWidth) { 00270 default: 00271 assert(false && "Bad bit width!"); 00272 case 32: 00273 return MVT::f32; 00274 case 64: 00275 return MVT::f64; 00276 case 80: 00277 return MVT::f80; 00278 case 128: 00279 return MVT::f128; 00280 } 00281 } 00282 00283 static MVT getIntegerVT(unsigned BitWidth) { 00284 switch (BitWidth) { 00285 default: 00286 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 00287 case 1: 00288 return MVT::i1; 00289 case 8: 00290 return MVT::i8; 00291 case 16: 00292 return MVT::i16; 00293 case 32: 00294 return MVT::i32; 00295 case 64: 00296 return MVT::i64; 00297 case 128: 00298 return MVT::i128; 00299 } 00300 } 00301 00302 static MVT getVectorVT(MVT VT, unsigned NumElements) { 00303 switch (VT.SimpleTy) { 00304 default: 00305 break; 00306 case MVT::i8: 00307 if (NumElements == 2) return MVT::v2i8; 00308 if (NumElements == 4) return MVT::v4i8; 00309 if (NumElements == 8) return MVT::v8i8; 00310 if (NumElements == 16) return MVT::v16i8; 00311 if (NumElements == 32) return MVT::v32i8; 00312 break; 00313 case MVT::i16: 00314 if (NumElements == 2) return MVT::v2i16; 00315 if (NumElements == 4) return MVT::v4i16; 00316 if (NumElements == 8) return MVT::v8i16; 00317 if (NumElements == 16) return MVT::v16i16; 00318 break; 00319 case MVT::i32: 00320 if (NumElements == 2) return MVT::v2i32; 00321 if (NumElements == 4) return MVT::v4i32; 00322 if (NumElements == 8) return MVT::v8i32; 00323 break; 00324 case MVT::i64: 00325 if (NumElements == 1) return MVT::v1i64; 00326 if (NumElements == 2) return MVT::v2i64; 00327 if (NumElements == 4) return MVT::v4i64; 00328 break; 00329 case MVT::f32: 00330 if (NumElements == 2) return MVT::v2f32; 00331 if (NumElements == 4) return MVT::v4f32; 00332 if (NumElements == 8) return MVT::v8f32; 00333 break; 00334 case MVT::f64: 00335 if (NumElements == 2) return MVT::v2f64; 00336 if (NumElements == 4) return MVT::v4f64; 00337 break; 00338 } 00339 return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 00340 } 00341 00342 static MVT getIntVectorWithNumElements(unsigned NumElts) { 00343 switch (NumElts) { 00344 default: return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE); 00345 case 1: return MVT::v1i64; 00346 case 2: return MVT::v2i32; 00347 case 4: return MVT::v4i16; 00348 case 8: return MVT::v8i8; 00349 case 16: return MVT::v16i8; 00350 } 00351 } 00352 }; 00353 00354 struct EVT { // EVT = Extended Value Type 00355 private: 00356 MVT V; 00357 const Type *LLVMTy; 00358 00359 public: 00360 EVT() : V((MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE)), 00361 LLVMTy(0) {} 00362 EVT(MVT::SimpleValueType SVT) : V(SVT), LLVMTy(0) { } 00363 EVT(MVT S) : V(S), LLVMTy(0) {} 00364 00365 bool operator==(const EVT VT) const { 00366 if (V.SimpleTy == VT.V.SimpleTy) { 00367 if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 00368 return LLVMTy == VT.LLVMTy; 00369 return true; 00370 } 00371 return false; 00372 } 00373 bool operator!=(const EVT VT) const { 00374 if (V.SimpleTy == VT.V.SimpleTy) { 00375 if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 00376 return LLVMTy != VT.LLVMTy; 00377 return false; 00378 } 00379 return true; 00380 } 00381 00382 /// getFloatingPointVT - Returns the EVT that represents a floating point 00383 /// type with the given number of bits. There are two floating point types 00384 /// with 128 bits - this returns f128 rather than ppcf128. 00385 static EVT getFloatingPointVT(unsigned BitWidth) { 00386 return MVT::getFloatingPointVT(BitWidth); 00387 } 00388 00389 /// getIntegerVT - Returns the EVT that represents an integer with the given 00390 /// number of bits. 00391 static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) { 00392 MVT M = MVT::getIntegerVT(BitWidth); 00393 if (M.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 00394 return getExtendedIntegerVT(Context, BitWidth); 00395 else 00396 return M; 00397 } 00398 00399 /// getVectorVT - Returns the EVT that represents a vector NumElements in 00400 /// length, where each element is of type VT. 00401 static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements) { 00402 MVT M = MVT::getVectorVT(VT.V, NumElements); 00403 if (M.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 00404 return getExtendedVectorVT(Context, VT, NumElements); 00405 else 00406 return M; 00407 } 00408 00409 /// getIntVectorWithNumElements - Return any integer vector type that has 00410 /// the specified number of elements. 00411 static EVT getIntVectorWithNumElements(LLVMContext &C, unsigned NumElts) { 00412 MVT M = MVT::getIntVectorWithNumElements(NumElts); 00413 if (M.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 00414 return getVectorVT(C, MVT::i8, NumElts); 00415 else 00416 return M; 00417 } 00418 00419 /// isSimple - Test if the given EVT is simple (as opposed to being 00420 /// extended). 00421 bool isSimple() const { 00422 return V.SimpleTy <= MVT::LastSimpleValueType; 00423 } 00424 00425 /// isExtended - Test if the given EVT is extended (as opposed to 00426 /// being simple). 00427 bool isExtended() const { 00428 return !isSimple(); 00429 } 00430 00431 /// isFloatingPoint - Return true if this is a FP, or a vector FP type. 00432 bool isFloatingPoint() const { 00433 return isSimple() ? 00434 ((V >= MVT::f32 && V <= MVT::ppcf128) || 00435 (V >= MVT::v2f32 && V <= MVT::v4f64)) : isExtendedFloatingPoint(); 00436 } 00437 00438 /// isInteger - Return true if this is an integer, or a vector integer type. 00439 bool isInteger() const { 00440 return isSimple() ? 00441 ((V >= MVT::FIRST_INTEGER_VALUETYPE && 00442 V <= MVT::LAST_INTEGER_VALUETYPE) || 00443 (V >= MVT::v2i8 && V <= MVT::v4i64)) : isExtendedInteger(); 00444 } 00445 00446 /// isVector - Return true if this is a vector value type. 00447 bool isVector() const { 00448 return isSimple() ? 00449 (V >= MVT::FIRST_VECTOR_VALUETYPE && V <= 00450 MVT::LAST_VECTOR_VALUETYPE) : 00451 isExtendedVector(); 00452 } 00453 00454 /// is64BitVector - Return true if this is a 64-bit vector type. 00455 bool is64BitVector() const { 00456 return isSimple() ? 00457 (V==MVT::v8i8 || V==MVT::v4i16 || V==MVT::v2i32 || 00458 V==MVT::v1i64 || V==MVT::v2f32) : 00459 isExtended64BitVector(); 00460 } 00461 00462 /// is128BitVector - Return true if this is a 128-bit vector type. 00463 bool is128BitVector() const { 00464 return isSimple() ? 00465 (V==MVT::v16i8 || V==MVT::v8i16 || V==MVT::v4i32 || 00466 V==MVT::v2i64 || V==MVT::v4f32 || V==MVT::v2f64) : 00467 isExtended128BitVector(); 00468 } 00469 00470 /// is256BitVector - Return true if this is a 256-bit vector type. 00471 inline bool is256BitVector() const { 00472 return isSimple() ? 00473 (V==MVT::v8f32 || V==MVT::v4f64 || V==MVT::v32i8 || 00474 V==MVT::v16i16 || V==MVT::v8i32 || V==MVT::v4i64) : 00475 isExtended256BitVector(); 00476 } 00477 00478 /// isOverloaded - Return true if this is an overloaded type for TableGen. 00479 bool isOverloaded() const { 00480 return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny); 00481 } 00482 00483 /// isByteSized - Return true if the bit size is a multiple of 8. 00484 bool isByteSized() const { 00485 return (getSizeInBits() & 7) == 0; 00486 } 00487 00488 /// isRound - Return true if the size is a power-of-two number of bytes. 00489 bool isRound() const { 00490 unsigned BitSize = getSizeInBits(); 00491 return BitSize >= 8 && !(BitSize & (BitSize - 1)); 00492 } 00493 00494 /// bitsEq - Return true if this has the same number of bits as VT. 00495 bool bitsEq(EVT VT) const { 00496 return getSizeInBits() == VT.getSizeInBits(); 00497 } 00498 00499 /// bitsGT - Return true if this has more bits than VT. 00500 bool bitsGT(EVT VT) const { 00501 return getSizeInBits() > VT.getSizeInBits(); 00502 } 00503 00504 /// bitsGE - Return true if this has no less bits than VT. 00505 bool bitsGE(EVT VT) const { 00506 return getSizeInBits() >= VT.getSizeInBits(); 00507 } 00508 00509 /// bitsLT - Return true if this has less bits than VT. 00510 bool bitsLT(EVT VT) const { 00511 return getSizeInBits() < VT.getSizeInBits(); 00512 } 00513 00514 /// bitsLE - Return true if this has no more bits than VT. 00515 bool bitsLE(EVT VT) const { 00516 return getSizeInBits() <= VT.getSizeInBits(); 00517 } 00518 00519 00520 /// getSimpleVT - Return the SimpleValueType held in the specified 00521 /// simple EVT. 00522 MVT getSimpleVT() const { 00523 assert(isSimple() && "Expected a SimpleValueType!"); 00524 return V; 00525 } 00526 00527 /// getVectorElementType - Given a vector type, return the type of 00528 /// each element. 00529 EVT getVectorElementType() const { 00530 assert(isVector() && "Invalid vector type!"); 00531 if (isSimple()) 00532 return V.getVectorElementType(); 00533 else 00534 return getExtendedVectorElementType(); 00535 } 00536 00537 /// getVectorNumElements - Given a vector type, return the number of 00538 /// elements it contains. 00539 unsigned getVectorNumElements() const { 00540 assert(isVector() && "Invalid vector type!"); 00541 if (isSimple()) 00542 return V.getVectorNumElements(); 00543 else 00544 return getExtendedVectorNumElements(); 00545 } 00546 00547 /// getSizeInBits - Return the size of the specified value type in bits. 00548 unsigned getSizeInBits() const { 00549 if (isSimple()) 00550 return V.getSizeInBits(); 00551 else 00552 return getExtendedSizeInBits(); 00553 } 00554 00555 /// getStoreSizeInBits - Return the number of bits overwritten by a store 00556 /// of the specified value type. 00557 unsigned getStoreSizeInBits() const { 00558 return (getSizeInBits() + 7)/8*8; 00559 } 00560 00561 /// getRoundIntegerType - Rounds the bit-width of the given integer EVT up 00562 /// to the nearest power of two (and at least to eight), and returns the 00563 /// integer EVT with that number of bits. 00564 EVT getRoundIntegerType(LLVMContext &Context) const { 00565 assert(isInteger() && !isVector() && "Invalid integer type!"); 00566 unsigned BitWidth = getSizeInBits(); 00567 if (BitWidth <= 8) 00568 return EVT(MVT::i8); 00569 else 00570 return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth)); 00571 } 00572 00573 /// isPow2VectorType - Retuns true if the given vector is a power of 2. 00574 bool isPow2VectorType() const { 00575 unsigned NElts = getVectorNumElements(); 00576 return !(NElts & (NElts - 1)); 00577 } 00578 00579 /// getPow2VectorType - Widens the length of the given vector EVT up to 00580 /// the nearest power of 2 and returns that type. 00581 EVT getPow2VectorType(LLVMContext &Context) const { 00582 if (!isPow2VectorType()) { 00583 unsigned NElts = getVectorNumElements(); 00584 unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts); 00585 return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts); 00586 } 00587 else { 00588 return *this; 00589 } 00590 } 00591 00592 /// getEVTString - This function returns value type as a string, 00593 /// e.g. "i32". 00594 std::string getEVTString() const; 00595 00596 /// getTypeForEVT - This method returns an LLVM type corresponding to the 00597 /// specified EVT. For integer types, this returns an unsigned type. Note 00598 /// that this will abort for types that cannot be represented. 00599 const Type *getTypeForEVT(LLVMContext &Context) const; 00600 00601 /// getEVT - Return the value type corresponding to the specified type. 00602 /// This returns all pointers as iPTR. If HandleUnknown is true, unknown 00603 /// types are returned as Other, otherwise they are invalid. 00604 static EVT getEVT(const Type *Ty, bool HandleUnknown = false); 00605 00606 intptr_t getRawBits() { 00607 if (V.SimpleTy <= MVT::LastSimpleValueType) 00608 return V.SimpleTy; 00609 else 00610 return (intptr_t)(LLVMTy); 00611 } 00612 00613 /// compareRawBits - A meaningless but well-behaved order, useful for 00614 /// constructing containers. 00615 struct compareRawBits { 00616 bool operator()(EVT L, EVT R) const { 00617 if (L.V.SimpleTy == R.V.SimpleTy) 00618 return L.LLVMTy < R.LLVMTy; 00619 else 00620 return L.V.SimpleTy < R.V.SimpleTy; 00621 } 00622 }; 00623 00624 private: 00625 // Methods for handling the Extended-type case in functions above. 00626 // These are all out-of-line to prevent users of this header file 00627 // from having a dependency on Type.h. 00628 static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth); 00629 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, 00630 unsigned NumElements); 00631 bool isExtendedFloatingPoint() const; 00632 bool isExtendedInteger() const; 00633 bool isExtendedVector() const; 00634 bool isExtended64BitVector() const; 00635 bool isExtended128BitVector() const; 00636 bool isExtended256BitVector() const; 00637 EVT getExtendedVectorElementType() const; 00638 unsigned getExtendedVectorNumElements() const; 00639 unsigned getExtendedSizeInBits() const; 00640 }; 00641 00642 } // End llvm namespace 00643 00644 #endif