LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - MachineValueType.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 242 307 78.8 %
Date: 2017-09-14 15:23:50 Functions: 16 16 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- CodeGen/MachineValueType.h - Machine-Level 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 machine-level target independent types which
      11             : // legal values in the code generator use.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_CODEGEN_MACHINEVALUETYPE_H
      16             : #define LLVM_CODEGEN_MACHINEVALUETYPE_H
      17             : 
      18             : #include "llvm/ADT/iterator_range.h"
      19             : #include "llvm/Support/ErrorHandling.h"
      20             : #include "llvm/Support/MathExtras.h"
      21             : #include <cassert>
      22             : 
      23             : namespace llvm {
      24             : 
      25             :   class Type;
      26             : 
      27             :   /// Machine Value Type. Every type that is supported natively by some
      28             :   /// processor targeted by LLVM occurs here. This means that any legal value
      29             :   /// type can be represented by an MVT.
      30             :   class MVT {
      31             :   public:
      32             :     enum SimpleValueType : uint8_t {
      33             :       // Simple value types that aren't explicitly part of this enumeration
      34             :       // are considered extended value types.
      35             :       INVALID_SIMPLE_VALUE_TYPE = 0,
      36             : 
      37             :       // If you change this numbering, you must change the values in
      38             :       // ValueTypes.td as well!
      39             :       Other          =   1,   // This is a non-standard value
      40             :       i1             =   2,   // This is a 1 bit integer value
      41             :       i8             =   3,   // This is an 8 bit integer value
      42             :       i16            =   4,   // This is a 16 bit integer value
      43             :       i32            =   5,   // This is a 32 bit integer value
      44             :       i64            =   6,   // This is a 64 bit integer value
      45             :       i128           =   7,   // This is a 128 bit integer value
      46             : 
      47             :       FIRST_INTEGER_VALUETYPE = i1,
      48             :       LAST_INTEGER_VALUETYPE  = i128,
      49             : 
      50             :       f16            =   8,   // This is a 16 bit floating point value
      51             :       f32            =   9,   // This is a 32 bit floating point value
      52             :       f64            =  10,   // This is a 64 bit floating point value
      53             :       f80            =  11,   // This is a 80 bit floating point value
      54             :       f128           =  12,   // This is a 128 bit floating point value
      55             :       ppcf128        =  13,   // This is a PPC 128-bit floating point value
      56             : 
      57             :       FIRST_FP_VALUETYPE = f16,
      58             :       LAST_FP_VALUETYPE  = ppcf128,
      59             : 
      60             :       v1i1           =  14,   //    1 x i1
      61             :       v2i1           =  15,   //    2 x i1
      62             :       v4i1           =  16,   //    4 x i1
      63             :       v8i1           =  17,   //    8 x i1
      64             :       v16i1          =  18,   //   16 x i1
      65             :       v32i1          =  19,   //   32 x i1
      66             :       v64i1          =  20,   //   64 x i1
      67             :       v512i1         =  21,   //  512 x i1
      68             :       v1024i1        =  22,   // 1024 x i1
      69             : 
      70             :       v1i8           =  23,   //  1 x i8
      71             :       v2i8           =  24,   //  2 x i8
      72             :       v4i8           =  25,   //  4 x i8
      73             :       v8i8           =  26,   //  8 x i8
      74             :       v16i8          =  27,   // 16 x i8
      75             :       v32i8          =  28,   // 32 x i8
      76             :       v64i8          =  29,   // 64 x i8
      77             :       v128i8         =  30,   //128 x i8
      78             :       v256i8         =  31,   //256 x i8
      79             : 
      80             :       v1i16          =  32,   //  1 x i16
      81             :       v2i16          =  33,   //  2 x i16
      82             :       v4i16          =  34,   //  4 x i16
      83             :       v8i16          =  35,   //  8 x i16
      84             :       v16i16         =  36,   // 16 x i16
      85             :       v32i16         =  37,   // 32 x i16
      86             :       v64i16         =  38,   // 64 x i16
      87             :       v128i16        =  39,   //128 x i16
      88             : 
      89             :       v1i32          =  40,   //  1 x i32
      90             :       v2i32          =  41,   //  2 x i32
      91             :       v4i32          =  42,   //  4 x i32
      92             :       v8i32          =  43,   //  8 x i32
      93             :       v16i32         =  44,   // 16 x i32
      94             :       v32i32         =  45,   // 32 x i32
      95             :       v64i32         =  46,   // 64 x i32
      96             : 
      97             :       v1i64          =  47,   //  1 x i64
      98             :       v2i64          =  48,   //  2 x i64
      99             :       v4i64          =  49,   //  4 x i64
     100             :       v8i64          =  50,   //  8 x i64
     101             :       v16i64         =  51,   // 16 x i64
     102             :       v32i64         =  52,   // 32 x i64
     103             : 
     104             :       v1i128         =  53,   //  1 x i128
     105             : 
     106             :       // Scalable integer types
     107             :       nxv1i1         =  54,   // n x  1 x i1
     108             :       nxv2i1         =  55,   // n x  2 x i1
     109             :       nxv4i1         =  56,   // n x  4 x i1
     110             :       nxv8i1         =  57,   // n x  8 x i1
     111             :       nxv16i1        =  58,   // n x 16 x i1
     112             :       nxv32i1        =  59,   // n x 32 x i1
     113             : 
     114             :       nxv1i8         =  60,   // n x  1 x i8
     115             :       nxv2i8         =  61,   // n x  2 x i8
     116             :       nxv4i8         =  62,   // n x  4 x i8
     117             :       nxv8i8         =  63,   // n x  8 x i8
     118             :       nxv16i8        =  64,   // n x 16 x i8
     119             :       nxv32i8        =  65,   // n x 32 x i8
     120             : 
     121             :       nxv1i16        =  66,   // n x  1 x i16
     122             :       nxv2i16        =  67,   // n x  2 x i16
     123             :       nxv4i16        =  68,   // n x  4 x i16
     124             :       nxv8i16        =  69,   // n x  8 x i16
     125             :       nxv16i16       =  70,   // n x 16 x i16
     126             :       nxv32i16       =  71,   // n x 32 x i16
     127             : 
     128             :       nxv1i32        =  72,   // n x  1 x i32
     129             :       nxv2i32        =  73,   // n x  2 x i32
     130             :       nxv4i32        =  74,   // n x  4 x i32
     131             :       nxv8i32        =  75,   // n x  8 x i32
     132             :       nxv16i32       =  76,   // n x 16 x i32
     133             :       nxv32i32       =  77,   // n x 32 x i32
     134             : 
     135             :       nxv1i64        =  78,   // n x  1 x i64
     136             :       nxv2i64        =  79,   // n x  2 x i64
     137             :       nxv4i64        =  80,   // n x  4 x i64
     138             :       nxv8i64        =  81,   // n x  8 x i64
     139             :       nxv16i64       =  82,   // n x 16 x i64
     140             :       nxv32i64       =  83,   // n x 32 x i64
     141             : 
     142             :       FIRST_INTEGER_VECTOR_VALUETYPE = v1i1,
     143             :       LAST_INTEGER_VECTOR_VALUETYPE = nxv32i64,
     144             : 
     145             :       FIRST_INTEGER_SCALABLE_VALUETYPE = nxv1i1,
     146             :       LAST_INTEGER_SCALABLE_VALUETYPE = nxv32i64,
     147             : 
     148             :       v2f16          =  84,   //  2 x f16
     149             :       v4f16          =  85,   //  4 x f16
     150             :       v8f16          =  86,   //  8 x f16
     151             :       v1f32          =  87,   //  1 x f32
     152             :       v2f32          =  88,   //  2 x f32
     153             :       v4f32          =  89,   //  4 x f32
     154             :       v8f32          =  90,   //  8 x f32
     155             :       v16f32         =  91,   // 16 x f32
     156             :       v1f64          =  92,   //  1 x f64
     157             :       v2f64          =  93,   //  2 x f64
     158             :       v4f64          =  94,   //  4 x f64
     159             :       v8f64          =  95,   //  8 x f64
     160             : 
     161             :       nxv2f16        =  96,   // n x  2 x f16
     162             :       nxv4f16        =  97,   // n x  4 x f16
     163             :       nxv8f16        =  98,   // n x  8 x f16
     164             :       nxv1f32        =  99,   // n x  1 x f32
     165             :       nxv2f32        = 100,   // n x  2 x f32
     166             :       nxv4f32        = 101,   // n x  4 x f32
     167             :       nxv8f32        = 102,   // n x  8 x f32
     168             :       nxv16f32       = 103,   // n x 16 x f32
     169             :       nxv1f64        = 104,   // n x  1 x f64
     170             :       nxv2f64        = 105,   // n x  2 x f64
     171             :       nxv4f64        = 106,   // n x  4 x f64
     172             :       nxv8f64        = 107,   // n x  8 x f64
     173             : 
     174             :       FIRST_FP_VECTOR_VALUETYPE = v2f16,
     175             :       LAST_FP_VECTOR_VALUETYPE = nxv8f64,
     176             : 
     177             :       FIRST_FP_SCALABLE_VALUETYPE = nxv2f16,
     178             :       LAST_FP_SCALABLE_VALUETYPE = nxv8f64,
     179             : 
     180             :       FIRST_VECTOR_VALUETYPE = v1i1,
     181             :       LAST_VECTOR_VALUETYPE  = nxv8f64,
     182             : 
     183             :       x86mmx         =  108,   // This is an X86 MMX value
     184             : 
     185             :       Glue           =  109,   // This glues nodes together during pre-RA sched
     186             : 
     187             :       isVoid         =  110,   // This has no value
     188             : 
     189             :       Untyped        =  111,   // This value takes a register, but has
     190             :                                // unspecified type.  The register class
     191             :                                // will be determined by the opcode.
     192             : 
     193             :       FIRST_VALUETYPE = 1,     // This is always the beginning of the list.
     194             :       LAST_VALUETYPE =  112,   // This always remains at the end of the list.
     195             : 
     196             :       // This is the current maximum for LAST_VALUETYPE.
     197             :       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
     198             :       // This value must be a multiple of 32.
     199             :       MAX_ALLOWED_VALUETYPE = 128,
     200             : 
     201             :       // A value of type llvm::TokenTy
     202             :       token          = 248,
     203             : 
     204             :       // This is MDNode or MDString.
     205             :       Metadata       = 249,
     206             : 
     207             :       // An int value the size of the pointer of the current
     208             :       // target to any address space. This must only be used internal to
     209             :       // tblgen. Other than for overloading, we treat iPTRAny the same as iPTR.
     210             :       iPTRAny        = 250,
     211             : 
     212             :       // A vector with any length and element size. This is used
     213             :       // for intrinsics that have overloadings based on vector types.
     214             :       // This is only for tblgen's consumption!
     215             :       vAny           = 251,
     216             : 
     217             :       // Any floating-point or vector floating-point value. This is used
     218             :       // for intrinsics that have overloadings based on floating-point types.
     219             :       // This is only for tblgen's consumption!
     220             :       fAny           = 252,
     221             : 
     222             :       // An integer or vector integer value of any bit width. This is
     223             :       // used for intrinsics that have overloadings based on integer bit widths.
     224             :       // This is only for tblgen's consumption!
     225             :       iAny           = 253,
     226             : 
     227             :       // An int value the size of the pointer of the current
     228             :       // target.  This should only be used internal to tblgen!
     229             :       iPTR           = 254,
     230             : 
     231             :       // Any type. This is used for intrinsics that have overloadings.
     232             :       // This is only for tblgen's consumption!
     233             :       Any            = 255
     234             :     };
     235             : 
     236             :     SimpleValueType SimpleTy = INVALID_SIMPLE_VALUE_TYPE;
     237             : 
     238             :     // A class to represent the number of elements in a vector
     239             :     //
     240             :     // For fixed-length vectors, the total number of elements is equal to 'Min'
     241             :     // For scalable vectors, the total number of elements is a multiple of 'Min'
     242             :     class ElementCount {
     243             :     public:
     244             :       unsigned Min;
     245             :       bool Scalable;
     246             : 
     247             :       ElementCount(unsigned Min, bool Scalable)
     248       99488 :       : Min(Min), Scalable(Scalable) {}
     249             : 
     250             :       ElementCount operator*(unsigned RHS) {
     251           1 :         return { Min * RHS, Scalable };
     252             :       }
     253             : 
     254             :       ElementCount& operator*=(unsigned RHS) {
     255             :         Min *= RHS;
     256             :         return *this;
     257             :       }
     258             : 
     259             :       ElementCount operator/(unsigned RHS) {
     260       99059 :         return { Min / RHS, Scalable };
     261             :       }
     262             : 
     263             :       ElementCount& operator/=(unsigned RHS) {
     264             :         Min /= RHS;
     265             :         return *this;
     266             :       }
     267             : 
     268             :       bool operator==(const ElementCount& RHS) {
     269             :         return Min == RHS.Min && Scalable == RHS.Scalable;
     270             :       }
     271             :     };
     272             : 
     273     6359300 :     constexpr MVT() = default;
     274   171157197 :     constexpr MVT(SimpleValueType SVT) : SimpleTy(SVT) {}
     275             : 
     276           1 :     bool operator>(const MVT& S)  const { return SimpleTy >  S.SimpleTy; }
     277          61 :     bool operator<(const MVT& S)  const { return SimpleTy <  S.SimpleTy; }
     278   289701438 :     bool operator==(const MVT& S) const { return SimpleTy == S.SimpleTy; }
     279      188837 :     bool operator!=(const MVT& S) const { return SimpleTy != S.SimpleTy; }
     280             :     bool operator>=(const MVT& S) const { return SimpleTy >= S.SimpleTy; }
     281           1 :     bool operator<=(const MVT& S) const { return SimpleTy <= S.SimpleTy; }
     282             : 
     283             :     /// Return true if this is a valid simple valuetype.
     284             :     bool isValid() const {
     285      214315 :       return (SimpleTy >= MVT::FIRST_VALUETYPE &&
     286          42 :               SimpleTy < MVT::LAST_VALUETYPE);
     287             :     }
     288             : 
     289             :     /// Return true if this is a FP or a vector FP type.
     290             :     bool isFloatingPoint() const {
     291    13039832 :       return ((SimpleTy >= MVT::FIRST_FP_VALUETYPE &&
     292    24852852 :                SimpleTy <= MVT::LAST_FP_VALUETYPE) ||
     293             :               (SimpleTy >= MVT::FIRST_FP_VECTOR_VALUETYPE &&
     294    24852852 :                SimpleTy <= MVT::LAST_FP_VECTOR_VALUETYPE));
     295             :     }
     296             : 
     297             :     /// Return true if this is an integer or a vector integer type.
     298             :     bool isInteger() const {
     299      169246 :       return ((SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
     300     9725185 :                SimpleTy <= MVT::LAST_INTEGER_VALUETYPE) ||
     301             :               (SimpleTy >= MVT::FIRST_INTEGER_VECTOR_VALUETYPE &&
     302     9725164 :                SimpleTy <= MVT::LAST_INTEGER_VECTOR_VALUETYPE));
     303             :     }
     304             : 
     305             :     /// Return true if this is an integer, not including vectors.
     306             :     bool isScalarInteger() const {
     307     2497805 :       return (SimpleTy >= MVT::FIRST_INTEGER_VALUETYPE &&
     308     2497805 :               SimpleTy <= MVT::LAST_INTEGER_VALUETYPE);
     309             :     }
     310             : 
     311             :     /// Return true if this is a vector value type.
     312             :     bool isVector() const {
     313   186880524 :       return (SimpleTy >= MVT::FIRST_VECTOR_VALUETYPE &&
     314   128266120 :               SimpleTy <= MVT::LAST_VECTOR_VALUETYPE);
     315             :     }
     316             : 
     317             :     /// Return true if this is a vector value type where the
     318             :     /// runtime length is machine dependent
     319             :     bool isScalableVector() const {
     320       99529 :       return ((SimpleTy >= MVT::FIRST_INTEGER_SCALABLE_VALUETYPE &&
     321      115427 :                SimpleTy <= MVT::LAST_INTEGER_SCALABLE_VALUETYPE) ||
     322             :               (SimpleTy >= MVT::FIRST_FP_SCALABLE_VALUETYPE &&
     323      115427 :                SimpleTy <= MVT::LAST_FP_SCALABLE_VALUETYPE));
     324             :     }
     325             : 
     326             :     /// Return true if this is a 16-bit vector type.
     327             :     bool is16BitVector() const {
     328             :       return (SimpleTy == MVT::v2i8  || SimpleTy == MVT::v1i16 ||
     329             :               SimpleTy == MVT::v16i1);
     330             :     }
     331             : 
     332             :     /// Return true if this is a 32-bit vector type.
     333             :     bool is32BitVector() const {
     334        1628 :       return (SimpleTy == MVT::v32i1 || SimpleTy == MVT::v4i8  ||
     335         814 :               SimpleTy == MVT::v2i16 || SimpleTy == MVT::v1i32 ||
     336        1628 :               SimpleTy == MVT::v2f16 || SimpleTy == MVT::v1f32);
     337             :     }
     338             : 
     339             :     /// Return true if this is a 64-bit vector type.
     340       10291 :     bool is64BitVector() const {
     341       19872 :       return (SimpleTy == MVT::v64i1 || SimpleTy == MVT::v8i8  ||
     342        8467 :               SimpleTy == MVT::v4i16 || SimpleTy == MVT::v2i32 ||
     343        6738 :               SimpleTy == MVT::v1i64 || SimpleTy == MVT::v4f16 ||
     344       16805 :               SimpleTy == MVT::v2f32 || SimpleTy == MVT::v1f64);
     345             :     }
     346             : 
     347             :     /// Return true if this is a 128-bit vector type.
     348     2350213 :     bool is128BitVector() const {
     349     4492912 :       return (SimpleTy == MVT::v16i8  || SimpleTy == MVT::v8i16 ||
     350     2067342 :               SimpleTy == MVT::v4i32  || SimpleTy == MVT::v2i64 ||
     351     1583824 :               SimpleTy == MVT::v1i128 || SimpleTy == MVT::v8f16 ||
     352     3905458 :               SimpleTy == MVT::v4f32  || SimpleTy == MVT::v2f64);
     353             :     }
     354             : 
     355             :     /// Return true if this is a 256-bit vector type.
     356             :     bool is256BitVector() const {
     357    10155720 :       return (SimpleTy == MVT::v8f32 || SimpleTy == MVT::v4f64  ||
     358     5040166 :               SimpleTy == MVT::v32i8 || SimpleTy == MVT::v16i16 ||
     359    10076682 :               SimpleTy == MVT::v8i32 || SimpleTy == MVT::v4i64);
     360             :     }
     361             : 
     362             :     /// Return true if this is a 512-bit vector type.
     363             :     bool is512BitVector() const {
     364     3148815 :       return (SimpleTy == MVT::v16f32 || SimpleTy == MVT::v8f64  ||
     365     1571746 :               SimpleTy == MVT::v512i1 || SimpleTy == MVT::v64i8  ||
     366     3145357 :               SimpleTy == MVT::v32i16 || SimpleTy == MVT::v16i32 ||
     367             :               SimpleTy == MVT::v8i64);
     368             :     }
     369             : 
     370             :     /// Return true if this is a 1024-bit vector type.
     371             :     bool is1024BitVector() const {
     372             :       return (SimpleTy == MVT::v1024i1 || SimpleTy == MVT::v128i8 ||
     373             :               SimpleTy == MVT::v64i16  || SimpleTy == MVT::v32i32 ||
     374             :               SimpleTy == MVT::v16i64);
     375             :     }
     376             : 
     377             :     /// Return true if this is a 1024-bit vector type.
     378             :     bool is2048BitVector() const {
     379             :       return (SimpleTy == MVT::v256i8 || SimpleTy == MVT::v128i16 ||
     380             :               SimpleTy == MVT::v64i32 || SimpleTy == MVT::v32i64);
     381             :     }
     382             : 
     383             :     /// Return true if this is an overloaded type for TableGen.
     384             :     bool isOverloaded() const {
     385      861878 :       return (SimpleTy==MVT::Any  ||
     386      848442 :               SimpleTy==MVT::iAny || SimpleTy==MVT::fAny ||
     387     1675844 :               SimpleTy==MVT::vAny || SimpleTy==MVT::iPTRAny);
     388             :     }
     389             : 
     390             :     /// Returns true if the given vector is a power of 2.
     391             :     bool isPow2VectorType() const {
     392     2402011 :       unsigned NElts = getVectorNumElements();
     393     2402011 :       return !(NElts & (NElts - 1));
     394             :     }
     395             : 
     396             :     /// Widens the length of the given vector MVT up to the nearest power of 2
     397             :     /// and returns that type.
     398     2402011 :     MVT getPow2VectorType() const {
     399     2402011 :       if (isPow2VectorType())
     400     2402011 :         return *this;
     401             : 
     402           0 :       unsigned NElts = getVectorNumElements();
     403           0 :       unsigned Pow2NElts = 1 << Log2_32_Ceil(NElts);
     404           0 :       return MVT::getVectorVT(getVectorElementType(), Pow2NElts);
     405             :     }
     406             : 
     407             :     /// If this is a vector, return the element type, otherwise return this.
     408             :     MVT getScalarType() const {
     409    47808396 :       return isVector() ? getVectorElementType() : *this;
     410             :     }
     411             : 
     412   287934670 :     MVT getVectorElementType() const {
     413   287934670 :       switch (SimpleTy) {
     414           0 :       default:
     415           0 :         llvm_unreachable("Not a vector MVT!");
     416    35251423 :       case v1i1:
     417             :       case v2i1:
     418             :       case v4i1:
     419             :       case v8i1:
     420             :       case v16i1:
     421             :       case v32i1:
     422             :       case v64i1:
     423             :       case v512i1:
     424             :       case v1024i1:
     425             :       case nxv1i1:
     426             :       case nxv2i1:
     427             :       case nxv4i1:
     428             :       case nxv8i1:
     429             :       case nxv16i1:
     430    35251423 :       case nxv32i1: return i1;
     431    39671950 :       case v1i8:
     432             :       case v2i8:
     433             :       case v4i8:
     434             :       case v8i8:
     435             :       case v16i8:
     436             :       case v32i8:
     437             :       case v64i8:
     438             :       case v128i8:
     439             :       case v256i8:
     440             :       case nxv1i8:
     441             :       case nxv2i8:
     442             :       case nxv4i8:
     443             :       case nxv8i8:
     444             :       case nxv16i8:
     445    39671950 :       case nxv32i8: return i8;
     446    41245320 :       case v1i16:
     447             :       case v2i16:
     448             :       case v4i16:
     449             :       case v8i16:
     450             :       case v16i16:
     451             :       case v32i16:
     452             :       case v64i16:
     453             :       case v128i16:
     454             :       case nxv1i16:
     455             :       case nxv2i16:
     456             :       case nxv4i16:
     457             :       case nxv8i16:
     458             :       case nxv16i16:
     459    41245320 :       case nxv32i16: return i16;
     460    46054523 :       case v1i32:
     461             :       case v2i32:
     462             :       case v4i32:
     463             :       case v8i32:
     464             :       case v16i32:
     465             :       case v32i32:
     466             :       case v64i32:
     467             :       case nxv1i32:
     468             :       case nxv2i32:
     469             :       case nxv4i32:
     470             :       case nxv8i32:
     471             :       case nxv16i32:
     472    46054523 :       case nxv32i32: return i32;
     473    45075158 :       case v1i64:
     474             :       case v2i64:
     475             :       case v4i64:
     476             :       case v8i64:
     477             :       case v16i64:
     478             :       case v32i64:
     479             :       case nxv1i64:
     480             :       case nxv2i64:
     481             :       case nxv4i64:
     482             :       case nxv8i64:
     483             :       case nxv16i64:
     484    45075158 :       case nxv32i64: return i64;
     485     2980817 :       case v1i128: return i128;
     486    18771336 :       case v2f16:
     487             :       case v4f16:
     488             :       case v8f16:
     489             :       case nxv2f16:
     490             :       case nxv4f16:
     491    18771336 :       case nxv8f16: return f16;
     492    32331461 :       case v1f32:
     493             :       case v2f32:
     494             :       case v4f32:
     495             :       case v8f32:
     496             :       case v16f32:
     497             :       case nxv1f32:
     498             :       case nxv2f32:
     499             :       case nxv4f32:
     500             :       case nxv8f32:
     501    32331461 :       case nxv16f32: return f32;
     502    26552682 :       case v1f64:
     503             :       case v2f64:
     504             :       case v4f64:
     505             :       case v8f64:
     506             :       case nxv1f64:
     507             :       case nxv2f64:
     508             :       case nxv4f64:
     509    26552682 :       case nxv8f64: return f64;
     510             :       }
     511             :     }
     512             : 
     513   112219653 :     unsigned getVectorNumElements() const {
     514   112219653 :       switch (SimpleTy) {
     515           0 :       default:
     516           0 :         llvm_unreachable("Not a vector MVT!");
     517             :       case v1024i1: return 1024;
     518      216238 :       case v512i1: return 512;
     519      434932 :       case v256i8: return 256;
     520      982029 :       case v128i8:
     521      982029 :       case v128i16: return 128;
     522     1930138 :       case v64i1:
     523             :       case v64i8:
     524             :       case v64i16:
     525     1930138 :       case v64i32: return 64;
     526     7317270 :       case v32i1:
     527             :       case v32i8:
     528             :       case v32i16:
     529             :       case v32i32:
     530             :       case v32i64:
     531             :       case nxv32i1:
     532             :       case nxv32i8:
     533             :       case nxv32i16:
     534             :       case nxv32i32:
     535     7317270 :       case nxv32i64: return 32;
     536    11415319 :       case v16i1:
     537             :       case v16i8:
     538             :       case v16i16:
     539             :       case v16i32:
     540             :       case v16i64:
     541             :       case v16f32:
     542             :       case nxv16i1:
     543             :       case nxv16i8:
     544             :       case nxv16i16:
     545             :       case nxv16i32:
     546             :       case nxv16i64:
     547    11415319 :       case nxv16f32: return 16;
     548    10316279 :       case v8i1:
     549             :       case v8i8:
     550             :       case v8i16:
     551             :       case v8i32:
     552             :       case v8i64:
     553             :       case v8f16:
     554             :       case v8f32:
     555             :       case v8f64:
     556             :       case nxv8i1:
     557             :       case nxv8i8:
     558             :       case nxv8i16:
     559             :       case nxv8i32:
     560             :       case nxv8i64:
     561             :       case nxv8f16:
     562             :       case nxv8f32:
     563    10316279 :       case nxv8f64: return 8;
     564    62811653 :       case v4i1:
     565             :       case v4i8:
     566             :       case v4i16:
     567             :       case v4i32:
     568             :       case v4i64:
     569             :       case v4f16:
     570             :       case v4f32:
     571             :       case v4f64:
     572             :       case nxv4i1:
     573             :       case nxv4i8:
     574             :       case nxv4i16:
     575             :       case nxv4i32:
     576             :       case nxv4i64:
     577             :       case nxv4f16:
     578             :       case nxv4f32:
     579    62811653 :       case nxv4f64: return 4;
     580     8871687 :       case v2i1:
     581             :       case v2i8:
     582             :       case v2i16:
     583             :       case v2i32:
     584             :       case v2i64:
     585             :       case v2f16:
     586             :       case v2f32:
     587             :       case v2f64:
     588             :       case nxv2i1:
     589             :       case nxv2i8:
     590             :       case nxv2i16:
     591             :       case nxv2i32:
     592             :       case nxv2i64:
     593             :       case nxv2f16:
     594             :       case nxv2f32:
     595     8871687 :       case nxv2f64: return 2;
     596     7680931 :       case v1i1:
     597             :       case v1i8:
     598             :       case v1i16:
     599             :       case v1i32:
     600             :       case v1i64:
     601             :       case v1i128:
     602             :       case v1f32:
     603             :       case v1f64:
     604             :       case nxv1i1:
     605             :       case nxv1i8:
     606             :       case nxv1i16:
     607             :       case nxv1i32:
     608             :       case nxv1i64:
     609             :       case nxv1f32:
     610     7680931 :       case nxv1f64: return 1;
     611             :       }
     612             :     }
     613             : 
     614       99487 :     MVT::ElementCount getVectorElementCount() const {
     615      298461 :       return { getVectorNumElements(), isScalableVector() };
     616             :     }
     617             : 
     618   198038841 :     unsigned getSizeInBits() const {
     619   198038841 :       switch (SimpleTy) {
     620           0 :       default:
     621           0 :         llvm_unreachable("getSizeInBits called on extended MVT.");
     622           0 :       case Other:
     623           0 :         llvm_unreachable("Value type is non-standard value, Other.");
     624           0 :       case iPTR:
     625           0 :         llvm_unreachable("Value type size is target-dependent. Ask TLI.");
     626           0 :       case iPTRAny:
     627             :       case iAny:
     628             :       case fAny:
     629             :       case vAny:
     630             :       case Any:
     631           0 :         llvm_unreachable("Value type is overloaded.");
     632           0 :       case token:
     633           0 :         llvm_unreachable("Token type is a sentinel that cannot be used "
     634             :                          "in codegen and has no size");
     635           0 :       case Metadata:
     636           0 :         llvm_unreachable("Value type is metadata.");
     637             :       case i1:
     638             :       case v1i1:
     639             :       case nxv1i1: return 1;
     640       58388 :       case v2i1:
     641       58388 :       case nxv2i1: return 2;
     642       68479 :       case v4i1:
     643       68479 :       case nxv4i1: return 4;
     644    26263115 :       case i8  :
     645             :       case v1i8:
     646             :       case v8i1:
     647             :       case nxv1i8:
     648    26263115 :       case nxv8i1: return 8;
     649    21538471 :       case i16 :
     650             :       case f16:
     651             :       case v16i1:
     652             :       case v2i8:
     653             :       case v1i16:
     654             :       case nxv16i1:
     655             :       case nxv2i8:
     656    21538471 :       case nxv1i16: return 16;
     657    54314523 :       case f32 :
     658             :       case i32 :
     659             :       case v32i1:
     660             :       case v4i8:
     661             :       case v2i16:
     662             :       case v2f16:
     663             :       case v1f32:
     664             :       case v1i32:
     665             :       case nxv32i1:
     666             :       case nxv4i8:
     667             :       case nxv2i16:
     668             :       case nxv1i32:
     669             :       case nxv2f16:
     670    54314523 :       case nxv1f32: return 32;
     671    36419448 :       case x86mmx:
     672             :       case f64 :
     673             :       case i64 :
     674             :       case v64i1:
     675             :       case v8i8:
     676             :       case v4i16:
     677             :       case v2i32:
     678             :       case v1i64:
     679             :       case v4f16:
     680             :       case v2f32:
     681             :       case v1f64:
     682             :       case nxv8i8:
     683             :       case nxv4i16:
     684             :       case nxv2i32:
     685             :       case nxv1i64:
     686             :       case nxv4f16:
     687             :       case nxv2f32:
     688    36419448 :       case nxv1f64: return 64;
     689      964254 :       case f80 :  return 80;
     690    32563230 :       case f128:
     691             :       case ppcf128:
     692             :       case i128:
     693             :       case v16i8:
     694             :       case v8i16:
     695             :       case v4i32:
     696             :       case v2i64:
     697             :       case v1i128:
     698             :       case v8f16:
     699             :       case v4f32:
     700             :       case v2f64:
     701             :       case nxv16i8:
     702             :       case nxv8i16:
     703             :       case nxv4i32:
     704             :       case nxv2i64:
     705             :       case nxv8f16:
     706             :       case nxv4f32:
     707    32563230 :       case nxv2f64: return 128;
     708     1588945 :       case v32i8:
     709             :       case v16i16:
     710             :       case v8i32:
     711             :       case v4i64:
     712             :       case v8f32:
     713             :       case v4f64:
     714             :       case nxv32i8:
     715             :       case nxv16i16:
     716             :       case nxv8i32:
     717             :       case nxv4i64:
     718             :       case nxv8f32:
     719     1588945 :       case nxv4f64: return 256;
     720     1009509 :       case v512i1:
     721             :       case v64i8:
     722             :       case v32i16:
     723             :       case v16i32:
     724             :       case v8i64:
     725             :       case v16f32:
     726             :       case v8f64:
     727             :       case nxv32i16:
     728             :       case nxv16i32:
     729             :       case nxv8i64:
     730             :       case nxv16f32:
     731     1009509 :       case nxv8f64: return 512;
     732       60114 :       case v1024i1:
     733             :       case v128i8:
     734             :       case v64i16:
     735             :       case v32i32:
     736             :       case v16i64:
     737             :       case nxv32i32:
     738       60114 :       case nxv16i64: return 1024;
     739       36731 :       case v256i8:
     740             :       case v128i16:
     741             :       case v64i32:
     742             :       case v32i64:
     743       36731 :       case nxv32i64: return 2048;
     744             :       }
     745             :     }
     746             : 
     747    47786567 :     unsigned getScalarSizeInBits() const {
     748    47786567 :       return getScalarType().getSizeInBits();
     749             :     }
     750             : 
     751             :     /// Return the number of bytes overwritten by a store of the specified value
     752             :     /// type.
     753             :     unsigned getStoreSize() const {
     754      597244 :       return (getSizeInBits() + 7) / 8;
     755             :     }
     756             : 
     757             :     /// Return the number of bits overwritten by a store of the specified value
     758             :     /// type.
     759             :     unsigned getStoreSizeInBits() const {
     760          49 :       return getStoreSize() * 8;
     761             :     }
     762             : 
     763             :     /// Return true if this has more bits than VT.
     764             :     bool bitsGT(MVT VT) const {
     765        1563 :       return getSizeInBits() > VT.getSizeInBits();
     766             :     }
     767             : 
     768             :     /// Return true if this has no less bits than VT.
     769             :     bool bitsGE(MVT VT) const {
     770         154 :       return getSizeInBits() >= VT.getSizeInBits();
     771             :     }
     772             : 
     773             :     /// Return true if this has less bits than VT.
     774             :     bool bitsLT(MVT VT) const {
     775         791 :       return getSizeInBits() < VT.getSizeInBits();
     776             :     }
     777             : 
     778             :     /// Return true if this has no more bits than VT.
     779             :     bool bitsLE(MVT VT) const {
     780             :       return getSizeInBits() <= VT.getSizeInBits();
     781             :     }
     782             : 
     783             :     static MVT getFloatingPointVT(unsigned BitWidth) {
     784       14401 :       switch (BitWidth) {
     785           0 :       default:
     786           0 :         llvm_unreachable("Bad bit width!");
     787             :       case 16:
     788             :         return MVT::f16;
     789        7316 :       case 32:
     790        7316 :         return MVT::f32;
     791        7809 :       case 64:
     792        7809 :         return MVT::f64;
     793           0 :       case 80:
     794           0 :         return MVT::f80;
     795           0 :       case 128:
     796           0 :         return MVT::f128;
     797             :       }
     798             :     }
     799             : 
     800    11249825 :     static MVT getIntegerVT(unsigned BitWidth) {
     801    11249825 :       switch (BitWidth) {
     802      346819 :       default:
     803      346819 :         return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
     804      255907 :       case 1:
     805      255907 :         return MVT::i1;
     806      512370 :       case 8:
     807      512370 :         return MVT::i8;
     808      374278 :       case 16:
     809      374278 :         return MVT::i16;
     810     4463782 :       case 32:
     811     4463782 :         return MVT::i32;
     812     5071201 :       case 64:
     813     5071201 :         return MVT::i64;
     814      225468 :       case 128:
     815      225468 :         return MVT::i128;
     816             :       }
     817             :     }
     818             : 
     819    11084563 :     static MVT getVectorVT(MVT VT, unsigned NumElements) {
     820    11084563 :       switch (VT.SimpleTy) {
     821             :       default:
     822             :         break;
     823     1847985 :       case MVT::i1:
     824     1847985 :         if (NumElements == 1)    return MVT::v1i1;
     825     1475353 :         if (NumElements == 2)    return MVT::v2i1;
     826     1154820 :         if (NumElements == 4)    return MVT::v4i1;
     827      874248 :         if (NumElements == 8)    return MVT::v8i1;
     828      629950 :         if (NumElements == 16)   return MVT::v16i1;
     829      433254 :         if (NumElements == 32)   return MVT::v32i1;
     830      287752 :         if (NumElements == 64)   return MVT::v64i1;
     831      199322 :         if (NumElements == 512)  return MVT::v512i1;
     832      142016 :         if (NumElements == 1024) return MVT::v1024i1;
     833             :         break;
     834     1707445 :       case MVT::i8:
     835     1707445 :         if (NumElements == 1)   return MVT::v1i8;
     836     1399567 :         if (NumElements == 2)   return MVT::v2i8;
     837     1147876 :         if (NumElements == 4)   return MVT::v4i8;
     838      938104 :         if (NumElements == 8)   return MVT::v8i8;
     839      757508 :         if (NumElements == 16)  return MVT::v16i8;
     840      412563 :         if (NumElements == 32)  return MVT::v32i8;
     841      226961 :         if (NumElements == 64)  return MVT::v64i8;
     842      124729 :         if (NumElements == 128) return MVT::v128i8;
     843       67353 :         if (NumElements == 256) return MVT::v256i8;
     844             :         break;
     845     1553766 :       case MVT::i16:
     846     1553766 :         if (NumElements == 1)   return MVT::v1i16;
     847     1274673 :         if (NumElements == 2)   return MVT::v2i16;
     848     1046324 :         if (NumElements == 4)   return MVT::v4i16;
     849      844116 :         if (NumElements == 8)   return MVT::v8i16;
     850      441863 :         if (NumElements == 16)  return MVT::v16i16;
     851      221916 :         if (NumElements == 32)  return MVT::v32i16;
     852       92253 :         if (NumElements == 64)  return MVT::v64i16;
     853       34799 :         if (NumElements == 128) return MVT::v128i16;
     854             :         break;
     855     1715809 :       case MVT::i32:
     856     1715809 :         if (NumElements == 1)  return MVT::v1i32;
     857     1444931 :         if (NumElements == 2)  return MVT::v2i32;
     858     1202713 :         if (NumElements == 4)  return MVT::v4i32;
     859      618323 :         if (NumElements == 8)  return MVT::v8i32;
     860      360152 :         if (NumElements == 16) return MVT::v16i32;
     861      170280 :         if (NumElements == 32) return MVT::v32i32;
     862       76396 :         if (NumElements == 64) return MVT::v64i32;
     863             :         break;
     864     1926996 :       case MVT::i64:
     865     1926996 :         if (NumElements == 1)  return MVT::v1i64;
     866     1708671 :         if (NumElements == 2)  return MVT::v2i64;
     867      685848 :         if (NumElements == 4)  return MVT::v4i64;
     868      392536 :         if (NumElements == 8)  return MVT::v8i64;
     869      187786 :         if (NumElements == 16) return MVT::v16i64;
     870       67494 :         if (NumElements == 32) return MVT::v32i64;
     871             :         break;
     872       36389 :       case MVT::i128:
     873       36389 :         if (NumElements == 1)  return MVT::v1i128;
     874             :         break;
     875      722762 :       case MVT::f16:
     876      722762 :         if (NumElements == 2)  return MVT::v2f16;
     877      497838 :         if (NumElements == 4)  return MVT::v4f16;
     878      331888 :         if (NumElements == 8)  return MVT::v8f16;
     879             :         break;
     880      907103 :       case MVT::f32:
     881      907103 :         if (NumElements == 1)  return MVT::v1f32;
     882      725268 :         if (NumElements == 2)  return MVT::v2f32;
     883      577969 :         if (NumElements == 4)  return MVT::v4f32;
     884      262782 :         if (NumElements == 8)  return MVT::v8f32;
     885       96519 :         if (NumElements == 16) return MVT::v16f32;
     886             :         break;
     887      655654 :       case MVT::f64:
     888      655654 :         if (NumElements == 1)  return MVT::v1f64;
     889      508651 :         if (NumElements == 2)  return MVT::v2f64;
     890      237227 :         if (NumElements == 4)  return MVT::v4f64;
     891       86144 :         if (NumElements == 8)  return MVT::v8f64;
     892             :         break;
     893             :       }
     894      465689 :       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
     895             :     }
     896             : 
     897           9 :     static MVT getScalableVectorVT(MVT VT, unsigned NumElements) {
     898           9 :       switch(VT.SimpleTy) {
     899             :         default:
     900             :           break;
     901           0 :         case MVT::i1:
     902           0 :           if (NumElements == 1)  return MVT::nxv1i1;
     903           0 :           if (NumElements == 2)  return MVT::nxv2i1;
     904           0 :           if (NumElements == 4)  return MVT::nxv4i1;
     905           0 :           if (NumElements == 8)  return MVT::nxv8i1;
     906           0 :           if (NumElements == 16) return MVT::nxv16i1;
     907           0 :           if (NumElements == 32) return MVT::nxv32i1;
     908             :           break;
     909           0 :         case MVT::i8:
     910           0 :           if (NumElements == 1)  return MVT::nxv1i8;
     911           0 :           if (NumElements == 2)  return MVT::nxv2i8;
     912           0 :           if (NumElements == 4)  return MVT::nxv4i8;
     913           0 :           if (NumElements == 8)  return MVT::nxv8i8;
     914           0 :           if (NumElements == 16) return MVT::nxv16i8;
     915           0 :           if (NumElements == 32) return MVT::nxv32i8;
     916             :           break;
     917           0 :         case MVT::i16:
     918           0 :           if (NumElements == 1)  return MVT::nxv1i16;
     919           0 :           if (NumElements == 2)  return MVT::nxv2i16;
     920           0 :           if (NumElements == 4)  return MVT::nxv4i16;
     921           0 :           if (NumElements == 8)  return MVT::nxv8i16;
     922           0 :           if (NumElements == 16) return MVT::nxv16i16;
     923           0 :           if (NumElements == 32) return MVT::nxv32i16;
     924             :           break;
     925           3 :         case MVT::i32:
     926           3 :           if (NumElements == 1)  return MVT::nxv1i32;
     927           3 :           if (NumElements == 2)  return MVT::nxv2i32;
     928           1 :           if (NumElements == 4)  return MVT::nxv4i32;
     929           0 :           if (NumElements == 8)  return MVT::nxv8i32;
     930           0 :           if (NumElements == 16) return MVT::nxv16i32;
     931           0 :           if (NumElements == 32) return MVT::nxv32i32;
     932             :           break;
     933           5 :         case MVT::i64:
     934           5 :           if (NumElements == 1)  return MVT::nxv1i64;
     935           4 :           if (NumElements == 2)  return MVT::nxv2i64;
     936           1 :           if (NumElements == 4)  return MVT::nxv4i64;
     937           0 :           if (NumElements == 8)  return MVT::nxv8i64;
     938           0 :           if (NumElements == 16) return MVT::nxv16i64;
     939           0 :           if (NumElements == 32) return MVT::nxv32i64;
     940             :           break;
     941           0 :         case MVT::f16:
     942           0 :           if (NumElements == 2)  return MVT::nxv2f16;
     943           0 :           if (NumElements == 4)  return MVT::nxv4f16;
     944           0 :           if (NumElements == 8)  return MVT::nxv8f16;
     945             :           break;
     946           0 :         case MVT::f32:
     947           0 :           if (NumElements == 1)  return MVT::nxv1f32;
     948           0 :           if (NumElements == 2)  return MVT::nxv2f32;
     949           0 :           if (NumElements == 4)  return MVT::nxv4f32;
     950           0 :           if (NumElements == 8)  return MVT::nxv8f32;
     951           0 :           if (NumElements == 16) return MVT::nxv16f32;
     952             :           break;
     953           1 :         case MVT::f64:
     954           1 :           if (NumElements == 1)  return MVT::nxv1f64;
     955           1 :           if (NumElements == 2)  return MVT::nxv2f64;
     956           0 :           if (NumElements == 4)  return MVT::nxv4f64;
     957           0 :           if (NumElements == 8)  return MVT::nxv8f64;
     958             :           break;
     959             :       }
     960           0 :       return (MVT::SimpleValueType)(MVT::INVALID_SIMPLE_VALUE_TYPE);
     961             :     }
     962             : 
     963     1853928 :     static MVT getVectorVT(MVT VT, unsigned NumElements, bool IsScalable) {
     964     1853928 :       if (IsScalable)
     965           2 :         return getScalableVectorVT(VT, NumElements);
     966     1853926 :       return getVectorVT(VT, NumElements);
     967             :     }
     968             : 
     969      103833 :     static MVT getVectorVT(MVT VT, MVT::ElementCount EC) {
     970      103833 :       if (EC.Scalable)
     971           7 :         return getScalableVectorVT(VT, EC.Min);
     972      103826 :       return getVectorVT(VT, EC.Min);
     973             :     }
     974             : 
     975             :     /// Return the value type corresponding to the specified type.  This returns
     976             :     /// all pointers as iPTR.  If HandleUnknown is true, unknown types are
     977             :     /// returned as Other, otherwise they are invalid.
     978             :     static MVT getVT(Type *Ty, bool HandleUnknown = false);
     979             : 
     980             :   private:
     981             :     /// A simple iterator over the MVT::SimpleValueType enum.
     982             :     struct mvt_iterator {
     983             :       SimpleValueType VT;
     984             : 
     985             :       mvt_iterator(SimpleValueType VT) : VT(VT) {}
     986             : 
     987   227604680 :       MVT operator*() const { return VT; }
     988             :       bool operator!=(const mvt_iterator &LHS) const { return VT != LHS.VT; }
     989             : 
     990             :       mvt_iterator& operator++() {
     991   230331773 :         VT = (MVT::SimpleValueType)((int)VT + 1);
     992             :         assert((int)VT <= MVT::MAX_ALLOWED_VALUETYPE &&
     993             :                "MVT iterator overflowed.");
     994             :         return *this;
     995             :       }
     996             :     };
     997             : 
     998             :     /// A range of the MVT::SimpleValueType enum.
     999             :     using mvt_range = iterator_range<mvt_iterator>;
    1000             : 
    1001             :   public:
    1002             :     /// SimpleValueType Iteration
    1003             :     /// @{
    1004             :     static mvt_range all_valuetypes() {
    1005     1383188 :       return mvt_range(MVT::FIRST_VALUETYPE, MVT::LAST_VALUETYPE);
    1006             :     }
    1007             : 
    1008             :     static mvt_range integer_valuetypes() {
    1009       26430 :       return mvt_range(MVT::FIRST_INTEGER_VALUETYPE,
    1010             :                        (MVT::SimpleValueType)(MVT::LAST_INTEGER_VALUETYPE + 1));
    1011             :     }
    1012             : 
    1013             :     static mvt_range fp_valuetypes() {
    1014        9930 :       return mvt_range(MVT::FIRST_FP_VALUETYPE,
    1015             :                        (MVT::SimpleValueType)(MVT::LAST_FP_VALUETYPE + 1));
    1016             :     }
    1017             : 
    1018             :     static mvt_range vector_valuetypes() {
    1019     1901156 :       return mvt_range(MVT::FIRST_VECTOR_VALUETYPE,
    1020             :                        (MVT::SimpleValueType)(MVT::LAST_VECTOR_VALUETYPE + 1));
    1021             :     }
    1022             : 
    1023             :     static mvt_range integer_vector_valuetypes() {
    1024       28320 :       return mvt_range(
    1025             :           MVT::FIRST_INTEGER_VECTOR_VALUETYPE,
    1026             :           (MVT::SimpleValueType)(MVT::LAST_INTEGER_VECTOR_VALUETYPE + 1));
    1027             :     }
    1028             : 
    1029             :     static mvt_range fp_vector_valuetypes() {
    1030       18790 :       return mvt_range(
    1031             :           MVT::FIRST_FP_VECTOR_VALUETYPE,
    1032             :           (MVT::SimpleValueType)(MVT::LAST_FP_VECTOR_VALUETYPE + 1));
    1033             :     }
    1034             : 
    1035             :     static mvt_range integer_scalable_vector_valuetypes() {
    1036           2 :       return mvt_range(MVT::FIRST_INTEGER_SCALABLE_VALUETYPE,
    1037             :               (MVT::SimpleValueType)(MVT::LAST_INTEGER_SCALABLE_VALUETYPE + 1));
    1038             :     }
    1039             : 
    1040             :     static mvt_range fp_scalable_vector_valuetypes() {
    1041           2 :       return mvt_range(MVT::FIRST_FP_SCALABLE_VALUETYPE,
    1042             :                    (MVT::SimpleValueType)(MVT::LAST_FP_SCALABLE_VALUETYPE + 1));
    1043             :     }
    1044             :     /// @}
    1045             :   };
    1046             : 
    1047             : } // end namespace llvm
    1048             : 
    1049             : #endif // LLVM_CODEGEN_MACHINEVALUETYPE_H

Generated by: LCOV version 1.13