1 //===- CodeGen/ValueTypes.h - Low-Level Target independ. 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 low-level target independent types which various 11 // values in the code generator are. This allows the target specific behavior 12 // of instructions to be described to target independent passes. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CODEGEN_VALUETYPES_H 17 #define LLVM_CODEGEN_VALUETYPES_H 18 19 #include "llvm/CodeGen/MachineValueType.h" 20 #include "llvm/Support/Compiler.h" 21 #include "llvm/Support/MathExtras.h" 22 #include <cassert> 23 #include <cstdint> 24 #include <string> 25 26 namespace llvm { 27 28 class LLVMContext; 29 class Type; 30 31 /// Extended Value Type. Capable of holding value types which are not native 32 /// for any processor (such as the i12345 type), as well as the types an MVT 33 /// can represent. 34 struct EVT { 35 private: 36 MVT V = MVT::INVALID_SIMPLE_VALUE_TYPE; 37 Type *LLVMTy = nullptr; 38 39 public: 40 constexpr EVT() = default; 41 constexpr EVT(MVT::SimpleValueType SVT) : V(SVT) {} 42 constexpr EVT(MVT S) : V(S) {} 43 44 bool operator==(EVT VT) const { 45 return !(*this != VT); 46 } 47 bool operator!=(EVT VT) const { 48 if (V.SimpleTy != VT.V.SimpleTy) 49 return true; 50 if (V.SimpleTy == MVT::INVALID_SIMPLE_VALUE_TYPE) 51 return LLVMTy != VT.LLVMTy; 52 return false; 53 } 54 55 /// Returns the EVT that represents a floating-point type with the given 56 /// number of bits. There are two floating-point types with 128 bits - this 57 /// returns f128 rather than ppcf128. 58 static EVT getFloatingPointVT(unsigned BitWidth) { 59 return MVT::getFloatingPointVT(BitWidth); 60 } 61 62 /// Returns the EVT that represents an integer with the given number of 63 /// bits. 64 static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) { 65 MVT M = MVT::getIntegerVT(BitWidth); 66 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 67 return M; 68 return getExtendedIntegerVT(Context, BitWidth); 69 } 70 71 /// Returns the EVT that represents a vector NumElements in length, where 72 /// each element is of type VT. 73 static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements, 74 bool IsScalable = false) { 75 MVT M = MVT::getVectorVT(VT.V, NumElements, IsScalable); 76 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 77 return M; 78 79 assert(!IsScalable && "We don't support extended scalable types yet"); 80 return getExtendedVectorVT(Context, VT, NumElements); 81 } 82 83 /// Returns the EVT that represents a vector EC.Min elements in length, 84 /// where each element is of type VT. 85 static EVT getVectorVT(LLVMContext &Context, EVT VT, MVT::ElementCount EC) { 86 MVT M = MVT::getVectorVT(VT.V, EC); 87 if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE) 88 return M; 89 assert (!EC.Scalable && "We don't support extended scalable types yet"); 90 return getExtendedVectorVT(Context, VT, EC.Min); 91 } 92 93 /// Return a vector with the same number of elements as this vector, but 94 /// with the element type converted to an integer type with the same 95 /// bitwidth. 96 EVT changeVectorElementTypeToInteger() const { 97 if (!isSimple()) { 98 assert (!isScalableVector() && 99 "We don't support extended scalable types yet"); 100 return changeExtendedVectorElementTypeToInteger(); 101 } 102 MVT EltTy = getSimpleVT().getVectorElementType(); 103 unsigned BitWidth = EltTy.getSizeInBits(); 104 MVT IntTy = MVT::getIntegerVT(BitWidth); 105 MVT VecTy = MVT::getVectorVT(IntTy, getVectorNumElements(), 106 isScalableVector()); 107 assert(VecTy.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE && 108 "Simple vector VT not representable by simple integer vector VT!"); 109 return VecTy; 110 } 111 112 /// Return the type converted to an equivalently sized integer or vector 113 /// with integer element type. Similar to changeVectorElementTypeToInteger, 114 /// but also handles scalars. 115 EVT changeTypeToInteger() { 116 if (isVector()) 117 return changeVectorElementTypeToInteger(); 118 119 if (isSimple()) 120 return MVT::getIntegerVT(getSizeInBits()); 121 122 return changeExtendedTypeToInteger(); 123 } 124 125 /// Test if the given EVT is simple (as opposed to being extended). 126 bool isSimple() const { 127 return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE; 128 } 129 130 /// Test if the given EVT is extended (as opposed to being simple). 131 bool isExtended() const { 132 return !isSimple(); 133 } 134 135 /// Return true if this is a FP or a vector FP type. 136 bool isFloatingPoint() const { 137 return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint(); 138 } 139 140 /// Return true if this is an integer or a vector integer type. 141 bool isInteger() const { 142 return isSimple() ? V.isInteger() : isExtendedInteger(); 143 } 144 145 /// Return true if this is an integer, but not a vector. 146 bool isScalarInteger() const { 147 return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger(); 148 } 149 150 /// Return true if this is a vector value type. 151 bool isVector() const { 152 return isSimple() ? V.isVector() : isExtendedVector(); 153 } 154 155 /// Return true if this is a vector type where the runtime 156 /// length is machine dependent 157 bool isScalableVector() const { 158 // FIXME: We don't support extended scalable types yet, because the 159 // matching IR type doesn't exist. Once it has been added, this can 160 // be changed to call isExtendedScalableVector. 161 if (!isSimple()) 162 return false; 163 return V.isScalableVector(); 164 } 165 166 /// Return true if this is a 16-bit vector type. 167 bool is16BitVector() const { 168 return isSimple() ? V.is16BitVector() : isExtended16BitVector(); 169 } 170 171 /// Return true if this is a 32-bit vector type. 172 bool is32BitVector() const { 173 return isSimple() ? V.is32BitVector() : isExtended32BitVector(); 174 } 175 176 /// Return true if this is a 64-bit vector type. 177 bool is64BitVector() const { 178 return isSimple() ? V.is64BitVector() : isExtended64BitVector(); 179 } 180 181 /// Return true if this is a 128-bit vector type. 182 bool is128BitVector() const { 183 return isSimple() ? V.is128BitVector() : isExtended128BitVector(); 184 } 185 186 /// Return true if this is a 256-bit vector type. 187 bool is256BitVector() const { 188 return isSimple() ? V.is256BitVector() : isExtended256BitVector(); 189 } 190 191 /// Return true if this is a 512-bit vector type. 192 bool is512BitVector() const { 193 return isSimple() ? V.is512BitVector() : isExtended512BitVector(); 194 } 195 196 /// Return true if this is a 1024-bit vector type. 197 bool is1024BitVector() const { 198 return isSimple() ? V.is1024BitVector() : isExtended1024BitVector(); 199 } 200 201 /// Return true if this is a 2048-bit vector type. 202 bool is2048BitVector() const { 203 return isSimple() ? V.is2048BitVector() : isExtended2048BitVector(); 204 } 205 206 /// Return true if this is an overloaded type for TableGen. 207 bool isOverloaded() const { 208 return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny); 209 } 210 211 /// Return true if the bit size is a multiple of 8. 212 bool isByteSized() const { 213 return (getSizeInBits() & 7) == 0; 214 } 215 216 /// Return true if the size is a power-of-two number of bytes. 217 bool isRound() const { 218 unsigned BitSize = getSizeInBits(); 219 return BitSize >= 8 && !(BitSize & (BitSize - 1)); 220 } 221 222 /// Return true if this has the same number of bits as VT. 223 bool bitsEq(EVT VT) const { 224 if (EVT::operator==(VT)) return true; 225 return getSizeInBits() == VT.getSizeInBits(); 226 } 227 228 /// Return true if this has more bits than VT. 229 bool bitsGT(EVT VT) const { 230 if (EVT::operator==(VT)) return false; 231 return getSizeInBits() > VT.getSizeInBits(); 232 } 233 234 /// Return true if this has no less bits than VT. 235 bool bitsGE(EVT VT) const { 236 if (EVT::operator==(VT)) return true; 237 return getSizeInBits() >= VT.getSizeInBits(); 238 } 239 240 /// Return true if this has less bits than VT. 241 bool bitsLT(EVT VT) const { 242 if (EVT::operator==(VT)) return false; 243 return getSizeInBits() < VT.getSizeInBits(); 244 } 245 246 /// Return true if this has no more bits than VT. 247 bool bitsLE(EVT VT) const { 248 if (EVT::operator==(VT)) return true; 249 return getSizeInBits() <= VT.getSizeInBits(); 250 } 251 252 /// Return the SimpleValueType held in the specified simple EVT. 253 MVT getSimpleVT() const { 254 assert(isSimple() && "Expected a SimpleValueType!"); 255 return V; 256 } 257 258 /// If this is a vector type, return the element type, otherwise return 259 /// this. 260 EVT getScalarType() const { 261 return isVector() ? getVectorElementType() : *this; 262 } 263 264 /// Given a vector type, return the type of each element. 265 EVT getVectorElementType() const { 266 assert(isVector() && "Invalid vector type!"); 267 if (isSimple()) 268 return V.getVectorElementType(); 269 return getExtendedVectorElementType(); 270 } 271 272 /// Given a vector type, return the number of elements it contains. 273 unsigned getVectorNumElements() const { 274 assert(isVector() && "Invalid vector type!"); 275 if (isSimple()) 276 return V.getVectorNumElements(); 277 return getExtendedVectorNumElements(); 278 } 279 280 // Given a (possibly scalable) vector type, return the ElementCount 281 MVT::ElementCount getVectorElementCount() const { 282 assert((isVector()) && "Invalid vector type!"); 283 if (isSimple()) 284 return V.getVectorElementCount(); 285 286 assert(!isScalableVector() && 287 "We don't support extended scalable types yet"); 288 return {getExtendedVectorNumElements(), false}; 289 } 290 291 /// Return the size of the specified value type in bits. 292 unsigned getSizeInBits() const { 293 if (isSimple()) 294 return V.getSizeInBits(); 295 return getExtendedSizeInBits(); 296 } 297 298 unsigned getScalarSizeInBits() const { 299 return getScalarType().getSizeInBits(); 300 } 301 302 /// Return the number of bytes overwritten by a store of the specified value 303 /// type. 304 unsigned getStoreSize() const { 305 return (getSizeInBits() + 7) / 8; 306 } 307 308 /// Return the number of bits overwritten by a store of the specified value 309 /// type. 310 unsigned getStoreSizeInBits() const { 311 return getStoreSize() * 8; 312 } 313 314 /// Rounds the bit-width of the given integer EVT up to the nearest power of 315 /// two (and at least to eight), and returns the integer EVT with that 316 /// number of bits. 317 EVT getRoundIntegerType(LLVMContext &Context) const { 318 assert(isInteger() && !isVector() && "Invalid integer type!"); 319 unsigned BitWidth = getSizeInBits(); 320 if (BitWidth <= 8) 321 return EVT(MVT::i8); 322 return getIntegerVT(Context, 1 << Log2_32_Ceil(BitWidth)); 323 } 324 325 /// Finds the smallest simple value type that is greater than or equal to 326 /// half the width of this EVT. If no simple value type can be found, an 327 /// extended integer value type of half the size (rounded up) is returned. 328 EVT getHalfSizedIntegerVT(LLVMContext &Context) const { 329 assert(isInteger() && !isVector() && "Invalid integer type!"); 330 unsigned EVTSize = getSizeInBits(); 331 for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE; 332 IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) { 333 EVT HalfVT = EVT((MVT::SimpleValueType)IntVT); 334 if (HalfVT.getSizeInBits() * 2 >= EVTSize) 335 return HalfVT; 336 } 337 return getIntegerVT(Context, (EVTSize + 1) / 2); 338 } 339 340 /// Return a VT for an integer vector type with the size of the 341 /// elements doubled. The typed returned may be an extended type. 342 EVT widenIntegerVectorElementType(LLVMContext &Context) const { 343 EVT EltVT = getVectorElementType(); 344 EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits()); 345 return EVT::getVectorVT(Context, EltVT, getVectorElementCount()); 346 } 347 348 // Return a VT for a vector type with the same element type but 349 // half the number of elements. The type returned may be an 350 // extended type. 351 EVT getHalfNumVectorElementsVT(LLVMContext &Context) const { 352 EVT EltVT = getVectorElementType(); 353 auto EltCnt = getVectorElementCount(); 354 assert(!(EltCnt.Min & 1) && "Splitting vector, but not in half!"); 355 return EVT::getVectorVT(Context, EltVT, EltCnt / 2); 356 } 357 358 /// Returns true if the given vector is a power of 2. 359 bool isPow2VectorType() const { 360 unsigned NElts = getVectorNumElements(); 361 return !(NElts & (NElts - 1)); 362 } 363 364 /// Widens the length of the given vector EVT up to the nearest power of 2 365 /// and returns that type. 366 EVT getPow2VectorType(LLVMContext &Context) const { 367 if (!isPow2VectorType()) { 368 unsigned NElts = getVectorNumElements(); 369 unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts); 370 return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts, 371 isScalableVector()); 372 } 373 else { 374 return *this; 375 } 376 } 377 378 /// This function returns value type as a string, e.g. "i32". 379 std::string getEVTString() const; 380 381 /// This method returns an LLVM type corresponding to the specified EVT. 382 /// For integer types, this returns an unsigned type. Note that this will 383 /// abort for types that cannot be represented. 384 Type *getTypeForEVT(LLVMContext &Context) const; 385 386 /// Return the value type corresponding to the specified type. 387 /// This returns all pointers as iPTR. If HandleUnknown is true, unknown 388 /// types are returned as Other, otherwise they are invalid. 389 static EVT getEVT(Type *Ty, bool HandleUnknown = false); 390 391 intptr_t getRawBits() const { 392 if (isSimple()) 393 return V.SimpleTy; 394 else 395 return (intptr_t)(LLVMTy); 396 } 397 398 /// A meaningless but well-behaved order, useful for constructing 399 /// containers. 400 struct compareRawBits { 401 bool operator()(EVT L, EVT R) const { 402 if (L.V.SimpleTy == R.V.SimpleTy) 403 return L.LLVMTy < R.LLVMTy; 404 else 405 return L.V.SimpleTy < R.V.SimpleTy; 406 } 407 }; 408 409 private: 410 // Methods for handling the Extended-type case in functions above. 411 // These are all out-of-line to prevent users of this header file 412 // from having a dependency on Type.h. 413 EVT changeExtendedTypeToInteger() const; 414 EVT changeExtendedVectorElementTypeToInteger() const; 415 static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth); 416 static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, 417 unsigned NumElements); 418 bool isExtendedFloatingPoint() const LLVM_READONLY; 419 bool isExtendedInteger() const LLVM_READONLY; 420 bool isExtendedScalarInteger() const LLVM_READONLY; 421 bool isExtendedVector() const LLVM_READONLY; 422 bool isExtended16BitVector() const LLVM_READONLY; 423 bool isExtended32BitVector() const LLVM_READONLY; 424 bool isExtended64BitVector() const LLVM_READONLY; 425 bool isExtended128BitVector() const LLVM_READONLY; 426 bool isExtended256BitVector() const LLVM_READONLY; 427 bool isExtended512BitVector() const LLVM_READONLY; 428 bool isExtended1024BitVector() const LLVM_READONLY; 429 bool isExtended2048BitVector() const LLVM_READONLY; 430 EVT getExtendedVectorElementType() const; 431 unsigned getExtendedVectorNumElements() const LLVM_READONLY; 432 unsigned getExtendedSizeInBits() const LLVM_READONLY; 433 }; 434 435 } // end namespace llvm 436 437 #endif // LLVM_CODEGEN_VALUETYPES_H 438