include/llvm/Support/LowLevelTypeImpl.h

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