include/llvm/Support/LowLevelTypeImpl.h

   1 //== llvm/Support/LowLevelTypeImpl.h --------------------------- -*- 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 /// Implement a low-level type suitable for MachineInstr level instruction
  11 /// selection.
  12 ///
  13 /// For a type attached to a MachineInstr, we only care about 2 details: total
  14 /// size and the number of vector lanes (if any). Accordingly, there are 4
  15 /// possible valid type-kinds:
  16 ///
  17 ///    * `sN` for scalars and aggregates
  18 ///    * `<N x sM>` for vectors, which must have at least 2 elements.
  19 ///    * `pN` for pointers
  20 ///
  21 /// Other information required for correct selection is expected to be carried
  22 /// by the opcode, or non-type flags. For example the distinction between G_ADD
  23 /// and G_FADD for int/float or fast-math flags.
  24 //
  25 //===----------------------------------------------------------------------===//
  26
  27 #ifndef LLVM_SUPPORT_LOWLEVELTYPEIMPL_H
  28 #define LLVM_SUPPORT_LOWLEVELTYPEIMPL_H
  29
  30 #include <cassert>
  31 #include "llvm/ADT/DenseMapInfo.h"
  32 #include "llvm/CodeGen/MachineValueType.h"
  33
  34 namespace llvm {
  35
  36 class DataLayout;
  37 class Type;
  38 class raw_ostream;
  39
  40 class LLT {
  41 public:
  42   /// Get a low-level scalar or aggregate "bag of bits".
  43   static LLT scalar(unsigned SizeInBits) {
  44     assert(SizeInBits > 0 && "invalid scalar size");
  45     return LLT{/*isPointer=*/false, /*isVector=*/false, /*NumElements=*/0,
  46                SizeInBits, /*AddressSpace=*/0};
  47   }
  48
  49   /// Get a low-level pointer in the given address space (defaulting to 0).
  50   static LLT pointer(uint16_t AddressSpace, unsigned SizeInBits) {
  51     assert(SizeInBits > 0 && "invalid pointer size");
  52     return LLT{/*isPointer=*/true, /*isVector=*/false, /*NumElements=*/0,
  53                SizeInBits, AddressSpace};
  54   }
  55
  56   /// Get a low-level vector of some number of elements and element width.
  57   /// \p NumElements must be at least 2.
  58   static LLT vector(uint16_t NumElements, unsigned ScalarSizeInBits) {
  59     assert(NumElements > 1 && "invalid number of vector elements");
  60     assert(ScalarSizeInBits > 0 && "invalid vector element size");
  61     return LLT{/*isPointer=*/false, /*isVector=*/true, NumElements,
  62                ScalarSizeInBits, /*AddressSpace=*/0};
  63   }
  64
  65   /// Get a low-level vector of some number of elements and element type.
  66   static LLT vector(uint16_t NumElements, LLT ScalarTy) {
  67     assert(NumElements > 1 && "invalid number of vector elements");
  68     assert(!ScalarTy.isVector() && "invalid vector element type");
  69     return LLT{ScalarTy.isPointer(), /*isVector=*/true, NumElements,
  70                ScalarTy.getSizeInBits(),
  71                ScalarTy.isPointer() ? ScalarTy.getAddressSpace() : 0};
  72   }
  73
  74   explicit LLT(bool isPointer, bool isVector, uint16_t NumElements,
  75                unsigned SizeInBits, unsigned AddressSpace) {
  76     init(isPointer, isVector, NumElements, SizeInBits, AddressSpace);
  77   }
  78   explicit LLT() : IsPointer(false), IsVector(false), RawData(0) {}
  79
  80   explicit LLT(MVT VT);
  81
  82   bool isValid() const { return RawData != 0; }
  83
  84   bool isScalar() const { return isValid() && !IsPointer && !IsVector; }
  85
  86   bool isPointer() const { return isValid() && IsPointer && !IsVector; }
  87
  88   bool isVector() const { return isValid() && IsVector; }
  89
  90   /// Returns the number of elements in a vector LLT. Must only be called on
  91   /// vector types.
  92   uint16_t getNumElements() const {
  93     assert(IsVector && "cannot get number of elements on scalar/aggregate");
  94     if (!IsPointer)
  95       return getFieldValue(VectorElementsFieldInfo);
  96     else
  97       return getFieldValue(PointerVectorElementsFieldInfo);
  98   }
  99
 100   /// Returns the total size of the type. Must only be called on sized types.
 101   unsigned getSizeInBits() const {
 102     if (isPointer() || isScalar())
 103       return getScalarSizeInBits();
 104     return getScalarSizeInBits() * getNumElements();
 105   }
 106
 107   unsigned getScalarSizeInBits() const {
 108     assert(RawData != 0 && "Invalid Type");
 109     if (!IsVector) {
 110       if (!IsPointer)
 111         return getFieldValue(ScalarSizeFieldInfo);
 112       else
 113         return getFieldValue(PointerSizeFieldInfo);
 114     } else {
 115       if (!IsPointer)
 116         return getFieldValue(VectorSizeFieldInfo);
 117       else
 118         return getFieldValue(PointerVectorSizeFieldInfo);
 119     }
 120   }
 121
 122   unsigned getAddressSpace() const {
 123     assert(RawData != 0 && "Invalid Type");
 124     assert(IsPointer && "cannot get address space of non-pointer type");
 125     if (!IsVector)
 126       return getFieldValue(PointerAddressSpaceFieldInfo);
 127     else
 128       return getFieldValue(PointerVectorAddressSpaceFieldInfo);
 129   }
 130
 131   /// Returns the vector's element type. Only valid for vector types.
 132   LLT getElementType() const {
 133     assert(isVector() && "cannot get element type of scalar/aggregate");
 134     if (IsPointer)
 135       return pointer(getAddressSpace(), getScalarSizeInBits());
 136     else
 137       return scalar(getScalarSizeInBits());
 138   }
 139
 140   /// Get a low-level type with half the size of the original, by halving the
 141   /// size of the scalar type involved. For example `s32` will become `s16`,
 142   /// `<2 x s32>` will become `<2 x s16>`.
 143   LLT halfScalarSize() const {
 144     assert(!IsPointer && getScalarSizeInBits() > 1 &&
 145            getScalarSizeInBits() % 2 == 0 && "cannot half size of this type");
 146     return LLT{/*isPointer=*/false, IsVector ? true : false,
 147                IsVector ? getNumElements() : (uint16_t)0,
 148                getScalarSizeInBits() / 2, /*AddressSpace=*/0};
 149   }
 150
 151   /// Get a low-level type with twice the size of the original, by doubling the
 152   /// size of the scalar type involved. For example `s32` will become `s64`,
 153   /// `<2 x s32>` will become `<2 x s64>`.
 154   LLT doubleScalarSize() const {
 155     assert(!IsPointer && "cannot change size of this type");
 156     return LLT{/*isPointer=*/false, IsVector ? true : false,
 157                IsVector ? getNumElements() : (uint16_t)0,
 158                getScalarSizeInBits() * 2, /*AddressSpace=*/0};
 159   }
 160
 161   /// Get a low-level type with half the size of the original, by halving the
 162   /// number of vector elements of the scalar type involved. The source must be
 163   /// a vector type with an even number of elements. For example `<4 x s32>`
 164   /// will become `<2 x s32>`, `<2 x s32>` will become `s32`.
 165   LLT halfElements() const {
 166     assert(isVector() && getNumElements() % 2 == 0 && "cannot half odd vector");
 167     if (getNumElements() == 2)
 168       return scalar(getScalarSizeInBits());
 169
 170     return LLT{/*isPointer=*/false, /*isVector=*/true,
 171                (uint16_t)(getNumElements() / 2), getScalarSizeInBits(),
 172                /*AddressSpace=*/0};
 173   }
 174
 175   /// Get a low-level type with twice the size of the original, by doubling the
 176   /// number of vector elements of the scalar type involved. The source must be
 177   /// a vector type. For example `<2 x s32>` will become `<4 x s32>`. Doubling
 178   /// the number of elements in sN produces <2 x sN>.
 179   LLT doubleElements() const {
 180     return LLT{IsPointer ? true : false, /*isVector=*/true,
 181                (uint16_t)(getNumElements() * 2), getScalarSizeInBits(),
 182                IsPointer ? getAddressSpace() : 0};
 183   }
 184
 185   void print(raw_ostream &OS) const;
 186
 187   bool operator==(const LLT &RHS) const {
 188     return IsPointer == RHS.IsPointer && IsVector == RHS.IsVector &&
 189            RHS.RawData == RawData;
 190   }
 191
 192   bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
 193
 194   friend struct DenseMapInfo<LLT>;
 195
 196 private:
 197   /// LLT is packed into 64 bits as follows:
 198   /// isPointer : 1
 199   /// isVector  : 1
 200   /// with 62 bits remaining for Kind-specific data, packed in bitfields
 201   /// as described below. As there isn't a simple portable way to pack bits
 202   /// into bitfields, here the different fields in the packed structure is
 203   /// described in static const *Field variables. Each of these variables
 204   /// is a 2-element array, with the first element describing the bitfield size
 205   /// and the second element describing the bitfield offset.
 206   typedef int BitFieldInfo[2];
 207   ///
 208   /// This is how the bitfields are packed per Kind:
 209   /// * Invalid:
 210   ///   gets encoded as RawData == 0, as that is an invalid encoding, since for
 211   ///   valid encodings, SizeInBits/SizeOfElement must be larger than 0.
 212   /// * Non-pointer scalar (isPointer == 0 && isVector == 0):
 213   ///   SizeInBits: 32;
 214   static const constexpr BitFieldInfo ScalarSizeFieldInfo{32, 0};
 215   /// * Pointer (isPointer == 1 && isVector == 0):
 216   ///   SizeInBits: 16;
 217   ///   AddressSpace: 23;
 218   static const constexpr BitFieldInfo PointerSizeFieldInfo{16, 0};
 219   static const constexpr BitFieldInfo PointerAddressSpaceFieldInfo{
 220       23, PointerSizeFieldInfo[0] + PointerSizeFieldInfo[1]};
 221   /// * Vector-of-non-pointer (isPointer == 0 && isVector == 1):
 222   ///   NumElements: 16;
 223   ///   SizeOfElement: 32;
 224   static const constexpr BitFieldInfo VectorElementsFieldInfo{16, 0};
 225   static const constexpr BitFieldInfo VectorSizeFieldInfo{
 226       32, VectorElementsFieldInfo[0] + VectorElementsFieldInfo[1]};
 227   /// * Vector-of-pointer (isPointer == 1 && isVector == 1):
 228   ///   NumElements: 16;
 229   ///   SizeOfElement: 16;
 230   ///   AddressSpace: 23;
 231   static const constexpr BitFieldInfo PointerVectorElementsFieldInfo{16, 0};
 232   static const constexpr BitFieldInfo PointerVectorSizeFieldInfo{
 233       16,
 234       PointerVectorElementsFieldInfo[1] + PointerVectorElementsFieldInfo[0]};
 235   static const constexpr BitFieldInfo PointerVectorAddressSpaceFieldInfo{
 236       23, PointerVectorSizeFieldInfo[1] + PointerVectorSizeFieldInfo[0]};
 237
 238   uint64_t IsPointer : 1;
 239   uint64_t IsVector : 1;
 240   uint64_t RawData : 62;
 241
 242   static uint64_t getMask(const BitFieldInfo FieldInfo) {
 243     const int FieldSizeInBits = FieldInfo[0];
 244     return (((uint64_t)1) << FieldSizeInBits) - 1;
 245   }
 246   static uint64_t maskAndShift(uint64_t Val, uint64_t Mask, uint8_t Shift) {
 247     assert(Val <= Mask && "Value too large for field");
 248     return (Val & Mask) << Shift;
 249   }
 250   static uint64_t maskAndShift(uint64_t Val, const BitFieldInfo FieldInfo) {
 251     return maskAndShift(Val, getMask(FieldInfo), FieldInfo[1]);
 252   }
 253   uint64_t getFieldValue(const BitFieldInfo FieldInfo) const {
 254     return getMask(FieldInfo) & (RawData >> FieldInfo[1]);
 255   }
 256
 257   void init(bool IsPointer, bool IsVector, uint16_t NumElements,
 258             unsigned SizeInBits, unsigned AddressSpace) {
 259     this->IsPointer = IsPointer;
 260     this->IsVector = IsVector;
 261     if (!IsVector) {
 262       if (!IsPointer)
 263         RawData = maskAndShift(SizeInBits, ScalarSizeFieldInfo);
 264       else
 265         RawData = maskAndShift(SizeInBits, PointerSizeFieldInfo) |
 266                   maskAndShift(AddressSpace, PointerAddressSpaceFieldInfo);
 267     } else {
 268       assert(NumElements > 1 && "invalid number of vector elements");
 269       if (!IsPointer)
 270         RawData = maskAndShift(NumElements, VectorElementsFieldInfo) |
 271                   maskAndShift(SizeInBits, VectorSizeFieldInfo);
 272       else
 273         RawData =
 274             maskAndShift(NumElements, PointerVectorElementsFieldInfo) |
 275             maskAndShift(SizeInBits, PointerVectorSizeFieldInfo) |
 276             maskAndShift(AddressSpace, PointerVectorAddressSpaceFieldInfo);
 277     }
 278   }
 279 };
 280
 281 inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
 282   Ty.print(OS);
 283   return OS;
 284 }
 285
 286 template<> struct DenseMapInfo<LLT> {
 287   static inline LLT getEmptyKey() {
 288     LLT Invalid;
 289     Invalid.IsPointer = true;
 290     return Invalid;
 291   }
 292   static inline LLT getTombstoneKey() {
 293     LLT Invalid;
 294     Invalid.IsVector = true;
 295     return Invalid;
 296   }
 297   static inline unsigned getHashValue(const LLT &Ty) {
 298     uint64_t Val = ((uint64_t)Ty.RawData) << 2 | ((uint64_t)Ty.IsPointer) << 1 |
 299                    ((uint64_t)Ty.IsVector);
 300     return DenseMapInfo<uint64_t>::getHashValue(Val);
 301   }
 302   static bool isEqual(const LLT &LHS, const LLT &RHS) {
 303     return LHS == RHS;
 304   }
 305 };
 306
 307 }
 308
 309 #endif // LLVM_SUPPORT_LOWLEVELTYPEIMPL_H