Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- CodeGen/ValueTypes.h - Low-Level Target independ. types --*- 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. // This file defines the set of low-level target independent types which various
  10. // values in the code generator are.  This allows the target specific behavior
  11. // of instructions to be described to target independent passes.
  12. //
  13. //===----------------------------------------------------------------------===//
  14.  
  15. #ifndef LLVM_CODEGEN_VALUETYPES_H
  16. #define LLVM_CODEGEN_VALUETYPES_H
  17.  
  18. #include "llvm/Support/Compiler.h"
  19. #include "llvm/Support/MachineValueType.h"
  20. #include "llvm/Support/MathExtras.h"
  21. #include "llvm/Support/TypeSize.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.       return getExtendedVectorVT(Context, VT, NumElements, IsScalable);
  79.     }
  80.  
  81.     /// Returns the EVT that represents a vector EC.Min elements in length,
  82.     /// where each element is of type VT.
  83.     static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
  84.       MVT M = MVT::getVectorVT(VT.V, EC);
  85.       if (M.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE)
  86.         return M;
  87.       return getExtendedVectorVT(Context, VT, EC);
  88.     }
  89.  
  90.     /// Return a vector with the same number of elements as this vector, but
  91.     /// with the element type converted to an integer type with the same
  92.     /// bitwidth.
  93.     EVT changeVectorElementTypeToInteger() const {
  94.       if (isSimple())
  95.         return getSimpleVT().changeVectorElementTypeToInteger();
  96.       return changeExtendedVectorElementTypeToInteger();
  97.     }
  98.  
  99.     /// Return a VT for a vector type whose attributes match ourselves
  100.     /// with the exception of the element type that is chosen by the caller.
  101.     EVT changeVectorElementType(EVT EltVT) const {
  102.       if (isSimple()) {
  103.         assert(EltVT.isSimple() &&
  104.                "Can't change simple vector VT to have extended element VT");
  105.         return getSimpleVT().changeVectorElementType(EltVT.getSimpleVT());
  106.       }
  107.       return changeExtendedVectorElementType(EltVT);
  108.     }
  109.  
  110.     /// Return the type converted to an equivalently sized integer or vector
  111.     /// with integer element type. Similar to changeVectorElementTypeToInteger,
  112.     /// but also handles scalars.
  113.     EVT changeTypeToInteger() {
  114.       if (isVector())
  115.         return changeVectorElementTypeToInteger();
  116.  
  117.       if (isSimple())
  118.         return getSimpleVT().changeTypeToInteger();
  119.       return changeExtendedTypeToInteger();
  120.     }
  121.  
  122.     /// Test if the given EVT has zero size, this will fail if called on a
  123.     /// scalable type
  124.     bool isZeroSized() const {
  125.       return !isScalableVector() && getSizeInBits() == 0;
  126.     }
  127.  
  128.     /// Test if the given EVT is simple (as opposed to being extended).
  129.     bool isSimple() const {
  130.       return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
  131.     }
  132.  
  133.     /// Test if the given EVT is extended (as opposed to being simple).
  134.     bool isExtended() const {
  135.       return !isSimple();
  136.     }
  137.  
  138.     /// Return true if this is a FP or a vector FP type.
  139.     bool isFloatingPoint() const {
  140.       return isSimple() ? V.isFloatingPoint() : isExtendedFloatingPoint();
  141.     }
  142.  
  143.     /// Return true if this is an integer or a vector integer type.
  144.     bool isInteger() const {
  145.       return isSimple() ? V.isInteger() : isExtendedInteger();
  146.     }
  147.  
  148.     /// Return true if this is an integer, but not a vector.
  149.     bool isScalarInteger() const {
  150.       return isSimple() ? V.isScalarInteger() : isExtendedScalarInteger();
  151.     }
  152.  
  153.     /// Return true if this is a vector value type.
  154.     bool isVector() const {
  155.       return isSimple() ? V.isVector() : isExtendedVector();
  156.     }
  157.  
  158.     /// Return true if this is a vector type where the runtime
  159.     /// length is machine dependent
  160.     bool isScalableVector() const {
  161.       return isSimple() ? V.isScalableVector() : isExtendedScalableVector();
  162.     }
  163.  
  164.     bool isFixedLengthVector() const {
  165.       return isSimple() ? V.isFixedLengthVector()
  166.                         : isExtendedFixedLengthVector();
  167.     }
  168.  
  169.     /// Return true if this is a 16-bit vector type.
  170.     bool is16BitVector() const {
  171.       return isSimple() ? V.is16BitVector() : isExtended16BitVector();
  172.     }
  173.  
  174.     /// Return true if this is a 32-bit vector type.
  175.     bool is32BitVector() const {
  176.       return isSimple() ? V.is32BitVector() : isExtended32BitVector();
  177.     }
  178.  
  179.     /// Return true if this is a 64-bit vector type.
  180.     bool is64BitVector() const {
  181.       return isSimple() ? V.is64BitVector() : isExtended64BitVector();
  182.     }
  183.  
  184.     /// Return true if this is a 128-bit vector type.
  185.     bool is128BitVector() const {
  186.       return isSimple() ? V.is128BitVector() : isExtended128BitVector();
  187.     }
  188.  
  189.     /// Return true if this is a 256-bit vector type.
  190.     bool is256BitVector() const {
  191.       return isSimple() ? V.is256BitVector() : isExtended256BitVector();
  192.     }
  193.  
  194.     /// Return true if this is a 512-bit vector type.
  195.     bool is512BitVector() const {
  196.       return isSimple() ? V.is512BitVector() : isExtended512BitVector();
  197.     }
  198.  
  199.     /// Return true if this is a 1024-bit vector type.
  200.     bool is1024BitVector() const {
  201.       return isSimple() ? V.is1024BitVector() : isExtended1024BitVector();
  202.     }
  203.  
  204.     /// Return true if this is a 2048-bit vector type.
  205.     bool is2048BitVector() const {
  206.       return isSimple() ? V.is2048BitVector() : isExtended2048BitVector();
  207.     }
  208.  
  209.     /// Return true if this is an overloaded type for TableGen.
  210.     bool isOverloaded() const {
  211.       return (V==MVT::iAny || V==MVT::fAny || V==MVT::vAny || V==MVT::iPTRAny);
  212.     }
  213.  
  214.     /// Return true if the bit size is a multiple of 8.
  215.     bool isByteSized() const {
  216.       return !isZeroSized() && getSizeInBits().isKnownMultipleOf(8);
  217.     }
  218.  
  219.     /// Return true if the size is a power-of-two number of bytes.
  220.     bool isRound() const {
  221.       if (isScalableVector())
  222.         return false;
  223.       unsigned BitSize = getSizeInBits();
  224.       return BitSize >= 8 && !(BitSize & (BitSize - 1));
  225.     }
  226.  
  227.     /// Return true if this has the same number of bits as VT.
  228.     bool bitsEq(EVT VT) const {
  229.       if (EVT::operator==(VT)) return true;
  230.       return getSizeInBits() == VT.getSizeInBits();
  231.     }
  232.  
  233.     /// Return true if we know at compile time this has more bits than VT.
  234.     bool knownBitsGT(EVT VT) const {
  235.       return TypeSize::isKnownGT(getSizeInBits(), VT.getSizeInBits());
  236.     }
  237.  
  238.     /// Return true if we know at compile time this has more than or the same
  239.     /// bits as VT.
  240.     bool knownBitsGE(EVT VT) const {
  241.       return TypeSize::isKnownGE(getSizeInBits(), VT.getSizeInBits());
  242.     }
  243.  
  244.     /// Return true if we know at compile time this has fewer bits than VT.
  245.     bool knownBitsLT(EVT VT) const {
  246.       return TypeSize::isKnownLT(getSizeInBits(), VT.getSizeInBits());
  247.     }
  248.  
  249.     /// Return true if we know at compile time this has fewer than or the same
  250.     /// bits as VT.
  251.     bool knownBitsLE(EVT VT) const {
  252.       return TypeSize::isKnownLE(getSizeInBits(), VT.getSizeInBits());
  253.     }
  254.  
  255.     /// Return true if this has more bits than VT.
  256.     bool bitsGT(EVT VT) const {
  257.       if (EVT::operator==(VT)) return false;
  258.       assert(isScalableVector() == VT.isScalableVector() &&
  259.              "Comparison between scalable and fixed types");
  260.       return knownBitsGT(VT);
  261.     }
  262.  
  263.     /// Return true if this has no less bits than VT.
  264.     bool bitsGE(EVT VT) const {
  265.       if (EVT::operator==(VT)) return true;
  266.       assert(isScalableVector() == VT.isScalableVector() &&
  267.              "Comparison between scalable and fixed types");
  268.       return knownBitsGE(VT);
  269.     }
  270.  
  271.     /// Return true if this has less bits than VT.
  272.     bool bitsLT(EVT VT) const {
  273.       if (EVT::operator==(VT)) return false;
  274.       assert(isScalableVector() == VT.isScalableVector() &&
  275.              "Comparison between scalable and fixed types");
  276.       return knownBitsLT(VT);
  277.     }
  278.  
  279.     /// Return true if this has no more bits than VT.
  280.     bool bitsLE(EVT VT) const {
  281.       if (EVT::operator==(VT)) return true;
  282.       assert(isScalableVector() == VT.isScalableVector() &&
  283.              "Comparison between scalable and fixed types");
  284.       return knownBitsLE(VT);
  285.     }
  286.  
  287.     /// Return the SimpleValueType held in the specified simple EVT.
  288.     MVT getSimpleVT() const {
  289.       assert(isSimple() && "Expected a SimpleValueType!");
  290.       return V;
  291.     }
  292.  
  293.     /// If this is a vector type, return the element type, otherwise return
  294.     /// this.
  295.     EVT getScalarType() const {
  296.       return isVector() ? getVectorElementType() : *this;
  297.     }
  298.  
  299.     /// Given a vector type, return the type of each element.
  300.     EVT getVectorElementType() const {
  301.       assert(isVector() && "Invalid vector type!");
  302.       if (isSimple())
  303.         return V.getVectorElementType();
  304.       return getExtendedVectorElementType();
  305.     }
  306.  
  307.     /// Given a vector type, return the number of elements it contains.
  308.     unsigned getVectorNumElements() const {
  309.       assert(isVector() && "Invalid vector type!");
  310.  
  311.       if (isScalableVector())
  312.         llvm::reportInvalidSizeRequest(
  313.             "Possible incorrect use of EVT::getVectorNumElements() for "
  314.             "scalable vector. Scalable flag may be dropped, use "
  315.             "EVT::getVectorElementCount() instead");
  316.  
  317.       return isSimple() ? V.getVectorNumElements()
  318.                         : getExtendedVectorNumElements();
  319.     }
  320.  
  321.     // Given a (possibly scalable) vector type, return the ElementCount
  322.     ElementCount getVectorElementCount() const {
  323.       assert((isVector()) && "Invalid vector type!");
  324.       if (isSimple())
  325.         return V.getVectorElementCount();
  326.  
  327.       return getExtendedVectorElementCount();
  328.     }
  329.  
  330.     /// Given a vector type, return the minimum number of elements it contains.
  331.     unsigned getVectorMinNumElements() const {
  332.       return getVectorElementCount().getKnownMinValue();
  333.     }
  334.  
  335.     /// Return the size of the specified value type in bits.
  336.     ///
  337.     /// If the value type is a scalable vector type, the scalable property will
  338.     /// be set and the runtime size will be a positive integer multiple of the
  339.     /// base size.
  340.     TypeSize getSizeInBits() const {
  341.       if (isSimple())
  342.         return V.getSizeInBits();
  343.       return getExtendedSizeInBits();
  344.     }
  345.  
  346.     /// Return the size of the specified fixed width value type in bits. The
  347.     /// function will assert if the type is scalable.
  348.     uint64_t getFixedSizeInBits() const {
  349.       return getSizeInBits().getFixedValue();
  350.     }
  351.  
  352.     uint64_t getScalarSizeInBits() const {
  353.       return getScalarType().getSizeInBits().getFixedValue();
  354.     }
  355.  
  356.     /// Return the number of bytes overwritten by a store of the specified value
  357.     /// type.
  358.     ///
  359.     /// If the value type is a scalable vector type, the scalable property will
  360.     /// be set and the runtime size will be a positive integer multiple of the
  361.     /// base size.
  362.     TypeSize getStoreSize() const {
  363.       TypeSize BaseSize = getSizeInBits();
  364.       return {(BaseSize.getKnownMinValue() + 7) / 8, BaseSize.isScalable()};
  365.     }
  366.  
  367.     // Return the number of bytes overwritten by a store of this value type or
  368.     // this value type's element type in the case of a vector.
  369.     uint64_t getScalarStoreSize() const {
  370.       return getScalarType().getStoreSize().getFixedValue();
  371.     }
  372.  
  373.     /// Return the number of bits overwritten by a store of the specified value
  374.     /// type.
  375.     ///
  376.     /// If the value type is a scalable vector type, the scalable property will
  377.     /// be set and the runtime size will be a positive integer multiple of the
  378.     /// base size.
  379.     TypeSize getStoreSizeInBits() const {
  380.       return getStoreSize() * 8;
  381.     }
  382.  
  383.     /// Rounds the bit-width of the given integer EVT up to the nearest power of
  384.     /// two (and at least to eight), and returns the integer EVT with that
  385.     /// number of bits.
  386.     EVT getRoundIntegerType(LLVMContext &Context) const {
  387.       assert(isInteger() && !isVector() && "Invalid integer type!");
  388.       unsigned BitWidth = getSizeInBits();
  389.       if (BitWidth <= 8)
  390.         return EVT(MVT::i8);
  391.       return getIntegerVT(Context, llvm::bit_ceil(BitWidth));
  392.     }
  393.  
  394.     /// Finds the smallest simple value type that is greater than or equal to
  395.     /// half the width of this EVT. If no simple value type can be found, an
  396.     /// extended integer value type of half the size (rounded up) is returned.
  397.     EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
  398.       assert(isInteger() && !isVector() && "Invalid integer type!");
  399.       unsigned EVTSize = getSizeInBits();
  400.       for (unsigned IntVT = MVT::FIRST_INTEGER_VALUETYPE;
  401.           IntVT <= MVT::LAST_INTEGER_VALUETYPE; ++IntVT) {
  402.         EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
  403.         if (HalfVT.getSizeInBits() * 2 >= EVTSize)
  404.           return HalfVT;
  405.       }
  406.       return getIntegerVT(Context, (EVTSize + 1) / 2);
  407.     }
  408.  
  409.     /// Return a VT for an integer vector type with the size of the
  410.     /// elements doubled. The typed returned may be an extended type.
  411.     EVT widenIntegerVectorElementType(LLVMContext &Context) const {
  412.       EVT EltVT = getVectorElementType();
  413.       EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
  414.       return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
  415.     }
  416.  
  417.     // Return a VT for a vector type with the same element type but
  418.     // half the number of elements. The type returned may be an
  419.     // extended type.
  420.     EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
  421.       EVT EltVT = getVectorElementType();
  422.       auto EltCnt = getVectorElementCount();
  423.       assert(EltCnt.isKnownEven() && "Splitting vector, but not in half!");
  424.       return EVT::getVectorVT(Context, EltVT, EltCnt.divideCoefficientBy(2));
  425.     }
  426.  
  427.     // Return a VT for a vector type with the same element type but
  428.     // double the number of elements. The type returned may be an
  429.     // extended type.
  430.     EVT getDoubleNumVectorElementsVT(LLVMContext &Context) const {
  431.       EVT EltVT = getVectorElementType();
  432.       auto EltCnt = getVectorElementCount();
  433.       return EVT::getVectorVT(Context, EltVT, EltCnt * 2);
  434.     }
  435.  
  436.     /// Returns true if the given vector is a power of 2.
  437.     bool isPow2VectorType() const {
  438.       unsigned NElts = getVectorMinNumElements();
  439.       return !(NElts & (NElts - 1));
  440.     }
  441.  
  442.     /// Widens the length of the given vector EVT up to the nearest power of 2
  443.     /// and returns that type.
  444.     EVT getPow2VectorType(LLVMContext &Context) const {
  445.       if (!isPow2VectorType()) {
  446.         ElementCount NElts = getVectorElementCount();
  447.         unsigned NewMinCount = 1 << Log2_32_Ceil(NElts.getKnownMinValue());
  448.         NElts = ElementCount::get(NewMinCount, NElts.isScalable());
  449.         return EVT::getVectorVT(Context, getVectorElementType(), NElts);
  450.       }
  451.       else {
  452.         return *this;
  453.       }
  454.     }
  455.  
  456.     /// This function returns value type as a string, e.g. "i32".
  457.     std::string getEVTString() const;
  458.  
  459.     /// This method returns an LLVM type corresponding to the specified EVT.
  460.     /// For integer types, this returns an unsigned type. Note that this will
  461.     /// abort for types that cannot be represented.
  462.     Type *getTypeForEVT(LLVMContext &Context) const;
  463.  
  464.     /// Return the value type corresponding to the specified type.
  465.     /// This returns all pointers as iPTR.  If HandleUnknown is true, unknown
  466.     /// types are returned as Other, otherwise they are invalid.
  467.     static EVT getEVT(Type *Ty, bool HandleUnknown = false);
  468.  
  469.     intptr_t getRawBits() const {
  470.       if (isSimple())
  471.         return V.SimpleTy;
  472.       else
  473.         return (intptr_t)(LLVMTy);
  474.     }
  475.  
  476.     /// A meaningless but well-behaved order, useful for constructing
  477.     /// containers.
  478.     struct compareRawBits {
  479.       bool operator()(EVT L, EVT R) const {
  480.         if (L.V.SimpleTy == R.V.SimpleTy)
  481.           return L.LLVMTy < R.LLVMTy;
  482.         else
  483.           return L.V.SimpleTy < R.V.SimpleTy;
  484.       }
  485.     };
  486.  
  487.   private:
  488.     // Methods for handling the Extended-type case in functions above.
  489.     // These are all out-of-line to prevent users of this header file
  490.     // from having a dependency on Type.h.
  491.     EVT changeExtendedTypeToInteger() const;
  492.     EVT changeExtendedVectorElementType(EVT EltVT) const;
  493.     EVT changeExtendedVectorElementTypeToInteger() const;
  494.     static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
  495.     static EVT getExtendedVectorVT(LLVMContext &C, EVT VT, unsigned NumElements,
  496.                                    bool IsScalable);
  497.     static EVT getExtendedVectorVT(LLVMContext &Context, EVT VT,
  498.                                    ElementCount EC);
  499.     bool isExtendedFloatingPoint() const LLVM_READONLY;
  500.     bool isExtendedInteger() const LLVM_READONLY;
  501.     bool isExtendedScalarInteger() const LLVM_READONLY;
  502.     bool isExtendedVector() const LLVM_READONLY;
  503.     bool isExtended16BitVector() const LLVM_READONLY;
  504.     bool isExtended32BitVector() const LLVM_READONLY;
  505.     bool isExtended64BitVector() const LLVM_READONLY;
  506.     bool isExtended128BitVector() const LLVM_READONLY;
  507.     bool isExtended256BitVector() const LLVM_READONLY;
  508.     bool isExtended512BitVector() const LLVM_READONLY;
  509.     bool isExtended1024BitVector() const LLVM_READONLY;
  510.     bool isExtended2048BitVector() const LLVM_READONLY;
  511.     bool isExtendedFixedLengthVector() const LLVM_READONLY;
  512.     bool isExtendedScalableVector() const LLVM_READONLY;
  513.     EVT getExtendedVectorElementType() const;
  514.     unsigned getExtendedVectorNumElements() const LLVM_READONLY;
  515.     ElementCount getExtendedVectorElementCount() const LLVM_READONLY;
  516.     TypeSize getExtendedSizeInBits() const LLVM_READONLY;
  517.   };
  518.  
  519. } // end namespace llvm
  520.  
  521. #endif // LLVM_CODEGEN_VALUETYPES_H
  522.