reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/CodeGen/Analysis.h

   37 struct EVT;

References

gen/lib/Target/ARM/ARMGenDAGISel.inc

54682   EVT ScalarVT = St->getMemoryVT().getScalarType();
54701   EVT ScalarVT = St->getMemoryVT().getScalarType();
54800   EVT ScalarVT = Ld->getMemoryVT().getScalarType();
54829   EVT ScalarVT = Ld->getMemoryVT().getScalarType();
54839   EVT ScalarVT = Ld->getMemoryVT().getScalarType();

gen/lib/Target/Mips/MipsGenDAGISel.inc

30281   EVT EltTy = N->getValueType(0).getVectorElementType();
30309   EVT EltTy = N->getValueType(0).getVectorElementType();
30322   EVT EltTy = N->getValueType(0).getVectorElementType();

include/llvm/ADT/ArrayRef.h

   43     using iterator = const T *;
   44     using const_iterator = const T *;
   50     const T *Data = nullptr;
   66     /*implicit*/ ArrayRef(const T &OneElt)
   70     /*implicit*/ ArrayRef(const T *data, size_t length)
   74     ArrayRef(const T *begin, const T *end)
   74     ArrayRef(const T *begin, const T *end)
   81     /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
   87     /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
   92     /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
   97     /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
  100     /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
  145     const T *data() const { return Data; }
  151     const T &front() const {
  157     const T &back() const {
  163     template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
  178     ArrayRef<T> slice(size_t N, size_t M) const {
  184     ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
  187     ArrayRef<T> drop_front(size_t N = 1) const {
  193     ArrayRef<T> drop_back(size_t N = 1) const {
  200     template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
  206     template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
  211     ArrayRef<T> take_front(size_t N = 1) const {
  218     ArrayRef<T> take_back(size_t N = 1) const {
  226     template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
  232     template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
  239     const T &operator[](size_t Index) const {
  249     typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
  257     typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
  263     std::vector<T> vec() const {
  270     operator std::vector<T>() const {
  456   ArrayRef<T> makeArrayRef(const T *data, size_t length) {
  456   ArrayRef<T> makeArrayRef(const T *data, size_t length) {

include/llvm/ADT/DenseMap.h

   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
   66   using mapped_type = ValueT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  219         InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
  299   ValueT &operator[](const KeyT &Key) {
  311   ValueT &operator[](KeyT &&Key) {
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  516                             ValueArgs &&... Values) {
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  526                                       ValueT &&Value, LookupKeyT &Lookup) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)

include/llvm/ADT/SmallVector.h

   75   AlignedCharArrayUnion<T> FirstEl;
  114   using value_type = T;
  115   using iterator = T *;
  116   using const_iterator = const T *;
  121   using reference = T &;
  122   using const_reference = const T &;
  123   using pointer = T *;
  124   using const_pointer = const T *;
  259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
  264   static void destroy_range(T *, T *) {}
  264   static void destroy_range(T *, T *) {}
  286       T1 *I, T1 *E, T2 *Dest,
  286       T1 *I, T1 *E, T2 *Dest,
  286       T1 *I, T1 *E, T2 *Dest,
  287       typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
  288                                            T2>::value>::type * = nullptr) {
  294       memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
  299   void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
  302   void push_back(const T &Elt) {
  305     memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
  315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
  316   using SuperClass = SmallVectorTemplateBase<T>;
  357   void resize(size_type N, const T &NV) {
  374   LLVM_NODISCARD T pop_back_val() {
  397   void append(size_type NumInputs, const T &Elt) {
  405   void append(std::initializer_list<T> IL) {
  412   void assign(size_type NumElts, const T &Elt) {
  429   void assign(std::initializer_list<T> IL) {
  467   iterator insert(iterator I, T &&Elt) {
  497   iterator insert(iterator I, const T &Elt) {
  526   iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
  637   void insert(iterator I, std::initializer_list<T> IL) {
  641   template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
  820   AlignedCharArrayUnion<T> InlineElts[N];
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  846   explicit SmallVector(size_t Size, const T &Value = T())
  865   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  884   SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {

include/llvm/CodeGen/Analysis.h

   73                      SmallVectorImpl<EVT> &ValueVTs,
   79                      SmallVectorImpl<EVT> &ValueVTs,
   80                      SmallVectorImpl<EVT> *MemVTs,

include/llvm/CodeGen/BasicTTIImpl.h

  203     EVT E = EVT::getIntegerVT(Context, BitWidth);
  203     EVT E = EVT::getIntegerVT(Context, BitWidth);
  250     EVT VT = getTLI()->getValueType(DL, Ty);
  256     EVT VT = getTLI()->getValueType(DL, Ty);
  285     EVT VT = getTLI()->getValueType(DL, Ty);
  393     EVT VT = TLI->getValueType(DL, Ty);
  406     EVT VT = TLI->getValueType(DL, Ty);
  721         EVT ExtVT = EVT::getEVT(Dst);
  721         EVT ExtVT = EVT::getEVT(Dst);
  722         EVT LoadVT = EVT::getEVT(Src);
  722         EVT LoadVT = EVT::getEVT(Src);
  887       EVT MemVT = getTLI()->getValueType(DL, Src);

include/llvm/CodeGen/RuntimeLibcalls.h

   37   Libcall getFPEXT(EVT OpVT, EVT RetVT);
   37   Libcall getFPEXT(EVT OpVT, EVT RetVT);
   41   Libcall getFPROUND(EVT OpVT, EVT RetVT);
   41   Libcall getFPROUND(EVT OpVT, EVT RetVT);
   45   Libcall getFPTOSINT(EVT OpVT, EVT RetVT);
   45   Libcall getFPTOSINT(EVT OpVT, EVT RetVT);
   49   Libcall getFPTOUINT(EVT OpVT, EVT RetVT);
   49   Libcall getFPTOUINT(EVT OpVT, EVT RetVT);
   53   Libcall getSINTTOFP(EVT OpVT, EVT RetVT);
   53   Libcall getSINTTOFP(EVT OpVT, EVT RetVT);
   57   Libcall getUINTTOFP(EVT OpVT, EVT RetVT);
   57   Libcall getUINTTOFP(EVT OpVT, EVT RetVT);

include/llvm/CodeGen/SelectionDAG.h

   93   const EVT *VTs;
  100   SDVTListNode(const FoldingSetNodeIDRef ID, const EVT *VT, unsigned int Num) :
  350   SDNodeT *newSDNode(ArgTypes &&... Args) {
  352         SDNodeT(std::forward<ArgTypes>(Args)...);
  363                                                ArgTypes &&... Args) {
  373                                                 SDVTList VTs, EVT MemoryVT,
  563   SDVTList getVTList(EVT VT);
  564   SDVTList getVTList(EVT VT1, EVT VT2);
  564   SDVTList getVTList(EVT VT1, EVT VT2);
  565   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
  565   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
  565   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3);
  566   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
  566   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
  566   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
  566   SDVTList getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4);
  567   SDVTList getVTList(ArrayRef<EVT> VTs);
  578   SDValue getConstant(uint64_t Val, const SDLoc &DL, EVT VT,
  580   SDValue getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
  583   SDValue getAllOnesConstant(const SDLoc &DL, EVT VT, bool IsTarget = false,
  589   SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
  593   SDValue getShiftAmountConstant(uint64_t Val, EVT VT, const SDLoc &DL,
  596   SDValue getTargetConstant(uint64_t Val, const SDLoc &DL, EVT VT,
  600   SDValue getTargetConstant(const APInt &Val, const SDLoc &DL, EVT VT,
  604   SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
  611   SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);
  611   SDValue getBoolConstant(bool V, const SDLoc &DL, EVT VT, EVT OpVT);
  622   SDValue getConstantFP(double Val, const SDLoc &DL, EVT VT,
  624   SDValue getConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT,
  626   SDValue getConstantFP(const ConstantFP &V, const SDLoc &DL, EVT VT,
  628   SDValue getTargetConstantFP(double Val, const SDLoc &DL, EVT VT) {
  631   SDValue getTargetConstantFP(const APFloat &Val, const SDLoc &DL, EVT VT) {
  634   SDValue getTargetConstantFP(const ConstantFP &Val, const SDLoc &DL, EVT VT) {
  639   SDValue getGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
  642   SDValue getTargetGlobalAddress(const GlobalValue *GV, const SDLoc &DL, EVT VT,
  646   SDValue getFrameIndex(int FI, EVT VT, bool isTarget = false);
  647   SDValue getTargetFrameIndex(int FI, EVT VT) {
  650   SDValue getJumpTable(int JTI, EVT VT, bool isTarget = false,
  652   SDValue getTargetJumpTable(int JTI, EVT VT, unsigned TargetFlags = 0) {
  655   SDValue getConstantPool(const Constant *C, EVT VT, unsigned Align = 0,
  658   SDValue getTargetConstantPool(const Constant *C, EVT VT, unsigned Align = 0,
  662   SDValue getConstantPool(MachineConstantPoolValue *C, EVT VT,
  665   SDValue getTargetConstantPool(MachineConstantPoolValue *C, EVT VT,
  670   SDValue getTargetIndex(int Index, EVT VT, int64_t Offset = 0,
  676   SDValue getExternalSymbol(const char *Sym, EVT VT);
  677   SDValue getExternalSymbol(const char *Sym, const SDLoc &dl, EVT VT);
  678   SDValue getTargetExternalSymbol(const char *Sym, EVT VT,
  680   SDValue getMCSymbol(MCSymbol *Sym, EVT VT);
  682   SDValue getValueType(EVT);
  683   SDValue getRegister(unsigned Reg, EVT VT);
  688   SDValue getBlockAddress(const BlockAddress *BA, EVT VT, int64_t Offset = 0,
  690   SDValue getTargetBlockAddress(const BlockAddress *BA, EVT VT,
  721   SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT) {
  730   SDValue getCopyFromReg(SDValue Chain, const SDLoc &dl, unsigned Reg, EVT VT,
  743   SDValue getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
  750   SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef<SDValue> Ops) {
  759   SDValue getBuildVector(EVT VT, const SDLoc &DL, ArrayRef<SDUse> Ops) {
  767   SDValue getSplatBuildVector(EVT VT, const SDLoc &DL, SDValue Op) {
  784   SDValue getSplatVector(EVT VT, const SDLoc &DL, SDValue Op) {
  804   SDValue getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT);
  808   SDValue getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
  812   SDValue getSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
  816   SDValue getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
  820   SDValue getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT);
  825   SDValue getPtrExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT);
  830   SDValue getPtrExtendInReg(SDValue Op, const SDLoc &DL, EVT VT);
  835   SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT);
  835   SDValue getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT, EVT OpVT);
  838   SDValue getNOT(const SDLoc &DL, SDValue Val, EVT VT);
  841   SDValue getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT);
  847     EVT VT = Op.getValueType();
  852     EVT VT = Op.getValueType();
  892   SDValue getUNDEF(EVT VT) {
  897   SDValue getGLOBAL_OFFSET_TABLE(EVT VT) {
  903   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
  905   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
  907   SDValue getNode(unsigned Opcode, const SDLoc &DL, ArrayRef<EVT> ResultTys,
  913   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT);
  914   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue Operand,
  916   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
  918   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
  921   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
  923   SDValue getNode(unsigned Opcode, const SDLoc &DL, EVT VT, SDValue N1,
  977   SDValue getSetCC(const SDLoc &DL, EVT VT, SDValue LHS, SDValue RHS,
  990   SDValue getSelect(const SDLoc &DL, EVT VT, SDValue Cond, SDValue LHS,
 1020   SDValue getVAArg(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
 1027   SDValue getAtomicCmpSwap(unsigned Opcode, const SDLoc &dl, EVT MemVT,
 1033   SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, SDValue Chain,
 1038   SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,
 1038   SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT, EVT VT,
 1043   SDValue getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
 1053     ArrayRef<SDValue> Ops, EVT MemVT,
 1062                               ArrayRef<SDValue> Ops, EVT MemVT,
 1079   SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
 1084   SDValue getLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
 1087   getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT, SDValue Chain,
 1088              SDValue Ptr, MachinePointerInfo PtrInfo, EVT MemVT,
 1092   SDValue getExtLoad(ISD::LoadExtType ExtType, const SDLoc &dl, EVT VT,
 1093                      SDValue Chain, SDValue Ptr, EVT MemVT,
 1097   SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
 1099                   MachinePointerInfo PtrInfo, EVT MemVT, unsigned Alignment = 0,
 1103   SDValue getLoad(ISD::MemIndexedMode AM, ISD::LoadExtType ExtType, EVT VT,
 1105                   EVT MemVT, MachineMemOperand *MMO);
 1120                 MachinePointerInfo PtrInfo, EVT SVT, unsigned Alignment = 0,
 1124                         SDValue Ptr, EVT SVT, MachineMemOperand *MMO);
 1131   SDValue getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain, SDValue Ptr,
 1132                         SDValue Mask, SDValue Src0, EVT MemVT,
 1136                          SDValue Ptr, SDValue Mask, EVT MemVT,
 1139   SDValue getMaskedGather(SDVTList VTs, EVT VT, const SDLoc &dl,
 1142   SDValue getMaskedScatter(SDVTList VTs, EVT VT, const SDLoc &dl,
 1150                              const SDLoc &dl, EVT MemVT,
 1161   SDValue getBitcast(EVT VT, SDValue V);
 1164   SDValue getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr, unsigned SrcAS,
 1169   SDValue getShiftAmountOperand(EVT LHSTy, SDValue Op);
 1217   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT);
 1218   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT, SDValue Op1);
 1219   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
 1221   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
 1223   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT,
 1225   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, EVT VT2);
 1225   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1, EVT VT2);
 1226   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
 1227                        EVT VT2, ArrayRef<SDValue> Ops);
 1228   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
 1229                        EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
 1229                        EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
 1230   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, EVT VT1,
 1231                        EVT VT2, SDValue Op1);
 1232   SDNode *SelectNodeTo(SDNode *N, unsigned MachineOpc, EVT VT1,
 1233                        EVT VT2, SDValue Op1, SDValue Op2);
 1253   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT);
 1254   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
 1256   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
 1258   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
 1260   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT,
 1262   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1263                                 EVT VT2, SDValue Op1, SDValue Op2);
 1264   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1265                                 EVT VT2, SDValue Op1, SDValue Op2, SDValue Op3);
 1266   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1267                                 EVT VT2, ArrayRef<SDValue> Ops);
 1268   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1269                                 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2);
 1269                                 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2);
 1270   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1271                                 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2,
 1271                                 EVT VT2, EVT VT3, SDValue Op1, SDValue Op2,
 1273   MachineSDNode *getMachineNode(unsigned Opcode, const SDLoc &dl, EVT VT1,
 1274                                 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
 1274                                 EVT VT2, EVT VT3, ArrayRef<SDValue> Ops);
 1276                                 ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops);
 1281   SDValue getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT,
 1285   SDValue getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
 1380   static const fltSemantics &EVTToAPFloatSemantics(EVT VT) {
 1434   SDValue CreateStackTemporary(EVT VT, unsigned minAlign = 1);
 1438   SDValue CreateStackTemporary(EVT VT1, EVT VT2);
 1438   SDValue CreateStackTemporary(EVT VT1, EVT VT2);
 1440   SDValue FoldSymbolOffset(unsigned Opcode, EVT VT,
 1444   SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
 1447   SDValue FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
 1451   SDValue FoldConstantVectorArithmetic(unsigned Opcode, const SDLoc &DL, EVT VT,
 1457   SDValue foldConstantFPMath(unsigned Opcode, const SDLoc &DL, EVT VT,
 1461   SDValue FoldSetCC(EVT VT, SDValue N1, SDValue N2, ISD::CondCode Cond,
 1646   std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
 1646   std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
 1646   std::pair<EVT, EVT> GetSplitDestVTs(const EVT &VT) const;
 1651                                           const EVT &LoVT, const EVT &HiVT);
 1651                                           const EVT &LoVT, const EVT &HiVT);
 1655     EVT LoVT, HiVT;
 1676   unsigned getEVTAlignment(EVT MemoryVT) const;
 1749   std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
 1749   std::map<EVT, SDNode*, EVT::compareRawBits> ExtendedValueTypeNodes;
 1771                                          const SDLoc &dl, EVT MemVT,

include/llvm/CodeGen/SelectionDAGNodes.h

   78   const EVT *VTs;
  165   inline EVT getValueType() const;
  291   EVT getValueType() const { return Val.getValueType(); }
  619   const EVT *ValueList;
  639   static const EVT *getValueTypeList(EVT VT);
  639   static const EVT *getValueTypeList(EVT VT);
 1014   EVT getValueType(unsigned ResNo) const {
 1029   using value_iterator = const EVT *;
 1096   static SDVTList getSDVTList(EVT VT) {
 1162 inline EVT SDValue::getValueType() const {
 1283   AddrSpaceCastSDNode(unsigned Order, const DebugLoc &dl, EVT VT,
 1298   EVT MemoryVT;
 1306             EVT memvt, MachineMemOperand *MMO);
 1372   EVT getMemoryVT() const { return MemoryVT; }
 1438                EVT MemVT, MachineMemOperand *MMO)
 1492                      SDVTList VTs, EVT MemoryVT, MachineMemOperand *MMO)
 1523   ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
 1528     EVT VT = getValueType(0);
 1541     EVT VT = getValueType(0);
 1551   static bool isSplatMask(const int *Mask, EVT VT);
 1578   ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
 1619   ConstantFPSDNode(bool isTarget, const ConstantFP *val, EVT VT)
 1653   static bool isValueValidForType(EVT VT, const APFloat& Val);
 1730                       const GlobalValue *GA, EVT VT, int64_t o,
 1753   FrameIndexSDNode(int fi, EVT VT, bool isTarg)
 1805   JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned TF)
 1831   ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
 1841                      EVT VT, int o, unsigned Align, unsigned TF)
 1891   TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned TF)
 2054   RegisterSDNode(unsigned reg, EVT VT)
 2090   BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
 2131   ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned TF, EVT VT)
 2151   MCSymbolSDNode(MCSymbol *Symbol, EVT VT)
 2184   EVT ValueType;
 2186   explicit VTSDNode(EVT VT)
 2191   EVT getVT() const { return ValueType; }
 2202                SDVTList VTs, ISD::MemIndexedMode AM, EVT MemVT,
 2236              ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
 2264               ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
 2296                         const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 2322                    ISD::LoadExtType ETy, bool IsExpanding, EVT MemVT,
 2350                     bool isTrunc, bool isCompressing, EVT MemVT,
 2385                             const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 2427                      EVT MemVT, MachineMemOperand *MMO,
 2446                       EVT MemVT, MachineMemOperand *MMO,

include/llvm/CodeGen/TargetCallingConv.h

  160     EVT ArgVT;
  174     InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
  174     InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
  198     EVT ArgVT;
  212     OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed,
  212     OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed,

include/llvm/CodeGen/TargetLowering.h

  137   using LegalizeKind = std::pair<LegalizeTypeAction, EVT>;
  269   virtual MVT getScalarShiftAmountTy(const DataLayout &, EVT) const;
  271   EVT getShiftAmountTy(EVT LHSTy, const DataLayout &DL,
  271   EVT getShiftAmountTy(EVT LHSTy, const DataLayout &DL,
  289   virtual bool reduceSelectOfFPConstantLoads(EVT CmpOpVT) const {
  324   shouldExpandBuildVectorWithShuffles(EVT /* VT */,
  333   virtual bool isIntDivCheap(EVT VT, AttributeList Attr) const { return false; }
  336   virtual bool hasStandaloneRem(EVT VT) const {
  357   int getRecipEstimateSqrtEnabled(EVT VT, MachineFunction &MF) const;
  363   int getRecipEstimateDivEnabled(EVT VT, MachineFunction &MF) const;
  369   int getSqrtRefinementSteps(EVT VT, MachineFunction &MF) const;
  375   int getDivRefinementSteps(EVT VT, MachineFunction &MF) const;
  406   virtual bool isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
  406   virtual bool isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
  429   virtual bool isStoreBitCastBeneficial(EVT StoreVT, EVT BitcastVT,
  429   virtual bool isStoreBitCastBeneficial(EVT StoreVT, EVT BitcastVT,
  439   virtual bool storeOfVectorConstantIsCheap(EVT MemVT,
  448   virtual bool mergeStoresAfterLegalization(EVT MemVT) const {
  453   virtual bool canMergeStoresTo(unsigned AS, EVT MemVT,
  477   virtual bool hasBitPreservingFPLogic(EVT VT) const {
  483   virtual bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const {
  483   virtual bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const {
  506   virtual bool convertSetCCLogicToBitwiseLogic(EVT VT) const {
  576   virtual bool shouldTransformSignedTruncationCheck(EVT XVT,
  619   virtual bool preferIncOfAddToSubOfNot(EVT VT) const {
  639   virtual bool shouldSplatInsEltVarIndex(EVT) const {
  646   virtual bool enableAggressiveFMAFusion(EVT VT) const {
  651   virtual EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  652                                  EVT VT) const;
  679   BooleanContent getBooleanContents(EVT Type) const {
  740   bool isTypeLegal(EVT VT) const {
  774   LegalizeTypeAction getTypeAction(LLVMContext &Context, EVT VT) const {
  787   EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const {
  787   EVT getTypeToTransformTo(LLVMContext &Context, EVT VT) const {
  795   EVT getTypeToExpandTo(LLVMContext &Context, EVT VT) const {
  795   EVT getTypeToExpandTo(LLVMContext &Context, EVT VT) const {
  818   unsigned getVectorTypeBreakdown(LLVMContext &Context, EVT VT,
  819                                   EVT &IntermediateVT,
  827       LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  827       LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  835     EVT          memVT;            // memory VT
  862   virtual bool isFPImmLegal(const APFloat & /*Imm*/, EVT /*VT*/,
  871   virtual bool isShuffleMaskLegal(ArrayRef<int> /*Mask*/, EVT /*VT*/) const {
  879   virtual bool canOpTrap(unsigned Op, EVT VT) const;
  885                                       EVT /*VT*/) const {
  892   LegalizeAction getOperationAction(unsigned Op, EVT VT) const {
  903   virtual bool isSupportedFixedPointOperation(unsigned Op, EVT VT,
  912   LegalizeAction getFixedPointOperationAction(unsigned Op, EVT VT,
  937   LegalizeAction getStrictFPOperationAction(unsigned Op, EVT VT) const {
  981   bool isOperationLegalOrCustom(unsigned Op, EVT VT) const {
  990   bool isOperationLegalOrPromote(unsigned Op, EVT VT) const {
  999   bool isOperationLegalOrCustomOrPromote(unsigned Op, EVT VT) const {
 1008   bool isOperationCustom(unsigned Op, EVT VT) const {
 1082   bool isOperationExpand(unsigned Op, EVT VT) const {
 1087   bool isOperationLegal(unsigned Op, EVT VT) const {
 1095   LegalizeAction getLoadExtAction(unsigned ExtType, EVT ValVT,
 1096                                   EVT MemVT) const {
 1107   bool isLoadExtLegal(unsigned ExtType, EVT ValVT, EVT MemVT) const {
 1107   bool isLoadExtLegal(unsigned ExtType, EVT ValVT, EVT MemVT) const {
 1113   bool isLoadExtLegalOrCustom(unsigned ExtType, EVT ValVT, EVT MemVT) const {
 1113   bool isLoadExtLegalOrCustom(unsigned ExtType, EVT ValVT, EVT MemVT) const {
 1121   LegalizeAction getTruncStoreAction(EVT ValVT, EVT MemVT) const {
 1121   LegalizeAction getTruncStoreAction(EVT ValVT, EVT MemVT) const {
 1132   bool isTruncStoreLegal(EVT ValVT, EVT MemVT) const {
 1132   bool isTruncStoreLegal(EVT ValVT, EVT MemVT) const {
 1138   bool isTruncStoreLegalOrCustom(EVT ValVT, EVT MemVT) const {
 1138   bool isTruncStoreLegalOrCustom(EVT ValVT, EVT MemVT) const {
 1156   bool isIndexedLoadLegal(unsigned IdxMode, EVT VT) const {
 1174   bool isIndexedStoreLegal(unsigned IdxMode, EVT VT) const {
 1237   EVT getValueType(const DataLayout &DL, Type *Ty,
 1247         EVT PointerTy(getPointerTy(DL, PTy->getAddressSpace()));
 1250       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(EltTy, false),
 1250       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(EltTy, false),
 1254     return EVT::getEVT(Ty, AllowUnknown);
 1257   EVT getMemValueType(const DataLayout &DL, Type *Ty,
 1265         EVT PointerTy(getPointerMemTy(DL, PT->getAddressSpace()));
 1268       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(Elm, false),
 1268       return EVT::getVectorVT(Ty->getContext(), EVT::getEVT(Elm, false),
 1294   MVT getRegisterType(LLVMContext &Context, EVT VT) const {
 1301       EVT VT1;
 1322   unsigned getNumRegisters(LLVMContext &Context, EVT VT) const {
 1329       EVT VT1;
 1346                                             CallingConv::ID CC, EVT VT) const {
 1355                                                  EVT VT) const {
 1369   virtual bool ShouldShrinkFPConstant(EVT) const { return true; }
 1374                                      EVT NewVT) const {
 1386   bool hasBigEndianPartOrdering(EVT VT, const DataLayout &DL) const {
 1465       EVT, unsigned AddrSpace = 0, unsigned Align = 1,
 1484       LLVMContext &Context, const DataLayout &DL, EVT VT,
 1494                                       const DataLayout &DL, EVT VT,
 1503   allowsMemoryAccess(LLVMContext &Context, const DataLayout &DL, EVT VT,
 1512   bool allowsMemoryAccess(LLVMContext &Context, const DataLayout &DL, EVT VT,
 1527   virtual EVT
 1834   virtual bool shouldSignExtendTypeInLibCall(EVT Type, bool IsSigned) const {
 1839   virtual bool shouldExtendTypeInLibCall(EVT Type) const {
 1893                                                EVT VT) const {
 1905   virtual bool isProfitableToCombineMinNumMaxNum(EVT VT) const { return true; }
 1910   virtual bool convertSelectOfConstantsToMath(EVT VT) const {
 1920                                       EVT VT, SDValue C) const {
 1929   virtual bool shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 1929   virtual bool shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 2334   virtual bool isTruncateFree(EVT FromVT, EVT ToVT) const {
 2334   virtual bool isTruncateFree(EVT FromVT, EVT ToVT) const {
 2352       if (isFPExtFree(EVT::getEVT(I->getType()),
 2353                       EVT::getEVT(I->getOperand(0)->getType())))
 2376     EVT VT = getValueType(DL, Ext->getType());
 2377     EVT LoadVT = getValueType(DL, Load->getType());
 2411   virtual bool isZExtFree(EVT FromTy, EVT ToTy) const {
 2411   virtual bool isZExtFree(EVT FromTy, EVT ToTy) const {
 2417   virtual bool isSExtCheaperThanZExt(EVT FromTy, EVT ToTy) const {
 2417   virtual bool isSExtCheaperThanZExt(EVT FromTy, EVT ToTy) const {
 2452   virtual bool hasPairedLoad(EVT /*LoadedType*/,
 2492   virtual bool isZExtFree(SDValue Val, EVT VT2) const {
 2499   virtual bool isFPExtFree(EVT DestVT, EVT SrcVT) const {
 2499   virtual bool isFPExtFree(EVT DestVT, EVT SrcVT) const {
 2508   virtual bool isFPExtFoldable(unsigned Opcode, EVT DestVT, EVT SrcVT) const {
 2508   virtual bool isFPExtFoldable(unsigned Opcode, EVT DestVT, EVT SrcVT) const {
 2520   virtual bool isFNegFree(EVT VT) const {
 2527   virtual bool isFAbsFree(EVT VT) const {
 2540   virtual bool isFMAFasterThanFMulAndFAdd(EVT) const {
 2547   virtual bool isNarrowingProfitable(EVT /*VT1*/, EVT /*VT2*/) const {
 2547   virtual bool isNarrowingProfitable(EVT /*VT1*/, EVT /*VT2*/) const {
 2565   virtual bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 2565   virtual bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 2580   virtual bool isExtractVecEltCheap(EVT VT, unsigned Index) const {
 2588   virtual bool shouldFormOverflowOp(unsigned Opcode, EVT VT) const {
 2603   virtual bool aggressivelyPreferBuildVectorSources(EVT VecVT) const {
 2614   virtual unsigned getShiftAmountThreshold(EVT VT) const {
 2804   LegalizeKind getTypeConversion(LLVMContext &Context, EVT VT) const;
 3023   void softenSetCCOperands(SelectionDAG &DAG, EVT VT, SDValue &NewLHS,
 3031                                           EVT RetVT, ArrayRef<SDValue> Ops,
 3075   bool findOptimalMemOpLowering(std::vector<EVT> &MemOps,
 3238   SDValue buildLegalVectorShuffle(EVT VT, const SDLoc &DL, SDValue N0,
 3291   bool isExtendedTrueVal(const ConstantSDNode *N, EVT VT, bool SExt) const;
 3295   SDValue SimplifySetCC(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
 3345       ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const {
 3345       ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const {
 3353   virtual bool isTypeDesirableForOp(unsigned /*Opc*/, EVT VT) const {
 3362                                                  EVT /*VT*/) const {
 3369   virtual bool IsDesirableToPromoteOp(SDValue /*Op*/, EVT &/*PVT*/) const {
 3589     ArrayRef<EVT> OpsVTBeforeSoften;
 3590     EVT RetVTBeforeSoften;
 3621     MakeLibCallOptions &setTypeListBeforeSoften(ArrayRef<EVT> OpsVT, EVT RetVT,
 3621     MakeLibCallOptions &setTypeListBeforeSoften(ArrayRef<EVT> OpsVT, EVT RetVT,
 3699   virtual Register getRegisterByName(const char* RegName, EVT VT,
 3710   virtual EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
 3710   virtual EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
 3712     EVT MinVT = getRegisterType(Context, MVT::i32);
 3954   virtual const char *LowerXConstraint(EVT ConstraintVT) const;
 4045   bool expandMUL_LOHI(unsigned Opcode, EVT VT, SDLoc dl, SDValue LHS,
 4046                       SDValue RHS, SmallVectorImpl<SDValue> &Result, EVT HiLoVT,
 4060   bool expandMUL(SDNode *N, SDValue &Lo, SDValue &Hi, EVT HiLoVT,
 4154                                  EVT DataVT, SelectionDAG &DAG,
 4161   SDValue getVectorElementPointer(SelectionDAG &DAG, SDValue VecPtr, EVT VecVT,
 4242   SDValue foldSetCCWithAnd(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
 4244   SDValue foldSetCCWithBinOp(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
 4247   SDValue optimizeSetCCOfSignedTruncationCheck(EVT SCCVT, SDValue N0,
 4254       EVT SCCVT, SDValue N0, SDValue N1C, ISD::CondCode Cond,
 4257   SDValue prepareUREMEqFold(EVT SETCCVT, SDValue REMNode,
 4261   SDValue buildUREMEqFold(EVT SETCCVT, SDValue REMNode, SDValue CompTargetNode,
 4265   SDValue prepareSREMEqFold(EVT SETCCVT, SDValue REMNode,
 4269   SDValue buildSREMEqFold(EVT SETCCVT, SDValue REMNode, SDValue CompTargetNode,

include/llvm/CodeGen/ValueTypes.h

   43     bool operator==(EVT VT) const {
   46     bool operator!=(EVT VT) const {
   57     static EVT getFloatingPointVT(unsigned BitWidth) {
   63     static EVT getIntegerVT(LLVMContext &Context, unsigned BitWidth) {
   72     static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
   72     static EVT getVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
   84     static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
   84     static EVT getVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) {
   95     EVT changeVectorElementTypeToInteger() const {
  114     EVT changeTypeToInteger() {
  222     bool bitsEq(EVT VT) const {
  228     bool bitsGT(EVT VT) const {
  234     bool bitsGE(EVT VT) const {
  240     bool bitsLT(EVT VT) const {
  246     bool bitsLE(EVT VT) const {
  259     EVT getScalarType() const {
  264     EVT getVectorElementType() const {
  316     EVT getRoundIntegerType(LLVMContext &Context) const {
  327     EVT getHalfSizedIntegerVT(LLVMContext &Context) const {
  332         EVT HalfVT = EVT((MVT::SimpleValueType)IntVT);
  341     EVT widenIntegerVectorElementType(LLVMContext &Context) const {
  342       EVT EltVT = getVectorElementType();
  343       EltVT = EVT::getIntegerVT(Context, 2 * EltVT.getSizeInBits());
  344       return EVT::getVectorVT(Context, EltVT, getVectorElementCount());
  350     EVT getHalfNumVectorElementsVT(LLVMContext &Context) const {
  351       EVT EltVT = getVectorElementType();
  354       return EVT::getVectorVT(Context, EltVT, EltCnt / 2);
  365     EVT getPow2VectorType(LLVMContext &Context) const {
  369         return EVT::getVectorVT(Context, getVectorElementType(), Pow2NElts,
  388     static EVT getEVT(Type *Ty, bool HandleUnknown = false);
  400       bool operator()(EVT L, EVT R) const {
  400       bool operator()(EVT L, EVT R) const {
  412     EVT changeExtendedTypeToInteger() const;
  413     EVT changeExtendedVectorElementTypeToInteger() const;
  414     static EVT getExtendedIntegerVT(LLVMContext &C, unsigned BitWidth);
  415     static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
  415     static EVT getExtendedVectorVT(LLVMContext &C, EVT VT,
  429     EVT getExtendedVectorElementType() const;

include/llvm/Support/AlignOf.h

   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];

include/llvm/Support/Allocator.h

   81   template <typename T> T *Allocate(size_t Num = 1) {
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));

include/llvm/Support/type_traits.h

   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;

lib/CodeGen/Analysis.cpp

   84                            Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
   85                            SmallVectorImpl<EVT> *MemVTs,
  120                            Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
  259           TLI.isTypeLegal(EVT::getEVT(T1)) && TLI.isTypeLegal(EVT::getEVT(T2)));
  259           TLI.isTypeLegal(EVT::getEVT(T1)) && TLI.isTypeLegal(EVT::getEVT(T2)));

lib/CodeGen/AtomicExpandPass.cpp

  363   EVT VT = TLI->getMemValueType(DL, T);

lib/CodeGen/CodeGenPrepare.cpp

 1151   EVT SrcVT = TLI.getValueType(DL, CI->getOperand(0)->getType());
 1152   EVT DstVT = TLI.getValueType(DL, CI->getType());
 5718   EVT LoadResultVT = TLI->getValueType(*DL, Load->getType());
 5763       EVT TruncVT = TLI->getValueType(*DL, I->getType());
 5792   EVT TruncVT = TLI->getValueType(*DL, TruncTy);
 6717   EVT LowTy = LBC ? EVT::getEVT(LBC->getOperand(0)->getType())
 6717   EVT LowTy = LBC ? EVT::getEVT(LBC->getOperand(0)->getType())
 6718                   : EVT::getEVT(LValue->getType());
 6719   EVT HighTy = HBC ? EVT::getEVT(HBC->getOperand(0)->getType())
 6719   EVT HighTy = HBC ? EVT::getEVT(HBC->getOperand(0)->getType())
 6720                    : EVT::getEVT(HValue->getType());

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

  301       EVT VT = Op.getValueType();
  339     SDValue scalarizeExtractedVectorLoad(SDNode *EVE, EVT InVecVT,
  343     SDValue PromoteOperand(SDValue Op, EVT PVT, bool &Replace);
  344     SDValue SExtPromoteOperand(SDValue Op, EVT PVT);
  345     SDValue ZExtPromoteOperand(SDValue Op, EVT PVT);
  511     SDValue SimplifySetCC(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
  522     SDValue CombineConsecutiveLoads(SDNode *N, EVT VT);
  527     SDValue ConstantFoldBITCASTofBUILD_VECTOR(SDNode *, EVT);
  612                           EVT LoadResultTy, EVT &ExtVT);
  612                           EVT LoadResultTy, EVT &ExtVT);
  617                            EVT &MemVT, unsigned ShAmt = 0);
  638                                          EVT MemVT, unsigned NumStores,
  677     bool hasOperation(unsigned Opcode, EVT VT) {
  691     EVT getShiftAmountTy(EVT LHSTy) {
  691     EVT getShiftAmountTy(EVT LHSTy) {
  698     bool isTypeLegal(const EVT &VT) {
  704     EVT getSetCCResultType(EVT VT) const {
  704     EVT getSetCCResultType(EVT VT) const {
  920       EVT VT = LoadStore->getMemoryVT();
  940   EVT VT = N0.getValueType();
 1088   EVT VT = Load->getValueType(0);
 1100 SDValue DAGCombiner::PromoteOperand(SDValue Op, EVT PVT, bool &Replace) {
 1105     EVT MemVT = LD->getMemoryVT();
 1137 SDValue DAGCombiner::SExtPromoteOperand(SDValue Op, EVT PVT) {
 1140   EVT OldVT = Op.getValueType();
 1154 SDValue DAGCombiner::ZExtPromoteOperand(SDValue Op, EVT PVT) {
 1155   EVT OldVT = Op.getValueType();
 1175   EVT VT = Op.getValueType();
 1185   EVT PVT = VT;
 1240   EVT VT = Op.getValueType();
 1250   EVT PVT = VT;
 1289   EVT VT = Op.getValueType();
 1299   EVT PVT = VT;
 1320   EVT VT = Op.getValueType();
 1330   EVT PVT = VT;
 1339     EVT MemVT = LD->getMemoryVT();
 1960   EVT VT = Sel.getValueType();
 2025   EVT VT = C.getValueType();
 2055   EVT VT = ShiftOp.getValueType();
 2077   EVT VT = N0.getValueType();
 2295   EVT VT = N0.getValueType();
 2319   EVT VT = N0.getValueType();
 2385   EVT VT = V.getNode()->getValueType(0);
 2408   EVT VT = N0.getValueType();
 2420   EVT VT = N0.getValueType();
 2500   EVT VT = N0.getValueType();
 2529   EVT VT = V.getValueType();
 2565   EVT VT = V.getValueType();
 2590   EVT VT = N0.getValueType();
 2593   EVT CarryVT = N->getValueType(1);
 2635   EVT VT = N0.getValueType();
 2698     EVT VT = N0.getValueType();
 2699     EVT CarryVT = CarryIn.getValueType();
 2757     EVT VT = Combiner.getSetCCResultType(Carry0.getValueType());
 2844 static SDValue tryFoldToZero(const SDLoc &DL, const TargetLowering &TLI, EVT VT,
 2856   EVT VT = N0.getValueType();
 3165   EVT VT = N0.getValueType();
 3202   EVT VT = N0.getValueType();
 3230   EVT VT = N0.getValueType();
 3233   EVT CarryVT = N->getValueType(1);
 3299   EVT VT = N0.getValueType();
 3320   EVT VT = N0.getValueType();
 3388     EVT ShiftVT = getShiftAmountTy(N0.getValueType());
 3491   EVT NodeType = Node->getValueType(0);
 3516   EVT VT = Node->getValueType(0);
 3580   EVT VT = N->getValueType(0);
 3626   EVT VT = N->getValueType(0);
 3627   EVT CCVT = getSetCCResultType(VT);
 3688   EVT VT = N->getValueType(0);
 3689   EVT CCVT = getSetCCResultType(VT);
 3714     EVT ShiftAmtTy = getShiftAmountTy(N0.getValueType());
 3770   EVT VT = N->getValueType(0);
 3771   EVT CCVT = getSetCCResultType(VT);
 3826   EVT VT = N->getValueType(0);
 3834     EVT ShiftVT = getShiftAmountTy(N0.getValueType());
 3848       EVT ADDVT = N1.getOperand(1).getValueType();
 3872   EVT VT = N->getValueType(0);
 3873   EVT CCVT = getSetCCResultType(VT);
 3953   EVT VT = N->getValueType(0);
 3982     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 3982     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4000   EVT VT = N->getValueType(0);
 4028     EVT ShiftVT = getShiftAmountTy(N0.getValueType());
 4038     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4038     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4106   EVT VT = N->getValueType(0);
 4114     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4114     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4137   EVT VT = N->getValueType(0);
 4157     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4157     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), SimpleSize*2);
 4179   EVT VT = N0.getValueType();
 4182   EVT CarryVT = N->getValueType(1);
 4207   EVT VT = N0.getValueType();
 4251   EVT VT = N0.getValueType();
 4268   EVT XVT = X.getValueType();
 4428   EVT VT = N0.getValueType();
 4429   EVT OpVT = LL.getValueType();
 4563   EVT VT = N1.getValueType();
 4620         EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), Size / 2);
 4620         EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), Size / 2);
 4640           EVT ShiftVT = TLI.getShiftAmountTy(HalfVT, DAG.getDataLayout());
 4658                                    EVT LoadResultTy, EVT &ExtVT) {
 4658                                    EVT LoadResultTy, EVT &ExtVT) {
 4664   ExtVT = EVT::getIntegerVT(*DAG.getContext(), ActiveBits);
 4665   EVT LoadedVT = LoadN->getMemoryVT();
 4695                                     ISD::LoadExtType ExtType, EVT &MemVT,
 4724   EVT PtrType = LDST->getBasePtr().getValueType();
 4795       EVT ExtVT;
 4815       EVT ExtVT = EVT::getIntegerVT(*DAG.getContext(), ActiveBits);
 4815       EVT ExtVT = EVT::getIntegerVT(*DAG.getContext(), ActiveBits);
 4816       EVT VT = Op.getOpcode() == ISD::AssertZext ?
 4971   EVT VT = N->getValueType(0);
 4988   EVT VT = And->getValueType(0);
 5025   EVT CCVT = TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 5037   EVT VT = N1.getValueType();
 5289     EVT MemVT = LN0->getMemoryVT();
 5330   EVT VT = N->getValueType(0);
 5554   EVT VT = N->getValueType(0);
 5605   EVT VT = N1.getValueType();
 5658   EVT VT = N0.getValueType();
 5675   EVT VT = N1.getValueType();
 5901   EVT ShiftedVT = OppShiftLHS.getValueType();
 5989   EVT ShiftVT = OppShift.getOperand(1).getValueType();
 5990   EVT ResVT = ExtractFrom.getValueType();
 6123   EVT VT = Shifted.getValueType();
 6138   EVT VT = LHS.getValueType();
 6489   EVT VT = EVT::getIntegerVT(
 6489   EVT VT = EVT::getIntegerVT(
 6653   EVT VT = N->getValueType(0);
 6794   EVT VT = N->getValueType(0);
 6859   EVT VT = N0.getValueType();
 7115   EVT VT = Shift->getValueType(0);
 7116   EVT ShiftAmtVT = Shift->getOperand(1).getValueType();
 7190   EVT VT = N->getValueType(0);
 7205   EVT TruncVT = N->getValueType(0);
 7227   EVT VT = N->getValueType(0);
 7264       EVT ShiftVT = C1->getValueType(0);
 7287   EVT VT = N0.getValueType();
 7288   EVT ShiftVT = N1.getValueType();
 7380     EVT InnerVT = N0Op0.getValueType();
 7433       EVT InnerShiftAmtVT = N0Op0.getOperand(1).getValueType();
 7537   EVT VT = N0.getValueType();
 7566     EVT ExtVT = EVT::getIntegerVT(*DAG.getContext(), LowBits);
 7566     EVT ExtVT = EVT::getIntegerVT(*DAG.getContext(), LowBits);
 7568       ExtVT = EVT::getVectorVT(*DAG.getContext(),
 7580     EVT ShiftVT = N1.getValueType();
 7581     EVT ShiftSVT = ShiftVT.getScalarType();
 7615       EVT TruncVT = EVT::getIntegerVT(Ctx, OpSizeInBits - N1C->getZExtValue());
 7615       EVT TruncVT = EVT::getIntegerVT(Ctx, OpSizeInBits - N1C->getZExtValue());
 7618         TruncVT = EVT::getVectorVT(Ctx, TruncVT, VT.getVectorNumElements());
 7656       EVT TruncVT = EVT::getIntegerVT(Ctx, OpSizeInBits - ShiftAmt);
 7656       EVT TruncVT = EVT::getIntegerVT(Ctx, OpSizeInBits - ShiftAmt);
 7658         TruncVT = EVT::getVectorVT(Ctx, TruncVT, VT.getVectorNumElements());
 7693       EVT LargeVT = N0Op0.getValueType();
 7728   EVT VT = N0.getValueType();
 7773       EVT ShiftVT = N1.getValueType();
 7786       EVT InnerShiftVT = N0.getOperand(0).getValueType();
 7787       EVT ShiftCountVT = N0.getOperand(0).getOperand(1).getValueType();
 7818     EVT SmallVT = N0.getOperand(0).getValueType();
 7937   EVT VT = N->getValueType(0);
 7957     EVT ShAmtTy = N2.getValueType();
 8013   EVT VT = N->getValueType(0);
 8029   EVT VT = N->getValueType(0);
 8042   EVT VT = N->getValueType(0);
 8055   EVT VT = N->getValueType(0);
 8072   EVT VT = N->getValueType(0);
 8082   EVT VT = N->getValueType(0);
 8099   EVT VT = N->getValueType(0);
 8109   EVT VT = N->getValueType(0);
 8123   EVT VT = LHS.getValueType();
 8131 static SDValue combineMinNumMaxNum(const SDLoc &DL, EVT VT, SDValue LHS,
 8138   EVT TransformVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 8187   EVT VT = N->getValueType(0);
 8219   EVT VT = N->getValueType(0);
 8220   EVT CondVT = Cond.getValueType();
 8327   EVT VT = N->getValueType(0);
 8328   EVT VT0 = N0.getValueType();
 8517   EVT VT = N->getValueType(0);
 8621   EVT VT = N->getValueType(0);
 8682   EVT VT = N->getValueType(0);
 8742       EVT NarrowVT = LHS.getValueType();
 8743       EVT WideVT = N1.getValueType().changeVectorElementTypeToInteger();
 8744       EVT SetCCVT = getSetCCResultType(LHS.getValueType());
 8760         EVT WideSetCCVT = getSetCCResultType(WideVT);
 8890   EVT VT = N->getValueType(0);
 8933   EVT SVT = VT.getScalarType();
 8973 static bool ExtendUsesToFormExtLoad(EVT VT, SDNode *N, SDValue N0,
 9057   EVT DstVT = N->getValueType(0);
 9058   EVT SrcVT = N0.getValueType();
 9100   EVT SplitSrcVT = SrcVT;
 9101   EVT SplitDstVT = DstVT;
 9158   EVT VT = N->getValueType(0);
 9159   EVT OrigVT = N->getOperand(0).getValueType();
 9182   EVT MemVT = Load->getMemoryVT();
 9246   EVT VT = Cast->getValueType(0);
 9257   EVT SetCCVT = getSetCCResultType(SetCC.getOperand(0).getValueType());
 9280                                      const TargetLowering &TLI, EVT VT,
 9291   EVT MemVT = LN0->getMemoryVT();
 9311                                   const TargetLowering &TLI, EVT VT,
 9351                                         const TargetLowering &TLI, EVT VT,
 9392   EVT VT = N->getValueType(0);
 9393   EVT XVT = X.getValueType();
 9412   EVT VT = N->getValueType(0);
 9502     EVT MemVT = LN00->getMemoryVT();
 9546     EVT N00VT = N0.getOperand(0).getValueType();
 9556       EVT SVT = getSetCCResultType(N00VT);
 9571         EVT MatchingVecType = N00VT.changeVectorElementTypeToInteger();
 9600       EVT SetCCVT = getSetCCResultType(N00VT);
 9687   EVT VT = Extend->getValueType(0);
 9701   EVT VT = N->getValueType(0);
 9743     EVT SrcVT = N0.getOperand(0).getValueType();
 9744     EVT MinVT = N0.getValueType();
 9815     EVT MemVT = LN00->getMemoryVT();
 9823           EVT LoadResultTy = AndC->getValueType(0);
 9824           EVT ExtVT;
 9881       EVT N00VT = N0.getOperand(0).getValueType();
 9902       EVT MatchingVectorType = N00VT.changeVectorElementTypeToInteger();
 9957   EVT VT = N->getValueType(0);
10045     EVT MemVT = LN0->getMemoryVT();
10064       EVT N00VT = N0.getOperand(0).getValueType();
10081       EVT MatchingVectorType = N00VT.changeVectorElementTypeToInteger();
10108   EVT AssertVT = cast<VTSDNode>(N1)->getVT();
10123     EVT BigA_AssertVT = cast<VTSDNode>(BigA.getOperand(1))->getVT();
10129     EVT MinAssertVT = AssertVT.bitsLT(BigA_AssertVT) ? AssertVT : BigA_AssertVT;
10143     EVT BigA_AssertVT = cast<VTSDNode>(BigA.getOperand(1))->getVT();
10170   EVT VT = N->getValueType(0);
10171   EVT ExtVT = VT;
10199       ExtVT = EVT::getIntegerVT(*DAG.getContext(), MemoryWidth - ShiftAmt);
10201       ExtVT = EVT::getIntegerVT(*DAG.getContext(),
10222     ExtVT = EVT::getIntegerVT(*DAG.getContext(), ActiveBits);
10263           EVT MaskedVT = EVT::getIntegerVT(*DAG.getContext(),
10263           EVT MaskedVT = EVT::getIntegerVT(*DAG.getContext(),
10307   EVT PtrType = N0.getOperand(1).getValueType();
10338     EVT ShImmTy = getShiftAmountTy(Result.getValueType());
10374   EVT VT = N->getValueType(0);
10375   EVT EVT = cast<VTSDNode>(N1)->getVT();
10507   EVT VT = N->getValueType(0);
10523   EVT VT = N->getValueType(0);
10539   EVT VT = N->getValueType(0);
10540   EVT SrcVT = N0.getValueType();
10589     EVT VecTy = N0.getOperand(0).getValueType();
10590     EVT ExTy = N0.getValueType();
10591     EVT TrTy = N->getValueType(0);
10596     EVT NVT = EVT::getVectorVT(*DAG.getContext(), TrTy, SizeRatio * NumElem);
10596     EVT NVT = EVT::getVectorVT(*DAG.getContext(), TrTy, SizeRatio * NumElem);
10602       EVT IndexTy = TLI.getVectorIdxTy(DAG.getDataLayout());
10633       EVT AmtVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
10648     EVT SVT = VT.getScalarType();
10666     EVT BuildVectEltTy = BuildVect.getValueType().getVectorElementType();
10667     EVT TruncVecEltTy = VT.getVectorElementType();
10724     SmallVector<EVT, 8> VTs;
10739       VTs.push_back(EVT::getVectorVT(*DAG.getContext(),
10769     EVT VecSrcVT = VecSrc.getValueType();
10775       EVT IdxVT = TLI.getVectorIdxTy(DAG.getDataLayout());
10859 SDValue DAGCombiner::CombineConsecutiveLoads(SDNode *N, EVT VT) {
10874   EVT LD1VT = LD1->getValueType(0);
10901   EVT VT = N->getValueType(0);
10908   EVT SourceVT = N0.getValueType();
10952   EVT VT = N->getValueType(0);
11088     EVT IntXVT = EVT::getIntegerVT(*DAG.getContext(), OrigXWidth);
11088     EVT IntXVT = EVT::getIntegerVT(*DAG.getContext(), OrigXWidth);
11199   EVT VT = N->getValueType(0);
11206 ConstantFoldBITCASTofBUILD_VECTOR(SDNode *BV, EVT DstEltVT) {
11207   EVT SrcEltVT = BV->getValueType(0).getVectorElementType();
11227     EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT,
11227     EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT,
11238     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), SrcEltVT.getSizeInBits());
11238     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), SrcEltVT.getSizeInBits());
11246     EVT TmpVT = EVT::getIntegerVT(*DAG.getContext(), DstEltVT.getSizeInBits());
11246     EVT TmpVT = EVT::getIntegerVT(*DAG.getContext(), DstEltVT.getSizeInBits());
11284     EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT, Ops.size());
11284     EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT, Ops.size());
11291   EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT,
11291   EVT VT = EVT::getVectorVT(*DAG.getContext(), DstEltVT,
11327   EVT VT = N->getValueType(0);
11539   EVT VT = N->getValueType(0);
11830   EVT VT = N->getValueType(0);
11924   EVT VT = N->getValueType(0);
12103   EVT VT = N->getValueType(0);
12195   EVT VT = N->getValueType(0);
12330   EVT VT = N->getValueType(0);
12469   EVT VT = N->getValueType(0);
12518   EVT VT = N->getValueType(0);
12622   EVT VT = N->getValueType(0);
12658     EVT N1VT = N1->getValueType(0);
12659     EVT N1Op0VT = N1->getOperand(0).getValueType();
12670   EVT VT = N->getValueType(0);
12721   EVT VT = N->getValueType(0);
12804   EVT VT = N->getValueType(0);
12825   EVT VT = N->getValueType(0);
12826   EVT OpVT = N0.getValueType();
12886   EVT VT = N->getValueType(0);
12887   EVT OpVT = N0.getValueType();
12933   EVT VT = N->getValueType(0);
12939   EVT SrcVT = Src.getValueType();
12974   EVT VT = N->getValueType(0);
12989   EVT VT = N->getValueType(0);
13006   EVT VT = N->getValueType(0);
13060   EVT VT = N->getValueType(0);
13113   EVT VT = N->getValueType(0);
13124   EVT VT = N->getValueType(0);
13148   EVT VT = N->getValueType(0);
13160   EVT VT = N->getValueType(0);
13175     EVT IntVT = Int.getValueType();
13219   EVT VT = N->getValueType(0);
13255   EVT VT = N->getValueType(0);
13273     EVT IntVT = Int.getValueType();
13409       EVT SetCCVT = N.getValueType();
13454   EVT VT;
13507   EVT VT;
13738   EVT VT;
13877 static inline int numVectorEltsOrZero(EVT T) {
13883   EVT STType = Val.getValueType();
13884   EVT STMemType = ST->getMemoryVT();
13907   EVT LDMemType = LD->getMemoryVT();
13908   EVT LDType = LD->getValueType(0);
13941   EVT LDType = LD->getValueType(0);
13942   EVT LDMemType = LD->getMemoryVT();
13943   EVT STMemType = ST->getMemoryVT();
13944   EVT STType = ST->getValue().getValueType();
14186       EVT TruncType = LS.Inst->getValueType(0);
14187       EVT LoadedType = LS.getLoadedType();
14295   EVT getLoadedType() const {
14298     return EVT::getIntegerVT(Ctxt, getLoadedSize() * 8);
14323     EVT SliceType = getLoadedType();
14333     EVT PtrType = Origin->getBasePtr().getValueType();
14346     EVT TruncateType = Inst->getValueType(0);
14390       EVT ArithType = BaseAddr.getValueType();
14397     EVT SliceType = getLoadedType();
14406     EVT FinalType = Inst->getValueType(0);
14425     EVT ResVT = Use->getValueType(0);
14526     EVT LoadedType = First->getLoadedType();
14846   EVT VT = Value.getValueType();
14898     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), NewBW);
14898     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), NewBW);
14906       NewVT = EVT::getIntegerVT(*DAG.getContext(), NewBW);
14969     EVT VT = LD->getMemoryVT();
14978     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
14978     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
15106     SmallVectorImpl<MemOpLink> &StoreNodes, EVT MemVT, unsigned NumStores,
15119   EVT StoreTy;
15123     StoreTy = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(), Elts);
15125     StoreTy = EVT::getIntegerVT(*DAG.getContext(), SizeInBits);
15139             EVT IntMemVT =
15140                 EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits());
15172           EVT MemVTScalarTy = MemVT.getScalarType();
15240     EVT LegalizedStoredValTy =
15268   EVT MemVT = St->getMemoryVT();
15285   EVT LoadVT;
15489   EVT MemVT = St->getMemoryVT();
15609           EVT StoreTy = EVT::getIntegerVT(Context, SizeInBits);
15609           EVT StoreTy = EVT::getIntegerVT(Context, SizeInBits);
15626             EVT LegalizedStoredValTy =
15647             EVT Ty = EVT::getVectorVT(Context, MemVT.getScalarType(), Elts);
15647             EVT Ty = EVT::getVectorVT(Context, MemVT.getScalarType(), Elts);
15712           EVT Ty =
15713               EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(), Elts);
15844         EVT StoreTy = EVT::getVectorVT(Context, MemVT.getScalarType(), Elts);
15844         EVT StoreTy = EVT::getVectorVT(Context, MemVT.getScalarType(), Elts);
15864         StoreTy = EVT::getIntegerVT(Context, SizeInBits);
15878           EVT LegalizedStoredValTy = TLI.getTypeToTransformTo(Context, StoreTy);
15942       EVT JointMemOpVT;
15946         JointMemOpVT = EVT::getVectorVT(Context, MemVT.getScalarType(), Elts);
15949         JointMemOpVT = EVT::getIntegerVT(Context, SizeInBits);
15981         EVT ExtendedTy =
16133     EVT SVT = Value.getOperand(0).getValueType();
16461   EVT LowTy = (Lo.getOperand(0).getOpcode() == ISD::BITCAST)
16464   EVT HighTy = (Hi.getOperand(0).getOpcode() == ISD::BITCAST)
16476   EVT VT = EVT::getIntegerVT(*DAG.getContext(), HalfValBitSize);
16476   EVT VT = EVT::getIntegerVT(*DAG.getContext(), HalfValBitSize);
16549   EVT SubVecVT = SubVec.getValueType();
16550   EVT VT = DestVec.getValueType();
16569   EVT SubVecEltVT = SubVecVT.getVectorElementType();
16570   EVT ShufVT = EVT::getVectorVT(*DAG.getContext(), SubVecEltVT, NumMaskVals);
16570   EVT ShufVT = EVT::getVectorVT(*DAG.getContext(), SubVecEltVT, NumMaskVals);
16596   EVT VT = InVec.getValueType();
16665     EVT OpVT = Ops[0].getValueType();
16673 SDValue DAGCombiner::scalarizeExtractedVectorLoad(SDNode *EVE, EVT InVecVT,
16678   EVT ResultVT = EVE->getValueType(0);
16679   EVT VecEltVT = InVecVT.getVectorElementType();
16696   EVT PtrType = NewPtr.getValueType();
16785     EVT VT = ExtElt->getValueType(0);
16797   EVT ScalarVT = N->getValueType(0);
16798   EVT VecVT = VecOp.getValueType();
16837     EVT InEltVT = Elt.getValueType();
16928       EVT IndexTy = TLI.getVectorIdxTy(DAG.getDataLayout());
16960   EVT ExtVT = VecVT.getVectorElementType();
16961   EVT LVT = ExtVT;
16970     EVT BCVT = VecOp.getOperand(0).getValueType();
17066   EVT VT = N->getValueType(0);
17073   EVT SourceType = MVT::Other;
17091     EVT InTy = In.getOperand(0).getValueType();
17110   EVT OutScalarTy = VT.getScalarType();
17148   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), SourceType, NewBVElems);
17148   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), SourceType, NewBVElems);
17173   EVT VT = N->getValueType(0);
17174   EVT InVT1 = VecIn1.getValueType();
17175   EVT InVT2 = VecIn2.getNode() ? VecIn2.getValueType() : InVT1;
17308   EVT VT = BV->getValueType(0);
17349   EVT VecVT = Extract.getOperand(0).getValueType();
17364   EVT VT = N->getValueType(0);
17445     EVT InVT = Vec.getValueType();
17461       EVT SplitVT = EVT::getVectorVT(*DAG.getContext(),
17461       EVT SplitVT = EVT::getVectorVT(*DAG.getContext(),
17581   EVT VT = N->getValueType(0);
17604   EVT InSVT = In.getValueType().getScalarType();
17605   EVT InVT = EVT::getVectorVT(*DAG.getContext(), InSVT, NumElems);
17605   EVT InVT = EVT::getVectorVT(*DAG.getContext(), InSVT, NumElems);
17625   EVT VT = N->getValueType(0);
17642       EVT SrcVT = Splat.getValueType();
17645         EVT NewVT = EVT::getVectorVT(*DAG.getContext(),
17645         EVT NewVT = EVT::getVectorVT(*DAG.getContext(),
17707   EVT OpVT = N->getOperand(0).getValueType();
17714   EVT VT = N->getValueType(0);
17717   EVT SVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
17717   EVT SVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
17734     EVT LastOpVT = Ops.back().getValueType();
17747     SVT = EVT::getFloatingPointVT(OpVT.getSizeInBits());
17761   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), SVT,
17761   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), SVT,
17771   EVT VT = N->getValueType(0);
17772   EVT OpVT = N->getOperand(0).getValueType();
17796     EVT ExtVT = ExtVec.getValueType();
17848   EVT VT = N->getValueType(0);
17874       EVT SVT = Scalar.getValueType().getVectorElementType();
17889       EVT SclTy = Scalar.getValueType();
17902       EVT NVT = EVT::getVectorVT(*DAG.getContext(), SclTy, VNTNumElms);
17902       EVT NVT = EVT::getVectorVT(*DAG.getContext(), SclTy, VNTNumElms);
17920     EVT SVT = VT.getScalarType();
17922     EVT MinVT = SVT;
17929           EVT OpSVT = Op.getOperand(0).getValueType();
17937       EVT OpVT = Op.getValueType();
18019 static SDValue getSubVectorSrc(SDValue V, SDValue Index, EVT SubVT) {
18042   EVT VecVT = BinOp.getValueType();
18048   EVT SubVT = Extract->getValueType(0);
18091   EVT WideBVT = BinOp.getValueType();
18095   EVT VT = Extract->getValueType(0);
18114   EVT NarrowBVT = EVT::getVectorVT(*DAG.getContext(), WideBVT.getScalarType(),
18114   EVT NarrowBVT = EVT::getVectorVT(*DAG.getContext(), WideBVT.getScalarType(),
18125   EVT ExtBOIdxVT = Extract->getOperand(1).getValueType();
18201   EVT VT = Extract->getValueType(0);
18223   EVT NVT = N->getValueType(0);
18252     EVT SrcVT = SrcOp.getValueType();
18258       EVT NewExtVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getScalarType(),
18258       EVT NewExtVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getScalarType(),
18292       EVT InVT = V.getValueType();
18298         EVT EltVT = InVT.getVectorElementType();
18299         EVT ExtractVT = NumElems == 1 ? EltVT
18300                                       : EVT::getVectorVT(*DAG.getContext(),
18329     EVT SmallVT = V.getOperand(1).getValueType();
18376   EVT VT = Shuf->getValueType(0);
18393   EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(),
18393   EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(),
18411   EVT VT = N->getValueType(0);
18420   EVT ConcatVT = N0.getOperand(0).getValueType();
18492   EVT VT = SVN->getValueType(0);
18554   EVT SVT = VT.getScalarType();
18574   EVT VT = SVN->getValueType(0);
18607     EVT OutSVT = EVT::getIntegerVT(*DAG.getContext(), EltSizeInBits * Scale);
18607     EVT OutSVT = EVT::getIntegerVT(*DAG.getContext(), EltSizeInBits * Scale);
18608     EVT OutVT = EVT::getVectorVT(*DAG.getContext(), OutSVT, NumElts / Scale);
18608     EVT OutVT = EVT::getVectorVT(*DAG.getContext(), OutSVT, NumElts / Scale);
18629   EVT VT = SVN->getValueType(0);
18845   EVT VT = N->getValueType(0);
18907       EVT EltVT = VT.getScalarType();
19017       EVT SVT = VT.getScalarType();
19018       EVT InnerVT = BC0->getValueType(0);
19019       EVT InnerSVT = InnerVT.getScalarType();
19022       EVT ScaleVT = SVT.bitsLT(InnerSVT) ? VT : InnerVT;
19023       EVT ScaleSVT = ScaleVT.getScalarType();
19193   EVT VT = N->getValueType(0);
19200     auto InVecT = InVec.getValueType();
19228             EVT SubVT =
19229                 EVT::getVectorVT(*DAG.getContext(), InVecT.getVectorElementType(),
19243   EVT VT = N->getValueType(0);
19279     EVT CN0VT = CN0.getValueType();
19280     EVT CN1VT = CN1.getValueType();
19319     EVT N0SrcSVT = N0Src.getValueType().getScalarType();
19320     EVT N1SrcSVT = N1Src.getValueType().getScalarType();
19323       EVT NewVT;
19332         NewVT = EVT::getVectorVT(Ctx, N1SrcSVT, NumElts * Scale);
19337           NewVT = EVT::getVectorVT(Ctx, N1SrcSVT, NumElts / Scale);
19413   EVT VT = N0.getValueType();
19448   EVT VT = N->getValueType(0);
19461   EVT RVT = RHS.getValueType();
19508     EVT ClearSVT = EVT::getIntegerVT(*DAG.getContext(), NumSubBits);
19508     EVT ClearSVT = EVT::getIntegerVT(*DAG.getContext(), NumSubBits);
19509     EVT ClearVT = EVT::getVectorVT(*DAG.getContext(), ClearSVT, NumSubElts);
19509     EVT ClearVT = EVT::getVectorVT(*DAG.getContext(), ClearSVT, NumSubElts);
19538   EVT VT = N->getValueType(0);
19539   EVT EltVT = VT.getVectorElementType();
19587   EVT VT = N->getValueType(0);
19629     EVT NarrowVT = X.getValueType();
19658     EVT NarrowVT = LHS.getOperand(0).getValueType();
19912   EVT XType = N0.getValueType();
19913   EVT AType = N2.getValueType();
19936   EVT ShiftAmtTy = getShiftAmountTy(N0.getValueType());
19984   EVT VT = N2.getValueType();
20035   EVT CmpOpVT = N0.getValueType();
20036   EVT CmpResVT = getSetCCResultType(CmpOpVT);
20037   EVT VT = N2.getValueType();
20177 SDValue DAGCombiner::SimplifySetCC(EVT VT, SDValue N0, SDValue N1,
20249   EVT VT = V.getValueType();
20271   EVT VT = Op.getValueType();
20335   EVT VT = Arg.getValueType();
20367   EVT VT = Arg.getValueType();
20410   EVT VT = Op.getValueType();
20439         EVT CCVT = getSetCCResultType(VT);

lib/CodeGen/SelectionDAG/FastISel.cpp

  363   EVT RealVT = TLI.getValueType(DL, V->getType(), /*AllowUnknown=*/true);
  425       EVT IntVT = TLI.getPointerTy(DL);
  517   EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false);
  517   EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false);
  585   EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true);
  585   EVT VT = EVT::getEVT(I->getType(), /*HandleUnknown=*/true);
 1139   SmallVector<EVT, 4> RetTys;
 1153     EVT VT = RetTys[I];
 1490   EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType());
 1491   EVT DstVT = TLI.getValueType(DL, I->getType());
 1533   EVT SrcEVT = TLI.getValueType(DL, I->getOperand(0)->getType());
 1534   EVT DstEVT = TLI.getValueType(DL, I->getType());
 1715   EVT VT = TLI.getValueType(DL, I->getType());
 1727   EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits());
 1727   EVT IntVT = EVT::getIntegerVT(I->getContext(), VT.getSizeInBits());
 1758   EVT RealVT = TLI.getValueType(DL, EVI->getType(), /*AllowUnknown=*/true);
 1781   SmallVector<EVT, 4> AggValueVTs;
 1896     EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType());
 1897     EVT DstVT = TLI.getValueType(DL, I->getType());
 2286       EVT VT = TLI.getValueType(DL, PN.getType(), /*AllowUnknown=*/true);

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

  281       SmallVector<EVT, 4> ValueVTs;
  283       for (EVT VT : ValueVTs) {
  365   SmallVector<EVT, 4> ValueVTs;
  370     EVT ValueVT = ValueVTs[Value];
  416   SmallVector<EVT, 1> ValueVTs;
  420   EVT IntVT = ValueVTs[0];
  532     SmallVector<EVT, 4> ValueVTs;
  538       for (EVT VT : ValueVTs) {

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

   63   EVT FloatVT;
   97   EVT getSetCCResultType(EVT VT) const {
   97   EVT getSetCCResultType(EVT VT) const {
  132   SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, const SDLoc &dl,
  132   SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, const SDLoc &dl,
  136   bool LegalizeSetCCCondCode(EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC,
  160   SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
  160   SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
  162   SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
  162   SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
  175   SDValue ExpandLegalINT_TO_FP(bool isSigned, SDValue Op0, EVT DestVT,
  177   SDValue PromoteLegalINT_TO_FP(SDValue LegalOp, EVT DestVT, bool isSigned,
  179   SDValue PromoteLegalFP_TO_INT(SDValue LegalOp, EVT DestVT, bool isSigned,
  260     EVT NVT, EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
  260     EVT NVT, EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
  299   EVT VT = CFP->getValueType(0);
  308   EVT OrigVT = VT;
  309   EVT SVT = VT;
  348   EVT VT = CP->getValueType(0);
  376   EVT VT    = Tmp1.getValueType();
  377   EVT EltVT = VT.getVectorElementType();
  403     EVT EltVT = Vec.getValueType().getVectorElementType();
  506       EVT MemVT = ST->getMemoryVT();
  541   EVT StVT = ST->getMemoryVT();
  549     EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
  549     EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
  567     EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
  567     EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
  568     EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
  568     EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
  620       EVT MemVT = ST->getMemoryVT();
  680       EVT MemVT = LD->getMemoryVT();
  722   EVT SrcVT = LD->getMemoryVT();
  742     EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth);
  742     EVT NVT = EVT::getIntegerVT(*DAG.getContext(), NewWidth);
  781     EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
  781     EVT RoundVT = EVT::getIntegerVT(*DAG.getContext(), RoundWidth);
  782     EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
  782     EVT ExtraVT = EVT::getIntegerVT(*DAG.getContext(), ExtraWidth);
  871         EVT MemVT = LD->getMemoryVT();
  881       EVT DestVT = Node->getValueType(0);
  885         EVT LoadVT = TLI.getRegisterType(SrcVT.getSimpleVT());
  907           EVT ISrcVT = SrcVT.changeTypeToInteger();
  908           EVT IDestVT = DestVT.changeTypeToInteger();
  909           EVT ILoadVT = TLI.getRegisterType(IDestVT.getSimpleVT());
 1017     EVT InnerType = cast<VTSDNode>(Node->getOperand(1))->getVT();
 1324   EVT VecVT = Vec.getValueType();
 1367   EVT VecVT = Vec.getValueType();
 1391   EVT VT = Node->getValueType(0);
 1392   EVT EltVT = VT.getVectorElementType();
 1440   EVT FloatVT = Value.getValueType();
 1443   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), NumBits);
 1443   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), NumBits);
 1511   EVT IntVT = SignAsInt.IntValue.getValueType();
 1517   EVT FloatVT = Mag.getValueType();
 1530   EVT MagVT = MagAsInt.IntValue.getValueType();
 1537   EVT ShiftVT = IntVT;
 1563   EVT FloatVT = Value.getValueType();
 1572   EVT IntVT = ValueAsInt.IntValue.getValueType();
 1585   EVT VT = Node->getValueType(0);
 1632 bool SelectionDAGLegalize::LegalizeSetCCCondCode(EVT VT, SDValue &LHS,
 1738 SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
 1739                                                EVT DestVT, const SDLoc &dl) {
 1743 SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
 1744                                                EVT DestVT, const SDLoc &dl,
 1807   EVT VT = Node->getValueType(0);
 1902   EVT VT = Node->getValueType(0);
 1903   EVT OpVT = Node->getOperand(0).getValueType();
 1904   EVT EltVT = VT.getVectorElementType();
 2012   EVT VT = Node->getValueType(0);
 2027     EVT ArgVT = Op.getValueType();
 2038   EVT RetVT = Node->getValueType(0);
 2091     EVT ArgVT = Node->getOperand(i).getValueType();
 2202   EVT RetVT = Node->getValueType(0);
 2208     EVT ArgVT = Op.getValueType();
 2297   EVT RetVT = Node->getValueType(0);
 2348                                                    EVT DestVT,
 2350   EVT SrcVT = Op0.getValueType();
 2459 SDValue SelectionDAGLegalize::PromoteLegalINT_TO_FP(SDValue LegalOp, EVT DestVT,
 2463   EVT NewInTy = LegalOp.getValueType();
 2500 SDValue SelectionDAGLegalize::PromoteLegalFP_TO_INT(SDValue LegalOp, EVT DestVT,
 2504   EVT NewOutTy = DestVT;
 2539   EVT VT = Op.getValueType();
 2540   EVT SHVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
 2603   EVT VT = Op.getValueType();
 2604   EVT SHVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
 2765     EVT AtomicType = cast<AtomicSDNode>(Node)->getMemoryVT();
 2766     EVT OuterType = Node->getValueType(0);
 2805     EVT VT = Node->getValueType(0);
 2854     EVT ExtraVT = cast<VTSDNode>(Node->getOperand(1))->getVT();
 2855     EVT VT = Node->getValueType(0);
 2875     EVT ShiftAmountTy = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
 2958     EVT VT = Node->getValueType(0);
 2959     EVT EltVT = VT.getVectorElementType();
 2963       EVT NewEltVT = TLI.getTypeToTransformTo(*DAG.getContext(), EltVT);
 2974         EVT NewVT =
 2975             EVT::getVectorVT(*DAG.getContext(), NewEltVT,
 3031     EVT OpTy = Node->getOperand(0).getValueType();
 3115     EVT VT = Node->getValueType(0);
 3174     EVT VT = Node->getValueType(0);
 3185     EVT VT = Node->getValueType(0);
 3198     EVT VT = Node->getValueType(0);
 3221     EVT VT = Node->getValueType(0);
 3234     EVT VT = Node->getValueType(0);
 3257     EVT HalfType = EVT(VT).getHalfSizedIntegerVT(*DAG.getContext());
 3276     EVT VT = Node->getValueType(0);
 3304     EVT HalfType = VT.getHalfSizedIntegerVT(*DAG.getContext());
 3353     EVT VT = LHS.getValueType();
 3357     EVT CarryType = Node->getValueType(1);
 3358     EVT SetCCType = getSetCCResultType(Node->getValueType(0));
 3411     EVT PairTy = Node->getValueType(0);
 3443     EVT PTy = TLI.getPointerTy(TD);
 3462     EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
 3462     EVT MemVT = EVT::getIntegerVT(*DAG.getContext(), EntrySize * 8);
 3531     EVT VT = Node->getValueType(0);
 3555     EVT VT = Node->getValueType(0);
 3562       EVT CmpVT = Tmp1.getValueType();
 3566       EVT CCVT = getSetCCResultType(CmpVT);
 3662     EVT VT = Node->getValueType(0);
 4458     EVT IdxVT = Idx.getValueType();
 4505     EVT IdxVT = Idx.getValueType();

lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

   29 static RTLIB::Libcall GetFPLibCall(EVT VT,
  166   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  178   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  182   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  195   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  199   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  212   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  216   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  229   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  232   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  244   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  247   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  263   EVT LVT = LHS.getValueType();
  264   EVT RVT = RHS.getValueType();
  307   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  310   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  322   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  326   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  339   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  342   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  354   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  357   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  369   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  372   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  384   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  387   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  399   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  402   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  414   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  417   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  429   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  434   EVT OpsVT[3] = { N->getOperand(0).getValueType(),
  448   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  452   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  465   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  468   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  480   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  483   EVT FloatVT = N->getValueType(0);
  505   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  529   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  537   EVT MidVT = TLI.getTypeToTransformTo(*DAG.getContext(), MVT::f32);
  540   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  547   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  554   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  565   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  571   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  575   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  590   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  593   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  606   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  610   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  623   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  626   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  638   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  641   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  653   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  656   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  668   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  671   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  683   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  687   EVT OpsVT[2] = { N->getOperand(0).getValueType(),
  700   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  706   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  719   EVT VT = N->getValueType(0);
  720   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
  774   EVT VT = N->getValueType(0);
  775   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
  791   EVT SVT = N->getOperand(0).getValueType();
  792   EVT RVT = N->getValueType(0);
  793   EVT NVT = EVT();
  814   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  878   EVT SVT = N->getOperand(0).getValueType();
  879   EVT RVT = N->getValueType(0);
  889   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  900   EVT SVT = N->getOperand(0).getValueType();
  901   EVT RVT = N->getValueType(0);
  902   EVT FloatRVT = N->getOpcode() == ISD::FP_TO_FP16 ? MVT::f16 : RVT;
  909   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  918   EVT VT = NewLHS.getValueType();
  940   EVT SVT = N->getOperand(0).getValueType();
  941   EVT RVT = N->getValueType(0);
  942   EVT NVT = EVT();
  962   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
  974   EVT VT = NewLHS.getValueType();
  998   EVT VT = NewLHS.getValueType();
 1036   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1039   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1041   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
 1053   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1056   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1058   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
 1070   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1073   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1075   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
 1087   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1090   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1092   EVT OpsVT[1] = { N->getOperand(0).getValueType() };
 1181   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1406   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1523   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), LD->getValueType(0));
 1545   EVT VT = N->getValueType(0);
 1546   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 1548   EVT SrcVT = Src.getValueType();
 1748   EVT RVT = N->getValueType(0);
 1758   EVT RVT = N->getValueType(0);
 1814   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(),
 1828   EVT RVT = N->getValueType(0);
 1829   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1841   EVT RVT = N->getValueType(0);
 1842   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1854   EVT RVT = N->getValueType(0);
 1855   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1867   EVT RVT = N->getValueType(0);
 1868   EVT RetVT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 1884 static ISD::NodeType GetPromotionOpcode(EVT OpVT, EVT RetVT) {
 1884 static ISD::NodeType GetPromotionOpcode(EVT OpVT, EVT RetVT) {
 1934   EVT OpVT = Op->getValueType(0);
 1937   EVT PromotedVT = Promoted->getValueType(0);
 1940   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
 1940   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), OpVT.getSizeInBits());
 1966   EVT VT = N->getValueType(0);
 1991   EVT VT = N->getValueType(0);
 1992   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2009   EVT VT = ST->getOperand(1).getValueType();
 2010   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2010   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2111   EVT VT = N->getValueType(0);
 2112   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2115   EVT IVT = EVT::getIntegerVT(*DAG.getContext(),
 2115   EVT IVT = EVT::getIntegerVT(*DAG.getContext(),
 2123   EVT VT = N->getValueType(0);
 2127   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2127   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2134   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2150     EVT VecVT = Vec->getValueType(0);
 2151     EVT EltVT = VecVT.getVectorElementType();
 2189   EVT IVT = NewOp.getValueType().getVectorElementType();
 2196   EVT VT = N->getValueType(0);
 2197   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2205   EVT VT = N->getValueType(0);
 2206   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2218   EVT VT = N->getValueType(0);
 2219   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2229   EVT VT = N->getValueType(0);
 2230   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2237   EVT VT = N->getValueType(0);
 2238   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2248   EVT VT = N->getValueType(0);
 2249   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2262   EVT VT = N->getValueType(0);
 2263   EVT OpVT = Op->getValueType(0);
 2264   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2265   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2265   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2275   EVT VT = N->getValueType(0);
 2278   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2278   EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 2290   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2318   EVT VT = N->getValueType(0);
 2319   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2333   EVT VT = N->getValueType(0);
 2334   EVT NFPVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2340   EVT CastVT = CastVal.getValueType();

lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp

  224   EVT ResVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  251     EVT SVT = getSetCCResultType(N->getOperand(2).getValueType());
  252     EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
  284   EVT InVT = InOp.getValueType();
  285   EVT NInVT = TLI.getTypeToTransformTo(*DAG.getContext(), InVT);
  286   EVT OutVT = N->getValueType(0);
  287   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
  329                          EVT::getIntegerVT(*DAG.getContext(),
  350         EVT WideOutVT = EVT::getVectorVT(*DAG.getContext(),
  350         EVT WideOutVT = EVT::getVectorVT(*DAG.getContext(),
  370 static EVT getShiftAmountTyForConstant(EVT VT, const TargetLowering &TLI,
  370 static EVT getShiftAmountTyForConstant(EVT VT, const TargetLowering &TLI,
  372   EVT ShiftVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
  383   EVT OVT = N->getValueType(0);
  384   EVT NVT = Op.getValueType();
  388   EVT ShiftVT = getShiftAmountTyForConstant(NVT, TLI, DAG);
  395   EVT OVT = N->getValueType(0);
  396   EVT NVT = Op.getValueType();
  400   EVT ShiftVT = getShiftAmountTyForConstant(NVT, TLI, DAG);
  416   EVT VT = N->getValueType(0);
  433   EVT OVT = N->getValueType(0);
  434   EVT NVT = Op.getValueType();
  451   EVT OVT = N->getValueType(0);
  452   EVT NVT = Op.getValueType();
  467   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  480     EVT SVT = In.getValueType().getScalarType();
  491   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  533   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  540   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  547   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  576   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  590   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  604   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  625   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
  626   EVT VT = N->getValueType(0);
  627   EVT SVT = getSetCCResultType(VT);
  669   EVT PromotedType = Op1Promoted.getValueType();
  689     EVT SHVT = TLI.getShiftAmountTy(PromotedType, DAG.getDataLayout());
  742   EVT OldType = N->getOperand(0).getValueType();
  743   EVT PromotedType = Op1Promoted.getValueType();
  752     EVT ShiftTy = TLI.getShiftAmountTy(PromotedType, DAG.getDataLayout());
  773   EVT OVT = N->getOperand(0).getValueType();
  774   EVT NVT = LHS.getValueType();
  819   EVT InVT = N->getOperand(0).getValueType();
  820   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  822   EVT SVT = getSetCCResultType(InVT);
  908   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
  923     EVT InVT = InOp.getValueType();
  934     EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
  934     EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
  946     EVT TruncVT = EVT::getVectorVT(*DAG.getContext(),
  946     EVT TruncVT = EVT::getVectorVT(*DAG.getContext(),
  951     EVT ExtVT = EVT::getVectorVT(*DAG.getContext(), NVT.getVectorElementType(),
  951     EVT ExtVT = EVT::getVectorVT(*DAG.getContext(), NVT.getVectorElementType(),
  974   EVT OVT = N->getOperand(0).getValueType();
  975   EVT NVT = LHS.getValueType();
 1014   EVT ValueVTs[] = {LHS.getValueType(), N->getValueType(1)};
 1038   EVT SmallVT = LHS.getValueType();
 1061     EVT ShiftTy = getShiftAmountTyForConstant(Mul.getValueType(), TLI, DAG);
 1092   EVT VT = N->getValueType(0);
 1111   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1335   EVT OVT = N->getOperand(0).getValueType();
 1351   EVT VecVT = N->getValueType(0);
 1412   EVT OpTy = N->getOperand(1).getValueType();
 1419   EVT OpVT = N->getOpcode() == ISD::SELECT ? OpTy.getScalarType() : OpTy;
 1483   EVT DataVT = DataOp.getValueType();
 1508   EVT DataVT = N->getValueType(0);
 1521     EVT DataVT = N->getValueType(0);
 1541     EVT DataVT = N->getValue().getValueType();
 1637   EVT EltVT = Op.getValueType().getVectorElementType();
 1638   EVT VT = N->getValueType(0);
 1839   EVT NVT = InL.getValueType();
 1842   EVT ShTy = N->getOperand(1).getValueType();
 1916   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 1917   EVT ShTy = Amt.getValueType();
 2003   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2004   EVT ShTy = Amt.getValueType();
 2105   EVT NVT = LHSL.getValueType();
 2106   EVT CCT = getSetCCResultType(NVT);
 2133   EVT NVT = LHSL.getValueType();
 2185     EVT OvfVT = getSetCCResultType(NVT);
 2378   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2403   EVT NVT = Lo.getValueType();
 2404   EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
 2410                      DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(),
 2425   EVT NVT = Lo.getValueType();
 2426   EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
 2432                      DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(),
 2459   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2475   EVT VT = N->getValueType(0);
 2483   EVT NVT = Lo.getValueType();
 2495   EVT NVT = Lo.getValueType();
 2515   EVT NVT = Lo.getValueType();
 2526   EVT NVT = Lo.getValueType();
 2544   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2547   EVT ShiftAmtTy = TLI.getShiftAmountTy(NVT, DAG.getDataLayout());
 2557   EVT VT = N->getValueType(0);
 2574   EVT VT = N->getValueType(0);
 2590   EVT VT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 2608   EVT RetVT = N->getValueType(0);
 2618   EVT VT = N->getOperand(0).getValueType().getSimpleVT().SimpleTy;
 2636   EVT RetVT = N->getValueType(0);
 2652   EVT VT = N->getValueType(0);
 2653   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2665     EVT MemVT = N->getMemoryVT();
 2695     EVT NEVT = EVT::getIntegerVT(*DAG.getContext(), ExcessBits);
 2695     EVT NEVT = EVT::getIntegerVT(*DAG.getContext(), ExcessBits);
 2712     EVT MemVT = N->getMemoryVT();
 2719                         EVT::getIntegerVT(*DAG.getContext(),
 2729                         EVT::getIntegerVT(*DAG.getContext(), ExcessBits),
 2769   EVT VT = N->getValueType(0);
 2770   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2808     EVT ShiftAmtTy = TLI.getShiftAmountTy(NVT, DAG.getDataLayout());
 2851   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2873   EVT VT = N->getValueType(0);
 2889       EVT BoolVT = getSetCCResultType(VT);
 2919   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2936   EVT ShiftTy = TLI.getShiftAmountTy(NVT, DAG.getDataLayout());
 2995   EVT BoolNVT = getSetCCResultType(NVT);
 3107   EVT OType = Node->getValueType(1);
 3127   EVT VT = N->getValueType(0);
 3155   EVT VT = N->getValueType(0);
 3182   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 3192     EVT VT = LHSL.getValueType();
 3198     EVT ShiftTy = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
 3261   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3285                      DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(),
 3294   EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
 3311                      DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(),
 3318   EVT VT = N->getValueType(0);
 3346   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3358   EVT VT = N->getValueType(0);
 3378     EVT HalfVT = LHSLow.getValueType()
 3416   EVT PtrVT = TLI.getPointerTy(DAG.getDataLayout());
 3438     EVT ArgVT = Op.getValueType();
 3476   EVT VT = N->getValueType(0);
 3503   EVT VT = N->getValueType(0);
 3530   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3550                                 EVT::getIntegerVT(*DAG.getContext(),
 3558   EVT VT = cast<AtomicSDNode>(N)->getMemoryVT();
 3746   EVT HiVT = LHSHi.getValueType();
 3747   EVT ExpandVT = TLI.getTypeToExpandTo(*DAG.getContext(), HiVT);
 3770     EVT LoVT = LHSLo.getValueType();
 3881   EVT DstVT = N->getValueType(0);
 3897   EVT VT = N->getOperand(1).getValueType();
 3898   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 3924     EVT NEVT = EVT::getIntegerVT(*DAG.getContext(), ExcessBits);
 3924     EVT NEVT = EVT::getIntegerVT(*DAG.getContext(), ExcessBits);
 3939   EVT ExtVT = N->getMemoryVT();
 3943   EVT HiVT = EVT::getIntegerVT(*DAG.getContext(),
 3943   EVT HiVT = EVT::getIntegerVT(*DAG.getContext(),
 3967                          EVT::getIntegerVT(*DAG.getContext(), ExcessBits),
 3981   EVT SrcVT = Op.getValueType();
 3982   EVT DstVT = N->getValueType(0);
 4070   EVT OutVT = N->getValueType(0);
 4071   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4074   EVT NOutVTElem = NOutVT.getVectorElementType();
 4083   EVT InVT = InOp0.getValueType();
 4106   EVT VT = N->getValueType(0);
 4113   EVT OutVT = V0.getValueType();
 4120   EVT OutVT = N->getValueType(0);
 4121   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4124   EVT NOutVTElem = NOutVT.getVectorElementType();
 4153   EVT OutVT = N->getValueType(0);
 4154   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4156   EVT NOutVTElem = NOutVT.getVectorElementType();
 4170   EVT OutVT = N->getValueType(0);
 4171   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4173   EVT NOutElemVT = NOutVT.getVectorElementType();
 4183   EVT OutVT = N->getValueType(0);
 4184   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4187   EVT OutElemTy = NOutVT.getVectorElementType();
 4201     EVT SclrTy = Op.getValueType().getVectorElementType();
 4217   EVT VT = N->getValueType(0);
 4218   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 4252   EVT OutVT = N->getValueType(0);
 4253   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
 4256   EVT NOutVTElem = NOutVT.getVectorElementType();
 4271   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4303   EVT RetSclrTy = N->getValueType(0).getVectorElementType();
 4311     EVT SclrTy = Incoming->getValueType(0).getVectorElementType();

lib/CodeGen/SelectionDAG/LegalizeTypes.cpp

  234       EVT ResultVT = N->getValueType(i);
  294       EVT OpVT = Op.getValueType();
  843                      EVT::getIntegerVT(*DAG.getContext(), BitWidth), Op);
  850   EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth);
  850   EVT EltNVT = EVT::getIntegerVT(*DAG.getContext(), EltWidth);
  853                      EVT::getVectorVT(*DAG.getContext(), EltNVT, EltCnt), Op);
  857                                                EVT DestVT) {
  877 bool DAGTypeLegalizer::CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult) {
  915 bool DAGTypeLegalizer::CustomWidenLowerNode(SDNode *N, EVT VT) {
  952   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), Pair.getValueType());
  964   EVT LVT = Lo.getValueType();
  965   EVT HVT = Hi.getValueType();
  966   EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
  966   EVT NVT = EVT::getIntegerVT(*DAG.getContext(),
  969   EVT ShiftAmtVT = TLI.getShiftAmountTy(NVT, DAG.getDataLayout(), false);
 1013     EVT ArgVT = Node->getOperand(i).getValueType();
 1044 SDValue DAGTypeLegalizer::PromoteTargetBoolean(SDValue Bool, EVT ValVT) {
 1046   EVT BoolVT = getSetCCResultType(ValVT);
 1054                                     EVT LoVT, EVT HiVT,
 1054                                     EVT LoVT, EVT HiVT,
 1075   EVT HalfVT =
 1076       EVT::getIntegerVT(*DAG.getContext(), Op.getValueSizeInBits() / 2);

lib/CodeGen/SelectionDAG/LegalizeTypes.h

   62   TargetLowering::LegalizeTypeAction getTypeAction(EVT VT) const {
   67   bool isTypeLegal(EVT VT) const {
   72   bool isSimpleLegalType(EVT VT) const {
   76   EVT getSetCCResultType(EVT VT) const {
   76   EVT getSetCCResultType(EVT VT) const {
  208   SDValue CreateStackStoreLoad(SDValue Op, EVT DestVT);
  209   bool CustomLowerNode(SDNode *N, EVT VT, bool LegalizeResult);
  210   bool CustomWidenLowerNode(SDNode *N, EVT VT);
  224   SDValue PromoteTargetBoolean(SDValue Bool, EVT ValVT);
  228   void SplitInteger(SDValue Op, EVT LoVT, EVT HiVT,
  228   void SplitInteger(SDValue Op, EVT LoVT, EVT HiVT,
  259     EVT OldVT = Op.getValueType();
  268     EVT OldVT = Op.getValueType();
  279     EVT OldVT = Op.getValueType();
  885   SDValue ModifyToType(SDValue InOp, EVT NVT, bool FillWithZeroes = false);
  889   SDValue convertMask(SDValue InMask, EVT MaskVT, EVT ToMaskVT);
  889   SDValue convertMask(SDValue InMask, EVT MaskVT, EVT ToMaskVT);
  941                        SmallVectorImpl<SDValue> &Ops, EVT EltVT);

lib/CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp

   41   EVT OutVT = N->getValueType(0);
   42   EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
   44   EVT InVT = InOp.getValueType();
   88       EVT LoVT, HiVT;
  103     EVT ElemVT = NOutVT;
  104     EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
  104     EVT NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
  113       ElemVT = EVT::getIntegerVT(*DAG.getContext(), NewSizeInBits);
  114       NVT = EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems);
  139             EVT::getIntegerVT(*DAG.getContext(), LHS.getValueSizeInBits() << 1),
  209   EVT OldEltVT = OldVec.getValueType().getVectorElementType();
  214   EVT OldVT = N->getValueType(0);
  215   EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
  222     EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts);
  222     EVT NVecVT = EVT::getVectorVT(*DAG.getContext(), OldVT, OldElts);
  227                                EVT::getVectorVT(*DAG.getContext(),
  251   EVT ValueVT = LD->getValueType(0);
  252   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
  287   EVT OVT = N->getValueType(0);
  288   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
  314                                        EVT EltVT) {
  345     EVT OVT = N->getOperand(0).getValueType();
  346     EVT NVT = EVT::getVectorVT(*DAG.getContext(),
  346     EVT NVT = EVT::getVectorVT(*DAG.getContext(),
  370   EVT VecVT = N->getValueType(0);
  372   EVT OldVT = N->getOperand(0).getValueType();
  373   EVT NewVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldVT);
  393   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NewElts.size());
  393   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NewElts.size());
  408   EVT VecVT = N->getValueType(0);
  413   EVT OldEVT = Val.getValueType();
  414   EVT NewEVT = TLI.getTypeToTransformTo(*DAG.getContext(), OldEVT);
  421   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2);
  421   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewEVT, NumElts*2);
  444   EVT VT = N->getValueType(0);
  462   EVT ValueVT = St->getValue().getValueType();
  463   EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), ValueVT);
  528       EVT CondLHSVT = Cond.getOperand(0).getValueType();
  557   EVT LoVT, HiVT;

lib/CodeGen/SelectionDAG/LegalizeVectorOps.cpp

  275     EVT StVT = ST->getMemoryVT();
  351       EVT EltVT = Node->getValueType(0).getVectorElementType();
  625   EVT SrcVT = LD->getMemoryVT();
  626   EVT SrcEltVT = SrcVT.getScalarType();
  637     EVT DstEltVT = LD->getValueType(0).getScalarType();
  647     EVT WideVT = TLI.getPointerTy(DAG.getDataLayout());
  670         EVT LoadVT = WideVT;
  673           LoadVT = EVT::getIntegerVT(*DAG.getContext(), LoadBytes << 3);
  891   EVT VT = Op.getValueType();
  913   EVT MaskTy = VT.changeVectorElementTypeToInteger();
  916   EVT BitTy = MaskTy.getScalarType();
  943   EVT VT = Op.getValueType();
  951   EVT OrigTy = cast<VTSDNode>(Op->getOperand(1))->getVT();
  966   EVT VT = Op.getValueType();
  969   EVT SrcVT = Src.getValueType();
  978     SrcVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getScalarType(),
 1002   EVT VT = Op.getValueType();
 1004   EVT SrcVT = Src.getValueType();
 1026   EVT VT = Op.getValueType();
 1029   EVT SrcVT = Src.getValueType();
 1038     SrcVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getScalarType(),
 1064 static void createBSWAPShuffleMask(EVT VT, SmallVectorImpl<int> &ShuffleMask) {
 1072   EVT VT = Op.getValueType();
 1077   EVT ByteVT = EVT::getVectorVT(*DAG.getContext(), MVT::i8, ShuffleMask.size());
 1077   EVT ByteVT = EVT::getVectorVT(*DAG.getContext(), MVT::i8, ShuffleMask.size());
 1090   EVT VT = Op.getValueType();
 1104     EVT ByteVT = EVT::getVectorVT(*DAG.getContext(), MVT::i8, BSWAPMask.size());
 1104     EVT ByteVT = EVT::getVectorVT(*DAG.getContext(), MVT::i8, BSWAPMask.size());
 1141   EVT VT = Mask.getValueType();
 1204   EVT VT = Op.getOperand(0).getValueType();
 1262   EVT VT = Op.getValueType();
 1369   EVT VT = Op.getValueType();
 1370   EVT EltVT = VT.getVectorElementType();
 1374   EVT ValueVTs[] = {EltVT, MVT::Other};
 1391       EVT OperVT = Oper.getValueType();
 1416   EVT VT = Op.getValueType();
 1418   EVT EltVT = VT.getVectorElementType();
 1420   EVT TmpEltVT = LHS.getValueType().getVectorElementType();

lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp

  223   EVT VT = N->getValueType(0).getVectorElementType();
  226   EVT ValueVTs[] = {VT, MVT::Other};
  255   EVT ResVT = N->getValueType(0);
  256   EVT OvVT = N->getValueType(1);
  277   EVT OtherVT = N->getValueType(OtherNo);
  301   EVT NewVT = N->getValueType(0).getVectorElementType();
  307   EVT EltVT = N->getValueType(0).getVectorElementType();
  323   EVT NewVT = N->getValueType(0).getVectorElementType();
  330   EVT NewVT = N->getValueType(0).getVectorElementType();
  351   EVT EltVT = N->getValueType(0).getVectorElementType();
  377   EVT DestVT = N->getValueType(0).getVectorElementType();
  379   EVT OpVT = Op.getValueType();
  391     EVT VT = OpVT.getVectorElementType();
  400   EVT EltVT = N->getValueType(0).getVectorElementType();
  401   EVT ExtVT = cast<VTSDNode>(N->getOperand(1))->getVT().getVectorElementType();
  411   EVT OpVT = Op.getValueType();
  412   EVT OpEltVT = OpVT.getVectorElementType();
  413   EVT EltVT = N->getValueType(0).getVectorElementType();
  438   EVT EltVT = N->getValueType(0).getVectorElementType();
  447   EVT OpVT = Cond.getValueType();
  455     EVT VT = OpVT.getVectorElementType();
  475       EVT OpVT = Cond->getOperand(0).getValueType();
  482   EVT CondVT = Cond.getValueType();
  505   auto BoolVT = getSetCCResultType(CondVT);
  548   EVT OpVT = LHS.getValueType();
  549   EVT NVT = N->getValueType(0).getVectorElementType();
  557     EVT VT = OpVT.getVectorElementType();
  716   EVT VT = N->getValueType(0);
  730   EVT VT = N->getValueType(0);
  745   EVT VT = N->getValueType(0);
  749   EVT OpVT = N->getOperand(0).getValueType();
  750   EVT NVT = VT.getVectorElementType();
 1061   EVT LoVT, HiVT;
 1066   EVT InVT = InOp.getValueType();
 1101   EVT LoIntVT = EVT::getIntegerVT(*DAG.getContext(), LoVT.getSizeInBits());
 1101   EVT LoIntVT = EVT::getIntegerVT(*DAG.getContext(), LoVT.getSizeInBits());
 1102   EVT HiIntVT = EVT::getIntegerVT(*DAG.getContext(), HiVT.getSizeInBits());
 1102   EVT HiIntVT = EVT::getIntegerVT(*DAG.getContext(), HiVT.getSizeInBits());
 1116   EVT LoVT, HiVT;
 1138   EVT LoVT, HiVT;
 1154   EVT LoVT, HiVT;
 1172   EVT VecVT = Vec.getValueType();
 1185       EVT LoVT, HiVT;
 1234   EVT RHSVT = RHS.getValueType();
 1251   EVT LoVT, HiVT;
 1274   EVT InLoVT = InLo.getValueType();
 1277   EVT OutLoVT, OutHiVT;
 1303   EVT LoVT, HiVT;
 1320     EVT InVT = Op.getValueType();
 1334   EVT LoValueVTs[] = {LoVT, MVT::Other};
 1335   EVT HiValueVTs[] = {HiVT, MVT::Other};
 1351   EVT VT = N->getValueType(0);
 1353   EVT EltVT = VT.getVectorElementType();
 1366   EVT ChainVTs[] = {EltVT, MVT::Other};
 1374       EVT OperandVT = Operand.getValueType();
 1376         EVT OperandEltVT = OperandVT.getVectorElementType();
 1402   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, ResNE);
 1402   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, ResNE);
 1409   EVT ResVT = N->getValueType(0);
 1410   EVT OvVT = N->getValueType(1);
 1411   EVT LoResVT, HiResVT, LoOvVT, HiOvVT;
 1435   EVT OtherVT = N->getValueType(OtherNo);
 1474   EVT VecVT = Vec.getValueType();
 1475   EVT EltVT = VecVT.getVectorElementType();
 1478     VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
 1501   EVT LoVT, HiVT;
 1528   EVT LoVT, HiVT;
 1538   EVT LoVT, HiVT;
 1546   EVT MemoryVT = LD->getMemoryVT();
 1551   EVT LoMemVT, HiMemVT;
 1575   EVT LoVT, HiVT;
 1597   EVT MemoryVT = MLD->getMemoryVT();
 1598   EVT LoMemVT, HiMemVT;
 1640   EVT LoVT, HiVT;
 1663   EVT MemoryVT = MGT->getMemoryVT();
 1664   EVT LoMemVT, HiMemVT;
 1709   EVT LoVT, HiVT;
 1734   EVT LoVT, HiVT;
 1741   EVT InVT = N->getOperand(OpNo).getValueType();
 1777   EVT SrcVT = N->getOperand(0).getValueType();
 1778   EVT DestVT = N->getValueType(0);
 1779   EVT LoVT, HiVT;
 1799     EVT NewSrcVT = SrcVT.widenIntegerVectorElementType(Ctx);
 1800     EVT SplitSrcVT = SrcVT.getHalfNumVectorElementsVT(Ctx);
 1802     EVT SplitLoVT, SplitHiVT;
 1830   EVT NewVT = Inputs[0].getValueType();
 1888       EVT EltVT = NewVT.getVectorElementType();
 1933   EVT OVT = N->getValueType(0);
 1934   EVT NVT = OVT.getHalfNumVectorElementsVT(*DAG.getContext());
 2081   EVT Src0VT = Src0.getValueType();
 2090   EVT LoOpVT, HiOpVT;
 2108   EVT ResVT = N->getValueType(0);
 2113   EVT VecVT = VecOp.getValueType();
 2116   EVT LoOpVT, HiOpVT;
 2151   EVT ResVT = N->getValueType(0);
 2155   EVT InVT = Lo.getValueType();
 2157   EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
 2157   EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
 2200   EVT SubVT = N->getValueType(0);
 2223   EVT VecVT = Vec.getValueType();
 2246   EVT EltVT = VecVT.getVectorElementType();
 2249     VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
 2289   EVT LoVT, HiVT;
 2308   EVT MemoryVT = MGT->getMemoryVT();
 2309   EVT LoMemVT, HiMemVT;
 2364   EVT MemoryVT = N->getMemoryVT();
 2368   EVT LoMemVT, HiMemVT;
 2424   EVT MemoryVT = N->getMemoryVT();
 2429   EVT LoMemVT, HiMemVT;
 2487   EVT MemoryVT = N->getMemoryVT();
 2494   EVT LoMemVT, HiMemVT;
 2534   EVT EltVT = N->getValueType(0).getVectorElementType();
 2566   EVT InVT = InVec->getValueType(0);
 2567   EVT OutVT = N->getValueType(0);
 2579   EVT LoOutVT, HiOutVT;
 2592   EVT FinalVT = InVT;
 2604   EVT HalfElementVT = IsFloat ?
 2605     EVT::getFloatingPointVT(InElementSize/2) :
 2606     EVT::getIntegerVT(*DAG.getContext(), InElementSize/2);
 2607   EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT,
 2607   EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT,
 2612   EVT InterVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT, NumElements);
 2612   EVT InterVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT, NumElements);
 2636   EVT PartResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, PartElements);
 2636   EVT PartResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, PartElements);
 2637   EVT WideResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, 2*PartElements);
 2637   EVT WideResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, 2*PartElements);
 2643   EVT OpVT = N->getOperand(0).getValueType();
 2652   EVT ResVT = N->getValueType(0);
 2656   EVT InVT = Lo.getValueType();
 2658   EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
 2658   EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
 2872     EVT VT = N->getValueType(0);
 2873     EVT WideVecVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 2910   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2920   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2929   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 2942                                  unsigned ConcatEnd, EVT VT, EVT MaxVT,
 2942                                  unsigned ConcatEnd, EVT VT, EVT MaxVT,
 2943                                  EVT WidenVT) {
 2952   EVT WidenEltVT = WidenVT.getVectorElementType();
 2965     EVT NextVT;
 2968       NextVT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NextSize);
 3022   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3023   EVT WidenEltVT = WidenVT.getVectorElementType();
 3024   EVT VT = WidenVT;
 3029     VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
 3044   EVT MaxVT = VT;
 3072       VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
 3098   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3099   EVT WidenEltVT = WidenVT.getVectorElementType();
 3100   EVT VT = WidenVT;
 3104     VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
 3112   EVT MaxVT = VT;
 3157       EVT OperVT[] = {VT, MVT::Other};
 3166       VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
 3185         EVT WidenVT[] = {WidenEltVT, MVT::Other}; 
 3207   EVT ResVT = N->getValueType(0);
 3208   EVT OvVT = N->getValueType(1);
 3209   EVT WideResVT, WideOvVT;
 3215     WideOvVT = EVT::getVectorVT(
 3223     WideResVT = EVT::getVectorVT(
 3243   EVT OtherVT = N->getValueType(OtherNo);
 3261   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3264   EVT InVT = InOp.getValueType();
 3265   EVT InEltVT = InVT.getVectorElementType();
 3266   EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
 3266   EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
 3322   EVT EltVT = WidenVT.getVectorElementType();
 3345   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3347   SmallVector<EVT, 2> WidenVTs = { WidenVT, MVT::Other };
 3349   EVT InVT = InOp.getValueType();
 3350   EVT InEltVT = InVT.getVectorElementType();
 3357   EVT EltVT = WidenVT.getVectorElementType();
 3358   SmallVector<EVT, 2> EltVTs = { EltVT, MVT::Other };
 3382   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3383   EVT WidenSVT = WidenVT.getVectorElementType();
 3386   EVT InVT = InOp.getValueType();
 3387   EVT InSVT = InVT.getVectorElementType();
 3437   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3442   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3449   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3453   EVT ShVT = ShOp.getValueType();
 3458   EVT ShWidenVT = EVT::getVectorVT(*DAG.getContext(),
 3458   EVT ShWidenVT = EVT::getVectorVT(*DAG.getContext(),
 3469   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3475   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3476   EVT ExtVT = EVT::getVectorVT(*DAG.getContext(),
 3476   EVT ExtVT = EVT::getVectorVT(*DAG.getContext(),
 3492   EVT InVT = InOp.getValueType();
 3493   EVT VT = N->getValueType(0);
 3494   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 3539     EVT NewInVT;
 3542       EVT InEltVT = InVT.getVectorElementType();
 3543       NewInVT = EVT::getVectorVT(*DAG.getContext(), InEltVT,
 3546       NewInVT = EVT::getVectorVT(*DAG.getContext(), InVT, NewNumElts);
 3574   EVT VT = N->getValueType(0);
 3578   EVT EltVT = N->getOperand(0).getValueType();
 3581   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 3592   EVT InVT = N->getOperand(0).getValueType();
 3593   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3643   EVT EltVT = WidenVT.getVectorElementType();
 3662   EVT      VT = N->getValueType(0);
 3663   EVT      WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 3672   EVT InVT = InOp.getValueType();
 3687   EVT EltVT = VT.getVectorElementType();
 3738   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),N->getValueType(0));
 3740   EVT MaskVT = Mask.getValueType();
 3746   EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 3746   EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 3763   EVT WideVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3765   EVT MaskVT = Mask.getValueType();
 3772   EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 3772   EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 3779   EVT WideIndexVT = EVT::getVectorVT(*DAG.getContext(),
 3779   EVT WideIndexVT = EVT::getVectorVT(*DAG.getContext(),
 3796   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 3841 SDValue DAGTypeLegalizer::convertMask(SDValue InMask, EVT MaskVT,
 3842                                       EVT ToMaskVT) {
 3860     EVT ExtVT = EVT::getVectorVT(Ctx, ToMaskVT.getVectorElementType(),
 3860     EVT ExtVT = EVT::getVectorVT(Ctx, ToMaskVT.getVectorElementType(),
 3864     EVT TruncVT = EVT::getVectorVT(Ctx, ToMaskVT.getVectorElementType(),
 3864     EVT TruncVT = EVT::getVectorVT(Ctx, ToMaskVT.getVectorElementType(),
 3882     EVT SubVT = Mask->getValueType(0);
 3910   EVT CondVT = Cond->getValueType(0);
 3914   EVT VSelVT = N->getValueType(0);
 3920   EVT FinalVT = VSelVT;
 3929     EVT SetCCOpVT = Cond->getOperand(0).getValueType();
 3932     EVT SetCCResVT = getSetCCResultType(SetCCOpVT);
 3955   EVT ToMaskVT = VSelVT;
 3961     EVT MaskVT = getSetCCResultType(Cond.getOperand(0).getValueType());
 3969     EVT VT0 = getSetCCResultType(SETCC0.getOperand(0).getValueType());
 3970     EVT VT1 = getSetCCResultType(SETCC1.getOperand(0).getValueType());
 3974     EVT MaskVT;
 3979       EVT NarrowVT = ((ScalarBits0 < ScalarBits1) ? VT0 : VT1);
 3980       EVT WideVT = ((NarrowVT == VT0) ? VT1 : VT0);
 4005   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4009   EVT CondVT = Cond1.getValueType();
 4014     EVT CondEltVT = CondVT.getVectorElementType();
 4015     EVT CondWidenVT =  EVT::getVectorVT(*DAG.getContext(),
 4015     EVT CondWidenVT =  EVT::getVectorVT(*DAG.getContext(),
 4051  EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4056   EVT VT = N->getValueType(0);
 4059   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
 4084   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
 4088   EVT InVT = InOp1.getValueType();
 4090   EVT WidenInVT = EVT::getVectorVT(*DAG.getContext(),
 4090   EVT WidenInVT = EVT::getVectorVT(*DAG.getContext(),
 4213   EVT VT = N->getValueType(0);
 4226   EVT InVT = InOp.getValueType();
 4228     EVT InEltVT = InVT.getVectorElementType();
 4230       EVT FixedVT = (MVT::SimpleValueType)i;
 4231       EVT FixedEltVT = FixedVT.getVectorElementType();
 4281   EVT VT = N->getValueType(0);
 4282   EVT EltVT = VT.getVectorElementType();
 4290   EVT InVT = InOp.getValueType();
 4295   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
 4295   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
 4312   EVT InEltVT = InVT.getVectorElementType();
 4341   EVT VT = N->getValueType(0);
 4343   EVT InWidenVT = InOp.getValueType();
 4352     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), VT, NewNumElts);
 4352     EVT NewVT = EVT::getVectorVT(*DAG.getContext(), VT, NewNumElts);
 4366     EVT EltVT = VT.getVectorElementType();
 4370       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NewNumElts);
 4370       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NewNumElts);
 4383   EVT VT = N->getValueType(0);
 4384   EVT EltVT = VT.getVectorElementType();
 4385   EVT InVT = N->getOperand(0).getValueType();
 4459   EVT MaskVT = Mask.getValueType();
 4468     EVT WideVT = StVal.getValueType();
 4469     EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 4469     EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 4475     EVT WideMaskVT = TLI.getTypeToTransformTo(*DAG.getContext(), MaskVT);
 4478     EVT ValueVT = StVal.getValueType();
 4479     EVT WideVT = EVT::getVectorVT(*DAG.getContext(),
 4479     EVT WideVT = EVT::getVectorVT(*DAG.getContext(),
 4525     EVT IndexVT = Index.getValueType();
 4526     EVT WideIndexVT = EVT::getVectorVT(*DAG.getContext(),
 4526     EVT WideIndexVT = EVT::getVectorVT(*DAG.getContext(),
 4531     EVT MaskVT = Mask.getValueType();
 4532     EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 4532     EVT WideMaskVT = EVT::getVectorVT(*DAG.getContext(),
 4552   EVT VT = N->getValueType(0);
 4560   EVT SVT = getSetCCResultType(InOp0.getValueType());
 4563     SVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1,
 4570   EVT ResVT = EVT::getVectorVT(*DAG.getContext(),
 4570   EVT ResVT = EVT::getVectorVT(*DAG.getContext(),
 4577   EVT OpVT = N->getOperand(0).getValueType();
 4586   EVT OrigVT = N->getOperand(0).getValueType();
 4587   EVT WideVT = Op.getValueType();
 4588   EVT ElemVT = OrigVT.getVectorElementType();
 4643   EVT VT = N->getValueType(0);
 4669 static EVT FindMemType(SelectionDAG& DAG, const TargetLowering &TLI,
 4670                        unsigned Width, EVT WidenVT,
 4672   EVT WidenEltVT = WidenVT.getVectorElementType();
 4678   EVT RetVT = WidenEltVT;
 4686     EVT MemVT((MVT::SimpleValueType) VT);
 4708     EVT MemVT = (MVT::SimpleValueType) VT;
 4730 static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy,
 4735   EVT LdTy = LdOps[Start].getValueType();
 4738   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), LdTy, NumElts);
 4738   EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), LdTy, NumElts);
 4744     EVT NewLdTy = LdOps[i].getValueType();
 4747       NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewLdTy, NumElts);
 4766   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
 4768   EVT LdVT    = LD->getMemoryVT();
 4785   EVT NewVT = FindMemType(DAG, TLI, LdWidth, WidenVT, LdAlign, WidthDiff);
 4795       EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
 4795       EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
 4871   EVT LdTy = LdOps[i].getValueType();
 4883     EVT NewLdTy = LdOps[i].getValueType();
 4918   EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
 4919   EVT LdVT    = LD->getMemoryVT();
 4930   EVT EltVT = WidenVT.getVectorElementType();
 4931   EVT LdEltVT = LdVT.getVectorElementType();
 4972   EVT StVT = ST->getMemoryVT();
 4974   EVT ValVT = ValOp.getValueType();
 4976   EVT ValEltVT = ValVT.getVectorElementType();
 4984     EVT NewVT = FindMemType(DAG, TLI, StWidth, ValVT);
 5005       EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
 5005       EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
 5040   EVT StVT = ST->getMemoryVT();
 5041   EVT ValVT = ValOp.getValueType();
 5050   EVT StEltVT  = StVT.getVectorElementType();
 5051   EVT ValEltVT = ValVT.getVectorElementType();
 5075 SDValue DAGTypeLegalizer::ModifyToType(SDValue InOp, EVT NVT,
 5079   EVT InVT = InOp.getValueType();
 5109   EVT EltVT = NVT.getVectorElementType();

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

  140 static void CloneNodeWithValues(SDNode *N, SelectionDAG *DAG, ArrayRef<EVT> VTs,
  175   SmallVector<EVT, 4> VTs(N->value_begin(), N->value_end());
  479         EVT OpVT = N->getOperand(i).getValueType();

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

   80 static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
  118 bool ConstantFPSDNode::isValueValidForType(EVT VT,
  279   EVT SVT = Op.getValueType().getScalarType();
  311   EVT SVT = LHS.getValueType().getScalarType();
  796     EVT VT = N->getValueType(0);
  814     EVT EltVT = N->getValueType(0).getVectorElementType();
  872     EVT VT = cast<VTSDNode>(N)->getVT();
  988 unsigned SelectionDAG::getEVTAlignment(EVT VT) const {
 1098 SDValue SelectionDAG::getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT) {
 1104 SDValue SelectionDAG::getAnyExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT) {
 1110 SDValue SelectionDAG::getSExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT) {
 1116 SDValue SelectionDAG::getZExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT) {
 1122 SDValue SelectionDAG::getBoolExtOrTrunc(SDValue Op, const SDLoc &SL, EVT VT,
 1123                                         EVT OpVT) {
 1131 SDValue SelectionDAG::getZeroExtendInReg(SDValue Op, const SDLoc &DL, EVT VT) {
 1143 SDValue SelectionDAG::getPtrExtOrTrunc(SDValue Op, const SDLoc &DL, EVT VT) {
 1149 SDValue SelectionDAG::getPtrExtendInReg(SDValue Op, const SDLoc &DL, EVT VT) {
 1156 SDValue SelectionDAG::getNOT(const SDLoc &DL, SDValue Val, EVT VT) {
 1157   EVT EltVT = VT.getScalarType();
 1163 SDValue SelectionDAG::getLogicalNOT(const SDLoc &DL, SDValue Val, EVT VT) {
 1168 SDValue SelectionDAG::getBoolConstant(bool V, const SDLoc &DL, EVT VT,
 1169                                       EVT OpVT) {
 1183 SDValue SelectionDAG::getConstant(uint64_t Val, const SDLoc &DL, EVT VT,
 1185   EVT EltVT = VT.getScalarType();
 1192 SDValue SelectionDAG::getConstant(const APInt &Val, const SDLoc &DL, EVT VT,
 1198                                   EVT VT, bool isT, bool isO) {
 1201   EVT EltVT = VT.getScalarType();
 1224     EVT ViaEltVT = TLI->getTypeToTransformTo(*getContext(), EltVT);
 1227     EVT ViaVecVT = EVT::getVectorVT(*getContext(), ViaEltVT, ViaVecNumElts);
 1227     EVT ViaVecVT = EVT::getVectorVT(*getContext(), ViaEltVT, ViaVecNumElts);
 1295 SDValue SelectionDAG::getShiftAmountConstant(uint64_t Val, EVT VT,
 1297   EVT ShiftVT = TLI->getShiftAmountTy(VT, getDataLayout(), LegalTypes);
 1301 SDValue SelectionDAG::getConstantFP(const APFloat &V, const SDLoc &DL, EVT VT,
 1307                                     EVT VT, bool isTarget) {
 1310   EVT EltVT = VT.getScalarType();
 1338 SDValue SelectionDAG::getConstantFP(double Val, const SDLoc &DL, EVT VT,
 1340   EVT EltVT = VT.getScalarType();
 1357                                        EVT VT, int64_t Offset, bool isTargetGA,
 1389 SDValue SelectionDAG::getFrameIndex(int FI, EVT VT, bool isTarget) {
 1404 SDValue SelectionDAG::getJumpTable(int JTI, EVT VT, bool isTarget,
 1423 SDValue SelectionDAG::getConstantPool(const Constant *C, EVT VT,
 1451 SDValue SelectionDAG::getConstantPool(MachineConstantPoolValue *C, EVT VT,
 1477 SDValue SelectionDAG::getTargetIndex(int Index, EVT VT, int64_t Offset,
 1508 SDValue SelectionDAG::getValueType(EVT VT) {
 1522 SDValue SelectionDAG::getExternalSymbol(const char *Sym, EVT VT) {
 1530 SDValue SelectionDAG::getMCSymbol(MCSymbol *Sym, EVT VT) {
 1539 SDValue SelectionDAG::getTargetExternalSymbol(const char *Sym, EVT VT,
 1569 SDValue SelectionDAG::getVectorShuffle(EVT VT, const SDLoc &dl, SDValue N1,
 1702         EVT BuildVT = BV->getValueType(0);
 1743   EVT VT = SV.getValueType(0);
 1752 SDValue SelectionDAG::getRegister(unsigned RegNo, EVT VT) {
 1805 SDValue SelectionDAG::getBlockAddress(const BlockAddress *BA, EVT VT,
 1858 SDValue SelectionDAG::getBitcast(EVT VT, SDValue V) {
 1865 SDValue SelectionDAG::getAddrSpaceCast(const SDLoc &dl, EVT VT, SDValue Ptr,
 1888 SDValue SelectionDAG::getShiftAmountOperand(EVT LHSTy, SDValue Op) {
 1889   EVT OpTy = Op.getValueType();
 1890   EVT ShTy = TLI->getShiftAmountTy(LHSTy, getDataLayout());
 1900   EVT VT = Node->getValueType(0);
 1944 SDValue SelectionDAG::CreateStackTemporary(EVT VT, unsigned minAlign) {
 1955 SDValue SelectionDAG::CreateStackTemporary(EVT VT1, EVT VT2) {
 1955 SDValue SelectionDAG::CreateStackTemporary(EVT VT1, EVT VT2) {
 1968 SDValue SelectionDAG::FoldSetCC(EVT VT, SDValue N1, SDValue N2,
 1970   EVT OpVT = N1.getValueType();
 2128   EVT VT = V.getValueType();
 2218   EVT VT = V.getValueType();
 2247   EVT VT = V.getValueType();
 2326   EVT VT = V.getValueType();
 2339   EVT VT = V.getValueType();
 2422   EVT VT = Op.getValueType();
 2538     EVT SubVectorVT = Op.getOperand(0).getValueType();
 2620     EVT SubVT = N0.getValueType();
 2860     EVT EVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 2974       EVT VT = LD->getMemoryVT();
 2984     EVT InVT = Op.getOperand(0).getValueType();
 2996     EVT InVT = Op.getOperand(0).getValueType();
 3022     EVT VT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 3154     EVT VecVT = InVec.getValueType();
 3362   EVT OpVT = Val.getValueType();
 3403   EVT VT = Op.getValueType();
 3412   EVT VT = Op.getValueType();
 3495     EVT SrcVT = N0.getValueType();
 3550     EVT SrcVT = Src.getValueType();
 3799     EVT VecVT = InVec.getValueType();
 3838     EVT SubVectorVT = Op.getOperand(0).getValueType();
 4151 static SDValue FoldBUILD_VECTOR(const SDLoc &DL, EVT VT,
 4185 static SDValue foldCONCAT_VECTORS(const SDLoc &DL, EVT VT,
 4233   EVT SVT = VT.getScalarType();
 4236     EVT OpVT = Op.getValueType();
 4262 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT) {
 4279 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 4737                                              EVT VT, const ConstantSDNode *C1,
 4749 SDValue SelectionDAG::FoldSymbolOffset(unsigned Opcode, EVT VT,
 4795                                              EVT VT, SDNode *N1, SDNode *N2) {
 4837   EVT SVT = VT.getScalarType();
 4838   EVT LegalSVT = SVT;
 4883                                                    const SDLoc &DL, EVT VT,
 4921   EVT SVT = (Opcode == ISD::SETCC ? MVT::i1 : VT.getScalarType());
 4925   EVT LegalSVT = VT.getScalarType();
 4937       EVT InSVT = Op.getValueType().getScalarType();
 4949       EVT ScalarVT = ScalarOp.getValueType();
 4979                                          EVT VT, SDValue N1, SDValue N2) {
 5036 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 5175     EVT EVT = cast<VTSDNode>(N2)->getVT();
 5187     EVT EVT = cast<VTSDNode>(N2)->getVT();
 5213       llvm::EVT OpVT = N1.getOperand(0).getValueType();
 5445 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 5590 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 5596 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 5627 static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
 5645   EVT IntVT = VT.getScalarType();
 5647     IntVT = EVT::getIntegerVT(*DAG.getContext(), IntVT.getSizeInBits());
 5669 static SDValue getMemsetStringVal(EVT VT, const SDLoc &dl, SelectionDAG &DAG,
 5683                                          EVT::getVectorVT(*DAG.getContext(),
 5713   EVT VT = Base.getValueType();
 5787   std::vector<EVT> MemOps;
 5839     EVT VT = MemOps[i];
 5883       EVT NVT = TLI.getTypeToTransformTo(C, VT);
 5970   std::vector<EVT> MemOps;
 6012     EVT VT = MemOps[i];
 6032     EVT VT = MemOps[i];
 6076   std::vector<EVT> MemOps;
 6110   EVT LargestVT = MemOps[0];
 6117     EVT VT = MemOps[i];
 6480 SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
 6503                                        EVT MemVT, SDVTList VTs, SDValue Chain,
 6514 SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
 6534   EVT VT = Val.getValueType();
 6542 SDValue SelectionDAG::getAtomic(unsigned Opcode, const SDLoc &dl, EVT MemVT,
 6543                                 EVT VT, SDValue Chain, SDValue Ptr,
 6557   SmallVector<EVT, 4> VTs;
 6566     EVT MemVT, MachinePointerInfo PtrInfo, unsigned Align,
 6583                                           ArrayRef<SDValue> Ops, EVT MemVT,
 6694                               EVT VT, const SDLoc &dl, SDValue Chain,
 6696                               MachinePointerInfo PtrInfo, EVT MemVT,
 6719                               EVT VT, const SDLoc &dl, SDValue Chain,
 6720                               SDValue Ptr, SDValue Offset, EVT MemVT,
 6767 SDValue SelectionDAG::getLoad(EVT VT, const SDLoc &dl, SDValue Chain,
 6777 SDValue SelectionDAG::getLoad(EVT VT, const SDLoc &dl, SDValue Chain,
 6785                                  EVT VT, SDValue Chain, SDValue Ptr,
 6786                                  MachinePointerInfo PtrInfo, EVT MemVT,
 6796                                  EVT VT, SDValue Chain, SDValue Ptr, EVT MemVT,
 6796                                  EVT VT, SDValue Chain, SDValue Ptr, EVT MemVT,
 6843   EVT VT = Val.getValueType();
 6871                                     EVT SVT, unsigned Alignment,
 6892                                     SDValue Ptr, EVT SVT,
 6894   EVT VT = Val.getValueType();
 6964 SDValue SelectionDAG::getMaskedLoad(EVT VT, const SDLoc &dl, SDValue Chain,
 6966                                     EVT MemVT, MachineMemOperand *MMO,
 6994                                      EVT MemVT, MachineMemOperand *MMO,
 7022 SDValue SelectionDAG::getMaskedGather(SDVTList VTs, EVT VT, const SDLoc &dl,
 7063 SDValue SelectionDAG::getMaskedScatter(SDVTList VTs, EVT VT, const SDLoc &dl,
 7180 SDValue SelectionDAG::getVAArg(EVT VT, const SDLoc &dl, SDValue Chain,
 7186 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 7202 SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
 7268                               ArrayRef<EVT> ResultTys, ArrayRef<SDValue> Ops) {
 7358 SDVTList SelectionDAG::getVTList(EVT VT) {
 7362 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2) {
 7362 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2) {
 7371     EVT *Array = Allocator.Allocate<EVT>(2);
 7371     EVT *Array = Allocator.Allocate<EVT>(2);
 7380 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3) {
 7380 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3) {
 7380 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3) {
 7390     EVT *Array = Allocator.Allocate<EVT>(3);
 7390     EVT *Array = Allocator.Allocate<EVT>(3);
 7400 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4) {
 7400 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4) {
 7400 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4) {
 7400 SDVTList SelectionDAG::getVTList(EVT VT1, EVT VT2, EVT VT3, EVT VT4) {
 7411     EVT *Array = Allocator.Allocate<EVT>(4);
 7411     EVT *Array = Allocator.Allocate<EVT>(4);
 7422 SDVTList SelectionDAG::getVTList(ArrayRef<EVT> VTs) {
 7433     EVT *Array = Allocator.Allocate<EVT>(NumVTs);
 7433     EVT *Array = Allocator.Allocate<EVT>(NumVTs);
 7589                                    EVT VT) {
 7595                                    EVT VT, SDValue Op1) {
 7602                                    EVT VT, SDValue Op1,
 7610                                    EVT VT, SDValue Op1,
 7618                                    EVT VT, ArrayRef<SDValue> Ops) {
 7624                                    EVT VT1, EVT VT2, ArrayRef<SDValue> Ops) {
 7624                                    EVT VT1, EVT VT2, ArrayRef<SDValue> Ops) {
 7630                                    EVT VT1, EVT VT2) {
 7630                                    EVT VT1, EVT VT2) {
 7636                                    EVT VT1, EVT VT2, EVT VT3,
 7636                                    EVT VT1, EVT VT2, EVT VT3,
 7636                                    EVT VT1, EVT VT2, EVT VT3,
 7643                                    EVT VT1, EVT VT2,
 7643                                    EVT VT1, EVT VT2,
 7824                                             EVT VT) {
 7830                                             EVT VT, SDValue Op1) {
 7837                                             EVT VT, SDValue Op1, SDValue Op2) {
 7844                                             EVT VT, SDValue Op1, SDValue Op2,
 7852                                             EVT VT, ArrayRef<SDValue> Ops) {
 7858                                             EVT VT1, EVT VT2, SDValue Op1,
 7858                                             EVT VT1, EVT VT2, SDValue Op1,
 7866                                             EVT VT1, EVT VT2, SDValue Op1,
 7866                                             EVT VT1, EVT VT2, SDValue Op1,
 7874                                             EVT VT1, EVT VT2,
 7874                                             EVT VT1, EVT VT2,
 7881                                             EVT VT1, EVT VT2, EVT VT3,
 7881                                             EVT VT1, EVT VT2, EVT VT3,
 7881                                             EVT VT1, EVT VT2, EVT VT3,
 7889                                             EVT VT1, EVT VT2, EVT VT3,
 7889                                             EVT VT1, EVT VT2, EVT VT3,
 7889                                             EVT VT1, EVT VT2, EVT VT3,
 7898                                             EVT VT1, EVT VT2, EVT VT3,
 7898                                             EVT VT1, EVT VT2, EVT VT3,
 7898                                             EVT VT1, EVT VT2, EVT VT3,
 7905                                             ArrayRef<EVT> ResultTys,
 7941 SDValue SelectionDAG::getTargetExtractSubreg(int SRIdx, const SDLoc &DL, EVT VT,
 7951 SDValue SelectionDAG::getTargetInsertSubreg(int SRIdx, const SDLoc &DL, EVT VT,
 8730       EVT CVT = CN->getValueType(0);
 8731       EVT NSVT = N.getValueType().getScalarType();
 8754       EVT CVT = CN->getValueType(0);
 8755       EVT NSVT = N.getValueType().getScalarType();
 8822                                          const GlobalValue *GA, EVT VT,
 8829                                          EVT VT, unsigned SrcAS,
 8835                      SDVTList VTs, EVT memvt, MachineMemOperand *mmo)
 8857     std::vector<EVT> VTs;
 8868 static ManagedStatic<std::set<EVT, EVT::compareRawBits>> EVTs;
 8868 static ManagedStatic<std::set<EVT, EVT::compareRawBits>> EVTs;
 8874 const EVT *SDNode::getValueTypeList(EVT VT) {
 8874 const EVT *SDNode::getValueTypeList(EVT VT) {
 9050     EVT OpVT = Op.getValueType();
 9051     EVT OpSVT = OpVT.getScalarType();
 9052     EVT SubVT = EVT::getVectorVT(*getContext(), OpSVT, NumSubElts);
 9052     EVT SubVT = EVT::getVectorVT(*getContext(), OpSVT, NumSubElts);
 9114   EVT VT = N->getValueType(0);
 9116   EVT EltVT = VT.getVectorElementType();
 9132       EVT OperandVT = Operand.getValueType();
 9135         EVT OperandEltVT = OperandVT.getVectorElementType();
 9164       EVT ExtVT = cast<VTSDNode>(Operands[1])->getVT().getVectorElementType();
 9175   EVT VecVT = EVT::getVectorVT(*getContext(), EltVT, ResNE);
 9175   EVT VecVT = EVT::getVectorVT(*getContext(), EltVT, ResNE);
 9187   EVT ResVT = N->getValueType(0);
 9188   EVT OvVT = N->getValueType(1);
 9189   EVT ResEltVT = ResVT.getVectorElementType();
 9190   EVT OvEltVT = OvVT.getVectorElementType();
 9205   EVT SVT = TLI->getSetCCResultType(getDataLayout(), *getContext(), ResEltVT);
 9223   EVT NewResVT = EVT::getVectorVT(*getContext(), ResEltVT, ResNE);
 9223   EVT NewResVT = EVT::getVectorVT(*getContext(), ResEltVT, ResNE);
 9224   EVT NewOvVT = EVT::getVectorVT(*getContext(), OvEltVT, ResNE);
 9224   EVT NewOvVT = EVT::getVectorVT(*getContext(), OvEltVT, ResNE);
 9242   EVT VT = LD->getValueType(0);
 9296 std::pair<EVT, EVT> SelectionDAG::GetSplitDestVTs(const EVT &VT) const {
 9296 std::pair<EVT, EVT> SelectionDAG::GetSplitDestVTs(const EVT &VT) const {
 9296 std::pair<EVT, EVT> SelectionDAG::GetSplitDestVTs(const EVT &VT) const {
 9298   EVT LoVT, HiVT;
 9310 SelectionDAG::SplitVector(const SDValue &N, const SDLoc &DL, const EVT &LoVT,
 9311                           const EVT &HiVT) {
 9326   EVT VT = N.getValueType();
 9327   EVT WideVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(),
 9327   EVT WideVT = EVT::getVectorVT(*getContext(), VT.getVectorElementType(),
 9336   EVT VT = Op.getValueType();
 9340   EVT EltVT = VT.getVectorElementType();
 9341   EVT IdxTy = TLI->getVectorIdxTy(getDataLayout());
 9365   EVT VT = getValueType(0);
 9517 bool ShuffleVectorSDNode::isSplatMask(const int *Mask, EVT VT) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  192                                       MVT PartVT, EVT ValueVT, const Value *V,
  202                                 MVT PartVT, EVT ValueVT, const Value *V,
  223       EVT RoundVT = RoundBits == ValueBits ?
  224         ValueVT : EVT::getIntegerVT(*DAG.getContext(), RoundBits);
  227       EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), RoundBits/2);
  227       EVT HalfVT = EVT::getIntegerVT(*DAG.getContext(), RoundBits/2);
  247         EVT OddVT = EVT::getIntegerVT(*DAG.getContext(), OddParts * PartBits);
  247         EVT OddVT = EVT::getIntegerVT(*DAG.getContext(), OddParts * PartBits);
  255         EVT TotalVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
  255         EVT TotalVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
  278       EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
  278       EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
  286   EVT PartEVT = Val.getValueType();
  295     PartEVT = EVT::getIntegerVT(*DAG.getContext(),  ValueVT.getSizeInBits());
  359                                       MVT PartVT, EVT ValueVT, const Value *V,
  370     EVT IntermediateVT;
  413     EVT BuiltVectorTy =
  414         EVT::getVectorVT(*DAG.getContext(), IntermediateVT.getScalarType(),
  424   EVT PartEVT = Val.getValueType();
  468        EVT WiderVecType = EVT::getVectorVT(*DAG.getContext(),
  468        EVT WiderVecType = EVT::getVectorVT(*DAG.getContext(),
  482   EVT ValueSVT = ValueVT.getVectorElementType();
  503   EVT ValueVT = Val.getValueType();
  519   EVT PartEVT = PartVT;
  535         ValueVT = EVT::getIntegerVT(*DAG.getContext(),  ValueVT.getSizeInBits());
  541       ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
  555     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
  596     ValueVT = EVT::getIntegerVT(*DAG.getContext(), NumParts * PartBits);
  603                          EVT::getIntegerVT(*DAG.getContext(),
  610       EVT ThisVT = EVT::getIntegerVT(*DAG.getContext(), ThisBits);
  610       EVT ThisVT = EVT::getIntegerVT(*DAG.getContext(), ThisBits);
  631                                      SDValue Val, const SDLoc &DL, EVT PartVT) {
  635   EVT ValueVT = Val.getValueType();
  640     EVT ElementVT = PartVT.getVectorElementType();
  662   EVT ValueVT = Val.getValueType();
  668     EVT PartEVT = PartVT;
  691         EVT IntermediateType =
  692             EVT::getIntegerVT(*DAG.getContext(), ValueVT.getSizeInBits());
  704   EVT IntermediateVT;
  728   EVT BuiltVectorTy = EVT::getVectorVT(
  728   EVT BuiltVectorTy = EVT::getVectorVT(
  782   for (EVT ValueVT : ValueVTs) {
  814     EVT ValueVT = ValueVTs[Value];
  860       EVT FromVT(MVT::Other);
  862         FromVT = EVT::getIntegerVT(*DAG.getContext(), RegSize - NumZeroBits);
  866             EVT::getIntegerVT(*DAG.getContext(), RegSize - NumSignBits + 1);
 1444     EVT VT = TLI.getValueType(DAG.getDataLayout(), V->getType(), true);
 1507       SmallVector<EVT, 4> ValueVTs;
 1514         EVT EltVT = ValueVTs[i];
 1540       EVT EltVT =
 1790     SmallVector<EVT, 1> PtrValueVTs;
 1800     SmallVector<EVT, 4> ValueVTs, MemVTs;
 1823     SmallVector<EVT, 4> ValueVTs;
 1848         EVT VT = ValueVTs[j];
 2328   EVT MemVT = TLI.getMemValueType(DAG.getDataLayout(), CB.CmpLHS->getType());
 2360     EVT VT = CmpOp.getValueType();
 2406   EVT PTy = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
 2425   EVT VT = SwitchOp.getValueType();
 2477   EVT PtrTy = TLI.getPointerTy(DAG.getDataLayout());
 2478   EVT PtrMemTy = TLI.getPointerMemTy(DAG.getDataLayout());
 2507   EVT PtrTy = TLI.getPointerTy(DAG.getDataLayout());
 2508   EVT PtrMemTy = TLI.getPointerMemTy(DAG.getDataLayout());
 2570   EVT VT = Guard.getValueType();
 2624   EVT VT = SwitchOp.getValueType();
 2878   SmallVector<EVT, 2> ValueVTs;
 3136   EVT ShiftTy = DAG.getTargetLoweringInfo().getShiftAmountTy(
 3207   EVT MemVT =
 3218   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3237   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3251   SmallVector<EVT, 4> ValueVTs;
 3269     EVT VT = ValueVTs[0];
 3381   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3390   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3399   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3409   EVT DestVT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 3418   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3426   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3434   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3442   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3450   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3460   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3462   EVT PtrMemVT =
 3474   EVT DestVT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 3475   EVT PtrMemVT = TLI.getMemValueType(DAG.getDataLayout(), I.getType());
 3484   EVT DestVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 3507   EVT DestVT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 3545   EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 3546   EVT SrcVT = Src1.getValueType();
 3620     EVT PaddedVT = EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(),
 3620     EVT PaddedVT = EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(),
 3718   EVT EltVT = VT.getVectorElementType();
 3719   EVT IdxVT = TLI.getVectorIdxTy(DAG.getDataLayout());
 3757   SmallVector<EVT, 4> AggValueVTs;
 3759   SmallVector<EVT, 4> ValValueVTs;
 3809   SmallVector<EVT, 4> ValValueVTs;
 3852     EVT VT = EVT::getVectorVT(Context, N.getValueType(), VectorWidth);
 3852     EVT VT = EVT::getVectorVT(Context, N.getValueType(), VectorWidth);
 3891           DAG.getConstant(Offs, dl, EVT::getVectorVT(Context, IdxTy, VectorWidth)) :
 3910         EVT VT = EVT::getVectorVT(*Context, IdxN.getValueType(), VectorWidth);
 3910         EVT VT = EVT::getVectorVT(*Context, IdxN.getValueType(), VectorWidth);
 3961   EVT IntPtr = TLI.getPointerTy(DAG.getDataLayout(), DL.getAllocaAddrSpace());
 4034   SmallVector<EVT, 4> ValueVTs, MemVTs;
 4071   EVT PtrVT = Ptr.getValueType();
 4130   SmallVector<EVT, 4> ValueVTs;
 4169   SmallVector<EVT, 4> ValueVTs;
 4206   SmallVector<EVT, 4> ValueVTs, MemVTs;
 4223   EVT PtrVT = Ptr.getValueType();
 4297   EVT VT = Src0.getValueType();
 4378     EVT VT = EVT::getVectorVT(Context, Index.getValueType(), GEPWidth);
 4378     EVT VT = EVT::getVectorVT(Context, Index.getValueType(), GEPWidth);
 4391   EVT VT = Src0.getValueType();
 4457   EVT VT = Src0.getValueType();
 4499   EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 4656   EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 4657   EVT MemVT = TLI.getMemValueType(DAG.getDataLayout(), I.getType());
 4722   EVT MemVT =
 4802     EVT VT = TLI.getValueType(*DL, Arg->getType(), true);
 4813   SmallVector<EVT, 4> ValueVTs;
 4849       EVT VT = TLI.getValueType(DAG.getDataLayout(), PTy);
 5677     EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 6067     EVT RetVT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 6144     EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 6205     EVT Ty = Arg.getValueType();
 6213     EVT Ty = Arg.getValueType();
 6220     EVT Ty = Arg.getValueType();
 6230     EVT VT = X.getValueType();
 6279     EVT CCVT = MVT::i1;
 6281       CCVT = EVT::getVectorVT(*Context, CCVT, VT.getVectorNumElements());
 6353     EVT PtrTy = TLI.getPointerTy(DAG.getDataLayout());
 6354     EVT ResTy = TLI.getValueType(DAG.getDataLayout(), I.getType());
 6367     EVT PtrTy = TLI.getPointerTy(DAG.getDataLayout());
 6390     EVT PtrTy = TLI.getPointerTy(DAG.getDataLayout());
 6533     EVT ResultVT = Op1.getValueType();
 6534     EVT OverflowVT = MVT::i1;
 6536       OverflowVT = EVT::getVectorVT(
 6554                                              EVT::getIntegerVT(*Context, 8),
 6870     EVT DestVT =
 6985   SmallVector<EVT, 4> ValueVTs;
 7246   EVT VT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 7265     EVT CallVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),
 7337     EVT CmpVT = EVT::getIntegerVT(LHS->getContext(), LoadVT.getSizeInBits());
 7337     EVT CmpVT = EVT::getIntegerVT(LHS->getContext(), LoadVT.getSizeInBits());
 7529   EVT VT = Tmp0.getValueType();
 7754   EVT getCallOperandValEVT(LLVMContext &Context, const TargetLowering &TLI,
 7950   EVT ValueVT = OpInfo.ConstraintVT;
 8074         EVT VT = TLI.getValueType(DAG.getDataLayout(), BA->getType(), true);
 8411   SmallVector<EVT, 1> ResultVTs;
 8426     EVT ResultVT = TLI.getValueType(DAG.getDataLayout(), *CurResultType);
 8525   SmallVector<EVT, 1> ValueVTs;
 8595   EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), Bits);
 8595   EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), Bits);
 8860     SmallVector<EVT, 3> ValueVTs;
 8907   EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType());
 8991   SmallVector<EVT, 4> RetTys;
 8998     SmallVector<EVT, 4> OldRetTys;
 9004       EVT RetVT = OldRetTys[i];
 9067       EVT VT = RetTys[I];
 9112     SmallVector<EVT, 4> ValueVTs;
 9122       EVT VT = ValueVTs[Value];
 9293     SmallVector<EVT, 1> PVTs;
 9298     EVT PtrVT = PVTs[0];
 9333       EVT VT = RetTys[I];
 9588     SmallVector<EVT, 1> ValueVTs;
 9613     SmallVector<EVT, 4> ValueVTs;
 9624       EVT VT = ValueVTs[Value];
 9754     SmallVector<EVT, 1> ValueVTs;
 9782     SmallVector<EVT, 4> ValueVTs;
 9813       EVT VT = ValueVTs[Val];
 9984       SmallVector<EVT, 4> ValueVTs;
 9988         EVT VT = ValueVTs[vti];
10075         EVT VT = CondLHS.getValueType();

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

  814   SmallVector<EVT, 4> ValueVTs;

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  767     EVT SrcVT = Src.getValueType();
 2200   EVT VT = Root->getValueType(Root->getNumValues()-1);
 2224   const EVT VTs[] = {MVT::Other, MVT::Glue};
 3377       SmallVector<EVT, 4> VTs;

lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp

   98       EVT VT = Op.getValueType();

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

   93 StatepointLoweringState::allocateStackSlot(EVT ValueType,
 1035   auto LoadVT = DAG.getTargetLoweringInfo().getValueType(DAG.getDataLayout(),

lib/CodeGen/SelectionDAG/StatepointLowering.h

   92   SDValue allocateStackSlot(EVT ValueType, SelectionDAGBuilder &Builder);

lib/CodeGen/SelectionDAG/TargetLowering.cpp

  122 TargetLowering::makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
  172 TargetLowering::findOptimalMemOpLowering(std::vector<EVT> &MemOps,
  191   EVT VT = getOptimalMemOpType(Size, DstAlign, SrcAlign,
  222       EVT NewVT = VT;
  275 void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT,
  379   EVT RetVT = getCmpLibcallReturnType();
  382   EVT OpsVT[2] = { OldLHS.getValueType(),
  494       EVT VT = Op.getValueType();
  538     EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), SmallVTBits);
  538     EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), SmallVTBits);
  574   EVT VT = Op.getValueType();
  604     EVT SrcVT = Src.getValueType();
  605     EVT DstVT = Op.getValueType();
  698     EVT ExVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
  707     EVT VecVT = Vec.getValueType();
  786   EVT VT = Op.getValueType();
  840     EVT VecVT = Vec.getValueType();
  877     EVT SubVT = Sub.getValueType();
  931     EVT SubVT = Op.getOperand(0).getValueType();
 1325         EVT InnerVT = InnerOp.getValueType();
 1329           EVT ShTy = getShiftAmountTy(InnerVT, DL);
 1383       EVT ShiftVT = Op1.getValueType();
 1543     EVT ExVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 1555         EVT ShiftAmtTy = VT;
 1599     EVT HalfVT = Op.getOperand(0).getValueType();
 1623     EVT SrcVT = Src.getValueType();
 1656     EVT SrcVT = Src.getValueType();
 1704     EVT SrcVT = Src.getValueType();
 1789     EVT ZVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 1828     EVT SrcVT = Src.getValueType();
 1841         EVT Ty = OpVTLegal ? VT : MVT::i32;
 2040   EVT VT = BO.getValueType();
 2044   EVT EltVT = VT.getVectorElementType();
 2087   EVT VT = Op.getValueType();
 2130     EVT SrcVT = Src.getValueType();
 2244     EVT SubVT = Op.getOperand(0).getValueType();
 2264     EVT SubVT = Sub.getValueType();
 2665 TargetLowering::buildLegalVectorShuffle(EVT VT, const SDLoc &DL, SDValue N0,
 2759 bool TargetLowering::isExtendedTrueVal(const ConstantSDNode *N, EVT VT,
 2779 SDValue TargetLowering::foldSetCCWithAnd(EVT VT, SDValue N0, SDValue N1,
 2788   EVT OpVT = N0.getValueType();
 2848     EVT SCCVT, SDValue N0, SDValue N1, ISD::CondCode Cond, DAGCombinerInfo &DCI,
 2865   EVT XVT = X.getValueType();
 2936     EVT SCCVT, SDValue N0, SDValue N1C, ISD::CondCode Cond,
 2995   EVT VT = X.getValueType();
 3008 SDValue TargetLowering::foldSetCCWithBinOp(EVT VT, SDValue N0, SDValue N1,
 3020   EVT OpVT = N0.getValueType();
 3039   EVT ShiftVT = getShiftAmountTy(OpVT, DAG.getDataLayout(),
 3050 SDValue TargetLowering::SimplifySetCC(EVT VT, SDValue N0, SDValue N1,
 3055   EVT OpVT = N0.getValueType();
 3115       EVT CTVT = CTPOP.getValueType();
 3189         EVT MinVT = EVT::getIntegerVT(*DAG.getContext(), MinBits);
 3189         EVT MinVT = EVT::getIntegerVT(*DAG.getContext(), MinBits);
 3272         EVT newVT = EVT::getIntegerVT(*DAG.getContext(), bestWidth);
 3272         EVT newVT = EVT::getIntegerVT(*DAG.getContext(), bestWidth);
 3275           EVT PtrType = Lod->getOperand(1).getValueType();
 3331         EVT newVT = N0.getOperand(0).getValueType();
 3335           EVT NewSetCCVT =
 3350       EVT ExtSrcTy = cast<VTSDNode>(N0.getOperand(1))->getVT();
 3352       EVT ExtDstTy = N0.getValueType();
 3361       EVT Op0Ty = N0.getOperand(0).getValueType();
 3611     EVT ShValTy = N0.getValueType();
 3619         EVT ShiftTy = getShiftAmountTy(ShValTy, DL, !DCI.isBeforeLegalize());
 3653             EVT ShiftTy = getShiftAmountTy(N0.getValueType(), DL,
 3655             EVT CmpTy = N0.getValueType();
 3684           EVT ShiftTy = getShiftAmountTy(N0.getValueType(), DL,
 3686           EVT CmpTy = N0.getValueType();
 4020 const char *TargetLowering::LowerXConstraint(EVT ConstraintVT) const {
 4567   EVT VT = N->getValueType(0);
 4568   EVT SVT = VT.getScalarType();
 4569   EVT ShVT = TLI.getShiftAmountTy(VT, DAG.getDataLayout());
 4570   EVT ShSVT = ShVT.getScalarType();
 4639   EVT VT = N->getValueType(0);
 4640   EVT SVT = VT.getScalarType();
 4641   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 4642   EVT ShSVT = ShVT.getScalarType();
 4748   EVT VT = N->getValueType(0);
 4749   EVT SVT = VT.getScalarType();
 4750   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 4751   EVT ShSVT = ShVT.getScalarType();
 4906 SDValue TargetLowering::buildUREMEqFold(EVT SETCCVT, SDValue REMNode,
 4923 TargetLowering::prepareUREMEqFold(EVT SETCCVT, SDValue REMNode,
 4937   EVT VT = REMNode.getValueType();
 4938   EVT SVT = VT.getScalarType();
 4939   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 4940   EVT ShSVT = ShVT.getScalarType();
 5073 SDValue TargetLowering::buildSREMEqFold(EVT SETCCVT, SDValue REMNode,
 5091 TargetLowering::prepareSREMEqFold(EVT SETCCVT, SDValue REMNode,
 5110   EVT VT = REMNode.getValueType();
 5111   EVT SVT = VT.getScalarType();
 5112   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 5113   EVT ShSVT = ShVT.getScalarType();
 5350   EVT VT = Op.getValueType();
 5586 bool TargetLowering::expandMUL_LOHI(unsigned Opcode, EVT VT, SDLoc dl,
 5589                                     EVT HiLoVT, SelectionDAG &DAG,
 5671   EVT ShiftAmountTy = getShiftAmountTy(VT, DAG.getDataLayout());
 5726   EVT BoolType = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 5769 bool TargetLowering::expandMUL(SDNode *N, SDValue &Lo, SDValue &Hi, EVT HiLoVT,
 5787   EVT VT = Node->getValueType(0);
 5805   EVT ShVT = Z.getValueType();
 5824   EVT CCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), ShVT);
 5836   EVT VT = Node->getValueType(0);
 5843   EVT ShVT = Op1.getValueType();
 5882   EVT SrcVT = Src.getValueType();
 5883   EVT DstVT = Node->getValueType(0);
 5901   EVT IntVT = SrcVT.changeTypeToInteger();
 5902   EVT IntShVT = getShiftAmountTy(IntVT, DAG.getDataLayout());
 5956   EVT SrcVT = Src.getValueType();
 5957   EVT DstVT = Node->getValueType(0);
 5958   EVT SetCCVT =
 6037   EVT SrcVT = Src.getValueType();
 6038   EVT DstVT = Node->getValueType(0);
 6044   EVT ShiftVT = getShiftAmountTy(SrcVT, DAG.getDataLayout());
 6074     EVT SetCCVT =
 6124   EVT VT = Node->getValueType(0);
 6162   EVT VT = Node->getValueType(0);
 6163   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 6222   EVT VT = Node->getValueType(0);
 6223   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 6236     EVT SetCCVT =
 6275   EVT VT = Node->getValueType(0);
 6288     EVT SetCCVT =
 6330   EVT VT = N->getValueType(0);
 6331   EVT ShVT = getShiftAmountTy(VT, DAG.getDataLayout());
 6353   EVT SrcVT = LD->getMemoryVT();
 6358   EVT SrcEltVT = SrcVT.getScalarType();
 6359   EVT DstEltVT = LD->getValueType(0).getScalarType();
 6393   EVT StVT = ST->getMemoryVT();
 6396   EVT RegVT = Value.getValueType();
 6397   EVT RegSclVT = RegVT.getScalarType();
 6400   EVT MemSclVT = StVT.getScalarType();
 6402   EVT IdxVT = getVectorIdxTy(DAG.getDataLayout());
 6413     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumBits);
 6413     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumBits);
 6466   EVT VT = LD->getValueType(0);
 6467   EVT LoadedVT = LD->getMemoryVT();
 6472     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
 6472     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), LoadedVT.getSizeInBits());
 6509     EVT PtrVT = Ptr.getValueType();
 6510     EVT StackPtrVT = StackPtr.getValueType();
 6534     EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
 6534     EVT MemVT = EVT::getIntegerVT(*DAG.getContext(),
 6566   EVT NewLoadedVT;
 6567   NewLoadedVT = EVT::getIntegerVT(*DAG.getContext(), NumBits/2);
 6622   EVT VT = Val.getValueType();
 6625   EVT StoreMemVT = ST->getMemoryVT();
 6629     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 6629     EVT intVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 6649         EVT::getIntegerVT(*DAG.getContext(), StoreMemVT.getSizeInBits()));
 6650     EVT PtrVT = Ptr.getValueType();
 6664     EVT StackPtrVT = StackPtr.getValueType();
 6691     EVT LoadMemVT =
 6692         EVT::getIntegerVT(*DAG.getContext(), 8 * (StoredBytes - Offset));
 6712   EVT NewStoredVT = StoreMemVT.getHalfSizedIntegerVT(*DAG.getContext());
 6743                                        const SDLoc &DL, EVT DataVT,
 6747   EVT AddrVT = Addr.getValueType();
 6748   EVT MaskVT = Mask.getValueType();
 6753     EVT MaskIntVT = EVT::getIntegerVT(*DAG.getContext(), MaskVT.getSizeInBits());
 6753     EVT MaskIntVT = EVT::getIntegerVT(*DAG.getContext(), MaskVT.getSizeInBits());
 6775                                        EVT VecVT,
 6780   EVT IdxVT = Idx.getValueType();
 6794                                                 SDValue VecPtr, EVT VecVT,
 6800   EVT EltVT = VecVT.getVectorElementType();
 6809   EVT IdxVT = Index.getValueType();
 6824   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 6866       EVT VT = Op.getOperand(0).getValueType();
 6886   EVT VT = LHS.getValueType();
 6924   EVT BoolVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 6973   EVT VT = LHS.getValueType();
 6979   EVT BoolVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 7045   EVT ShiftTy = getShiftAmountTy(VT, DAG.getDataLayout());
 7123   EVT ResultType = Node->getValueType(1);
 7124   EVT SetCCType = getSetCCResultType(
 7141   EVT ResultType = Node->getValueType(1);
 7142   EVT OType = getSetCCResultType(
 7174   EVT VT = Node->getValueType(0);
 7175   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 7187       EVT ShiftAmtTy = getShiftAmountTy(VT, DAG.getDataLayout());
 7198   EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getScalarSizeInBits() * 2);
 7198   EVT WideVT = EVT::getIntegerVT(*DAG.getContext(), VT.getScalarSizeInBits() * 2);
 7200     WideVT = EVT::getVectorVT(*DAG.getContext(), WideVT,
 7306   EVT RType = Node->getValueType(1);
 7341   EVT VT = Op.getValueType();
 7346       EVT HalfVT = VT.getHalfNumVectorElementsVT(*DAG.getContext());
 7357   EVT EltVT = VT.getVectorElementType();

lib/CodeGen/SwitchLoweringUtils.cpp

  280   EVT PTy = TLI->getPointerTy(*DL);

lib/CodeGen/TargetLoweringBase.cpp

  213 RTLIB::Libcall RTLIB::getFPEXT(EVT OpVT, EVT RetVT) {
  213 RTLIB::Libcall RTLIB::getFPEXT(EVT OpVT, EVT RetVT) {
  239 RTLIB::Libcall RTLIB::getFPROUND(EVT OpVT, EVT RetVT) {
  239 RTLIB::Libcall RTLIB::getFPROUND(EVT OpVT, EVT RetVT) {
  277 RTLIB::Libcall RTLIB::getFPTOSINT(EVT OpVT, EVT RetVT) {
  277 RTLIB::Libcall RTLIB::getFPTOSINT(EVT OpVT, EVT RetVT) {
  319 RTLIB::Libcall RTLIB::getFPTOUINT(EVT OpVT, EVT RetVT) {
  319 RTLIB::Libcall RTLIB::getFPTOUINT(EVT OpVT, EVT RetVT) {
  361 RTLIB::Libcall RTLIB::getSINTTOFP(EVT OpVT, EVT RetVT) {
  361 RTLIB::Libcall RTLIB::getSINTTOFP(EVT OpVT, EVT RetVT) {
  401 RTLIB::Libcall RTLIB::getUINTTOFP(EVT OpVT, EVT RetVT) {
  401 RTLIB::Libcall RTLIB::getUINTTOFP(EVT OpVT, EVT RetVT) {
  793                                                EVT) const {
  797 EVT TargetLoweringBase::getShiftAmountTy(EVT LHSTy, const DataLayout &DL,
  797 EVT TargetLoweringBase::getShiftAmountTy(EVT LHSTy, const DataLayout &DL,
  806 bool TargetLoweringBase::canOpTrap(unsigned Op, EVT VT) const {
  826 TargetLoweringBase::getTypeConversion(LLVMContext &Context, EVT VT) const {
  841                           EVT::getVectorVT(Context, SVT.getVectorElementType(),
  854       EVT NVT = VT.getRoundIntegerType(Context);
  865                         EVT::getIntegerVT(Context, VT.getSizeInBits() / 2));
  870   EVT EltVT = VT.getVectorElementType();
  884       EVT NVT = EVT::getVectorVT(Context, EltVT, NumElts);
  884       EVT NVT = EVT::getVectorVT(Context, EltVT, NumElts);
  895                           EVT::getVectorVT(Context, EltVT, NumElts / 2));
  901     EVT OldEltVT = EltVT;
  905       EltVT = EVT::getIntegerVT(Context, 1 + EltVT.getSizeInBits())
  920                             EVT::getVectorVT(Context, EltVT, NumElts));
  950     EVT NVT = VT.getPow2VectorType(Context);
  955   EVT NVT = EVT::getVectorVT(Context, EltVT, VT.getVectorNumElements() / 2);
  955   EVT NVT = EVT::getVectorVT(Context, EltVT, VT.getVectorNumElements() / 2);
 1376 EVT TargetLoweringBase::getSetCCResultType(const DataLayout &DL, LLVMContext &,
 1377                                            EVT VT) const {
 1394 unsigned TargetLoweringBase::getVectorTypeBreakdown(LLVMContext &Context, EVT VT,
 1395                                                 EVT &IntermediateVT,
 1407     EVT RegisterEVT = getTypeToTransformTo(Context, VT);
 1417   EVT EltTy = VT.getVectorElementType();
 1431                                    EVT::getVectorVT(Context, EltTy, NumElts))) {
 1438   EVT NewVT = EVT::getVectorVT(Context, EltTy, NumElts);
 1438   EVT NewVT = EVT::getVectorVT(Context, EltTy, NumElts);
 1467   SmallVector<EVT, 4> ValueVTs;
 1473     EVT VT = ValueVTs[j];
 1521     LLVMContext &Context, const DataLayout &DL, EVT VT, unsigned AddrSpace,
 1541     LLVMContext &Context, const DataLayout &DL, EVT VT,
 1549     LLVMContext &Context, const DataLayout &DL, EVT VT, unsigned AddrSpace,
 1556                                             const DataLayout &DL, EVT VT,
 1653   EVT MTy = getValueType(DL, Ty);
 1832 static std::string getReciprocalOpName(bool IsSqrt, EVT VT) {
 1875 static int getOpEnabled(bool IsSqrt, EVT VT, StringRef Override) {
 1935 static int getOpRefinementSteps(bool IsSqrt, EVT VT, StringRef Override) {
 1981 int TargetLoweringBase::getRecipEstimateSqrtEnabled(EVT VT,
 1986 int TargetLoweringBase::getRecipEstimateDivEnabled(EVT VT,
 1991 int TargetLoweringBase::getSqrtRefinementSteps(EVT VT,
 1996 int TargetLoweringBase::getDivRefinementSteps(EVT VT,

lib/CodeGen/ValueTypes.cpp

   16 EVT EVT::changeExtendedTypeToInteger() const {
   21 EVT EVT::changeExtendedVectorElementTypeToInteger() const {
   23   EVT IntTy = getIntegerVT(Context, getScalarSizeInBits());
   27 EVT EVT::getExtendedIntegerVT(LLVMContext &Context, unsigned BitWidth) {
   28   EVT VT;
   34 EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT,
   34 EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT,
   36   EVT ResultVT;
   94 EVT EVT::getExtendedVectorElementType() const {
   96   return EVT::getEVT(cast<VectorType>(LLVMTy)->getElementType());
  477 EVT EVT::getEVT(Type *Ty, bool HandleUnknown){

lib/Target/AArch64/AArch64CallLowering.cpp

  228   SmallVector<EVT, 4> SplitVTs;
  275     SmallVector<EVT, 4> SplitEVTs;

lib/Target/AArch64/AArch64FastISel.cpp

  466   EVT DestEVT = TLI.getValueType(DL, GV->getType(), true);
  523   EVT CEVT = TLI.getValueType(DL, C->getType(), true);
  978   EVT evt = TLI.getValueType(DL, Ty, true);
 1487   EVT EVT = TLI.getValueType(DL, Ty, true);
 2881   EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType(), true);
 2921   EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType(), true);
 2982     EVT ArgVT = TLI.getValueType(DL, ArgTy);
 3897     EVT RVEVT = TLI.getValueType(DL, RV->getType());
 3945   EVT SrcEVT = TLI.getValueType(DL, SrcTy, true);
 3946   EVT DestEVT = TLI.getValueType(DL, DestTy, true);
 4633   EVT DestEVT = TLI.getValueType(DL, I->getType(), true);
 5000   EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false);
 5000   EVT IdxVT = EVT::getEVT(Idx->getType(), /*HandleUnknown=*/false);

lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

  454     EVT SrcVT;
  471     EVT SrcVT = N.getOperand(0).getValueType();
 1131   EVT VT = N->getValueType(0);
 1153   EVT VT = LD->getMemoryVT();
 1154   EVT DstVT = N->getValueType(0);
 1246   EVT VT = N->getValueType(0);
 1252   const EVT ResTys[] = {MVT::Untyped, MVT::Other};
 1272   EVT VT = N->getValueType(0);
 1279   const EVT ResTys[] = {MVT::i64, // Type of the write back register
 1304   EVT VT = N->getOperand(2)->getValueType(0);
 1324   EVT VT = N->getOperand(2)->getValueType(0);
 1325   const EVT ResTys[] = {MVT::i64,    // Type of the write back register
 1352     EVT VT = V64Reg.getValueType();
 1368   EVT VT = V128Reg.getValueType();
 1380   EVT VT = N->getValueType(0);
 1392   const EVT ResTys[] = {MVT::Untyped, MVT::Other};
 1402   EVT WideVT = RegSeq.getOperand(1)->getValueType(0);
 1419   EVT VT = N->getValueType(0);
 1431   const EVT ResTys[] = {MVT::i64, // Type of the write back register
 1454     EVT WideVT = RegSeq.getOperand(1)->getValueType(0);
 1474   EVT VT = N->getOperand(2)->getValueType(0);
 1503   EVT VT = N->getOperand(2)->getValueType(0);
 1515   const EVT ResTys[] = {MVT::i64, // Type of the write back register
 1542   EVT VT = N->getValueType(0);
 1631   EVT VT = N->getValueType(0);
 1711   EVT VT = N->getValueType(0);
 1775   EVT VT = N->getValueType(0);
 1776   EVT NarrowVT = N->getOperand(0)->getValueType(0);
 1843   EVT VT = N->getValueType(0);
 1870                               unsigned NumberOfIgnoredHighBits, EVT VT) {
 2107   EVT VT = Op.getValueType();
 2137   EVT VT = Op.getValueType();
 2184 static bool isShiftedMask(uint64_t Mask, EVT VT) {
 2196   EVT VT = N->getValueType(0);
 2285   EVT VT = N->getValueType(0);
 2355     EVT VT = OrOpd1Val.getValueType();
 2467   EVT VT = N->getValueType(0);
 2493   EVT VT = N->getValueType(0);
 2549       EVT SubVT = ShiftAmt->getValueType(0);
 2784   EVT MemTy = cast<MemSDNode>(N)->getMemoryVT();
 2878   EVT VT = Node->getValueType(0);

lib/Target/AArch64/AArch64ISelLowering.cpp

  906 EVT AArch64TargetLowering::getSetCCResultType(const DataLayout &, LLVMContext &,
  907                                               EVT VT) const {
  987   EVT VT = Op.getValueType();
 1017   EVT VT = Op.getValueType();
 1082       EVT VT = cast<MemIntrinsicSDNode>(Op)->getMemoryVT();
 1121                                                   EVT) const {
 1126     EVT VT, unsigned AddrSpace, unsigned Align, MachineMemOperand::Flags Flags,
 1604   EVT VT = LHS.getValueType();
 1962       EVT VT = Op.getValueType();
 1974     EVT VT = RHS.getValueType();
 2313   EVT VT = Op.getValueType();
 2439   EVT InVT = Op.getOperand(0).getValueType();
 2440   EVT VT = Op.getValueType();
 2508   EVT VT = Op.getValueType();
 2511   EVT InVT = In.getValueType();
 2524     EVT CastVT = VT.changeVectorElementTypeToInteger();
 2571   EVT ArgVT = Arg.getValueType();
 2614 static EVT getExtensionTo64Bits(const EVT &OrigVT) {
 2614 static EVT getExtensionTo64Bits(const EVT &OrigVT) {
 2632                                                  const EVT &OrigTy,
 2633                                                  const EVT &ExtTy,
 2643   EVT NewVT = getExtensionTo64Bits(OrigTy);
 2650   EVT VT = N->getValueType(0);
 2682   EVT VT = N->getValueType(0);
 2753   EVT VT = Op.getValueType();
 2811   EVT Op1VT = Op1.getValueType();
 2826     EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2830     EVT Ty = Op.getValueType();
 2898                                         EVT VT, EVT MemVT,
 2898                                         EVT VT, EVT MemVT,
 2939   EVT VT = Value.getValueType();
 2940   EVT MemVT = StoreNode->getMemoryVT();
 3164       EVT ActualVT = getValueType(DAG.getDataLayout(), CurOrigArg->getType(),
 3187       EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3204       EVT RegVT = VA.getLocVT();
 3784       EVT ActualVT = getValueType(DAG.getDataLayout(),
 4278 SDValue AArch64TargetLowering::getTargetNode(GlobalAddressSDNode *N, EVT Ty,
 4285 SDValue AArch64TargetLowering::getTargetNode(JumpTableSDNode *N, EVT Ty,
 4291 SDValue AArch64TargetLowering::getTargetNode(ConstantPoolSDNode *N, EVT Ty,
 4298 SDValue AArch64TargetLowering::getTargetNode(BlockAddressSDNode* N, EVT Ty,
 4310   EVT Ty = getPointerTy(DAG.getDataLayout());
 4323   EVT Ty = getPointerTy(DAG.getDataLayout());
 4339   EVT Ty = getPointerTy(DAG.getDataLayout());
 4353   EVT Ty = getPointerTy(DAG.getDataLayout());
 4382   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 4489   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 4524   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 4607   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 4813   EVT VT = Op.getValueType();
 4818   EVT SrcVT = In2.getValueType();
 4825   EVT VecVT;
 4903   EVT VT = Op.getValueType();
 4924   EVT VT8Bit = VT.is64BitVector() ? MVT::v8i8 : MVT::v16i8;
 4954   EVT VT = Op.getValueType();
 5155     EVT VT = TVal.getValueType();
 5163   EVT VT = TVal.getValueType();
 5445   EVT VT = Op.getValueType();
 5511   EVT VT = Op.getValueType();
 5531   EVT VT = getPointerTy(DAG.getDataLayout());
 5543 getRegisterByName(const char* RegName, EVT VT, const MachineFunction &MF) const {
 5561   EVT VT = Op.getValueType();
 5577   EVT VT = Op.getValueType();
 5598   EVT VT = Op.getValueType();
 5655   EVT VT = Op.getValueType();
 5708 bool AArch64TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
 5752   EVT VT = Operand.getValueType();
 5781       EVT VT = Operand.getValueType();
 5795         EVT CCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
 5820       EVT VT = Operand.getValueType();
 5867 const char *AArch64TargetLowering::LowerXConstraint(EVT ConstraintVT) const {
 6222   EVT VT = V64Reg.getValueType();
 6235   EVT EltType = V.getValueType().getVectorElementType();
 6242   EVT VT = V128Reg.getValueType();
 6258   EVT VT = Op.getValueType();
 6321   EVT SmallestEltTy = VT.getVectorElementType();
 6323     EVT SrcEltTy = Source.Vec.getValueType().getVectorElementType();
 6331   EVT ShuffleVT = EVT::getVectorVT(*DAG.getContext(), SmallestEltTy, NumElts);
 6331   EVT ShuffleVT = EVT::getVectorVT(*DAG.getContext(), SmallestEltTy, NumElts);
 6337     EVT SrcVT = Src.ShuffleVec.getValueType();
 6344     EVT EltVT = SrcVT.getVectorElementType();
 6346     EVT DestVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumSrcElts);
 6346     EVT DestVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumSrcElts);
 6398     EVT SrcEltTy = Src.ShuffleVec.getValueType().getVectorElementType();
 6426     EVT OrigEltTy = Entry.getOperand(0).getValueType().getVectorElementType();
 6463 static bool isSingletonEXTMask(ArrayRef<int> M, EVT VT, unsigned &Imm) {
 6494 static bool isEXTMask(ArrayRef<int> M, EVT VT, bool &ReverseEXT,
 6535 static bool isREVMask(ArrayRef<int> M, EVT VT, unsigned BlockSize) {
 6562 static bool isZIPMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6578 static bool isUZPMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6591 static bool isTRNMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6607 static bool isZIP_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6626 static bool isUZP_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6645 static bool isTRN_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6697 static bool isConcatMask(ArrayRef<int> Mask, EVT VT, bool SplitLHS) {
 6719   EVT VT = Op.getValueType();
 6733   EVT CastVT = VT.getHalfNumVectorElementsVT(*DAG.getContext());
 6782   EVT VT = OpLHS.getValueType();
 6803     EVT EltTy = VT.getVectorElementType();
 6856   EVT EltVT = Op.getValueType().getVectorElementType();
 6911 static unsigned getDUPLANEOp(EVT EltType) {
 6927   EVT VT = Op.getValueType();
 7040     EVT ScalarVT = VT.getVectorElementType();
 7079   EVT VT = Op.getValueType();
 7080   EVT ElemVT = VT.getScalarType();
 7113   EVT VT = BVN->getValueType(0);
 7138     EVT VT = Op.getValueType();
 7160     EVT VT = Op.getValueType();
 7208     EVT VT = Op.getValueType();
 7247     EVT VT = Op.getValueType();
 7278     EVT VT = Op.getValueType();
 7299     EVT VT = Op.getValueType();
 7336   EVT VT = Bvec->getValueType(0);
 7364   EVT VT = N->getValueType(0);
 7432   EVT VT = Op.getValueType();
 7473   EVT VT = Op.getValueType();
 7474   EVT EltTy= VT.getVectorElementType();
 7501   EVT VT = Op.getValueType();
 7543   EVT VT = Op.getValueType();
 7717       EVT EltTy = VT.getVectorElementType();
 7726       EVT VecVT = EVT::getVectorVT(*DAG.getContext(), NewType, NumElts);
 7726       EVT VecVT = EVT::getVectorVT(*DAG.getContext(), NewType, NumElts);
 7829   EVT VT = Op.getOperand(0).getValueType();
 7849   EVT WideTy = WideVec.getValueType();
 7863   EVT VT = Op.getOperand(0).getValueType();
 7883   EVT WideTy = WideVec.getValueType();
 7885   EVT ExtrTy = WideTy.getVectorElementType();
 7896   EVT VT = Op.getOperand(0).getValueType();
 7921 bool AArch64TargetLowering::isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const {
 7982 static bool isVShiftLImm(SDValue Op, EVT VT, bool isLong, int64_t &Cnt) {
 7993 static bool isVShiftRImm(SDValue Op, EVT VT, bool isNarrow, int64_t &Cnt) {
 8003   EVT VT = Op.getValueType();
 8051                                     AArch64CC::CondCode CC, bool NoNans, EVT VT,
 8053   EVT SrcVT = LHS.getValueType();
 8150   EVT CmpVT = LHS.getValueType().changeVectorElementTypeToInteger();
 8287   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 8323   EVT VT = Node->getValueType(0);
 8381     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
 8407     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
 8464                                                   EVT NewVT) const {
 8501 bool AArch64TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 8501 bool AArch64TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 8528   EVT VT = getValueType(DL, User->getOperand(0)->getType());
 8545 bool AArch64TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
 8545 bool AArch64TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
 8553 bool AArch64TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
 8554   EVT VT1 = Val.getValueType();
 8726 bool AArch64TargetLowering::hasPairedLoad(EVT LoadedType,
 9027 EVT AArch64TargetLowering::getOptimalMemOpType(
 9188 bool AArch64TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
 9220   EVT VT = N->getValueType(0);
 9257 bool AArch64TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 9257 bool AArch64TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 9271   EVT VT = N->getValueType(0);
 9285   EVT ShiftEltTy = Shift.getValueType().getVectorElementType();
 9294   EVT VT = N->getValueType(0);
 9341   EVT VT = N->getValueType(0);
 9456   EVT VT = N->getValueType(0);
 9488   EVT VT = N->getValueType(0);
 9506     EVT IntVT = BV->getValueType(0);
 9528   EVT VT = N->getValueType(0);
 9732   EVT VT = N->getValueType(0);
 9770   EVT VT = N->getValueType(0);
 9819   EVT VT = N->getValueType(0);
 9837   EVT VT = N->getValueType(0);
 9876   EVT VT = N->getValueType(0);
 9917   EVT VT = N->getValueType(0);
 9946   EVT SVT = Source->getValueType(0);
 9973   EVT VT = N->getValueType(0);
 9992     EVT N00VT = N00.getValueType();
10075     EVT ResTy = N->getValueType(0);
10076     EVT VecResTy;
10260   EVT CmpVT = InfoAndKind.IsAArch64
10280   EVT VT = Op->getValueType(0);
10579   EVT ResVT = N->getValueType(0);
10586   EVT SrcVT = Src->getValueType(0);
10603   EVT LoVT, HiVT;
10607   LoVT = HiVT = EVT::getVectorVT(*DAG.getContext(),
10610   EVT InNVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getVectorElementType(),
10610   EVT InNVT = EVT::getVectorVT(*DAG.getContext(), SrcVT.getVectorElementType(),
10681   EVT VT = StVal.getValueType();
10724   EVT ZeroVT;
10744   EVT VT = StVal.getValueType();
10804   EVT VT = StVal.getValueType();
10848   EVT HalfVT = VT.getHalfNumVectorElementsVT(*DAG.getContext());
10874   EVT VT = N->getValueType(0);
10892   EVT MemVT = LoadSDN->getMemoryVT();
10948     EVT Tys[3] = { VT, MVT::i64, MVT::Other };
11084     EVT VecTy;
11111     EVT Tys[6];
11567   EVT CCVT = N0.getValueType();
11573   EVT ResVT = N->getValueType(0);
11574   EVT CmpVT = N0.getOperand(0).getValueType();
11598   EVT ResVT = N->getValueType(0);
11612   EVT SrcVT = N0.getOperand(0).getValueType();
11623   SrcVT = EVT::getVectorVT(*DAG.getContext(), SrcVT, NumMaskElts);
11624   EVT CCVT = SrcVT.changeVectorElementTypeToInteger();
11884   EVT VT;
11905   EVT VT;
11948   EVT LoVT, HiVT;
12256                                                             EVT) const {
12415 bool AArch64TargetLowering::isIntDivCheap(EVT VT, AttributeList Attr) const {
12428 bool AArch64TargetLowering::preferIncOfAddToSubOfNot(EVT VT) const {
12433 bool AArch64TargetLowering::enableAggressiveFMAFusion(EVT VT) const {

lib/Target/AArch64/AArch64ISelLowering.h

  280   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
  285       EVT VT, unsigned AddrSpace = 0, unsigned Align = 1,
  313   bool isFPImmLegal(const APFloat &Imm, EVT VT,
  318   bool isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const override;
  321   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  322                          EVT VT) const override;
  344                              EVT NewVT) const override;
  347   bool isTruncateFree(EVT VT1, EVT VT2) const override;
  347   bool isTruncateFree(EVT VT1, EVT VT2) const override;
  352   bool isZExtFree(EVT VT1, EVT VT2) const override;
  352   bool isZExtFree(EVT VT1, EVT VT2) const override;
  353   bool isZExtFree(SDValue Val, EVT VT2) const override;
  358   bool hasPairedLoad(EVT LoadedType, unsigned &RequiredAligment) const override;
  374   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
  399   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
  414   bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
  414   bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
  465   bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
  467   bool canMergeStoresTo(unsigned AddressSpace, EVT MemVT,
  496     EVT VT = Y.getValueType();
  511   bool shouldTransformSignedTruncationCheck(EVT XVT,
  528   bool preferIncOfAddToSubOfNot(EVT VT) const override;
  530   bool hasBitPreservingFPLogic(EVT VT) const override {
  549   bool enableAggressiveFMAFusion(EVT VT) const override;
  630   SDValue getTargetNode(GlobalAddressSDNode *N, EVT Ty, SelectionDAG &DAG,
  632   SDValue getTargetNode(JumpTableSDNode *N, EVT Ty, SelectionDAG &DAG,
  634   SDValue getTargetNode(ConstantPoolSDNode *N, EVT Ty, SelectionDAG &DAG,
  636   SDValue getTargetNode(BlockAddressSDNode *N, EVT Ty, SelectionDAG &DAG,
  716   Register getRegisterByName(const char* RegName, EVT VT,
  729   const char *LowerXConstraint(EVT ConstraintVT) const override;
  760   bool shouldNormalizeToSelectSequence(LLVMContext &, EVT) const override;

lib/Target/AArch64/AArch64SelectionDAGInfo.cpp

   34     EVT IntPtr = TLI.getPointerTy(DAG.getDataLayout());
  139   const EVT ResTys[] = {MVT::i64, MVT::i64, MVT::Other};

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

  287   EVT SrcTy = TLI->getValueType(DL, Src);
  288   EVT DstTy = TLI->getValueType(DL, Dst);
  419   auto DstVT = TLI->getValueType(DL, Dst);
  420   auto SrcVT = TLI->getValueType(DL, Src);
  525       auto VT = TLI->getValueType(DL, Ty);
  609     EVT SelCondTy = TLI->getValueType(DL, CondTy);
  610     EVT SelValTy = TLI->getValueType(DL, ValTy);

lib/Target/AMDGPU/AMDGPUCallLowering.cpp

  163   SmallVector<EVT, 4> SplitVTs;
  169   for (EVT VT : SplitVTs) {
  189     EVT PartVT = TLI.getRegisterTypeForCallingConv(Ctx, CallConv, VT);

lib/Target/AMDGPU/AMDGPUISelDAGToDAG.cpp

  173   MachineSDNode *buildSMovImm64(SDLoc &DL, uint64_t Val, EVT VT) const;
  625                                                   EVT VT) const {
  664   EVT VT = N->getValueType(0);
  666   EVT EltVT = VT.getVectorElementType();
  772     EVT VT = N->getValueType(0);
 1099   EVT VT = N->getValueType(0);
 1115   EVT VT = N->getValueType(0);
 2779     EVT VT = N->getValueType(0);

lib/Target/AMDGPU/AMDGPUISelLowering.cpp

   42 EVT AMDGPUTargetLowering::getEquivalentMemType(LLVMContext &Ctx, EVT VT) {
   42 EVT AMDGPUTargetLowering::getEquivalentMemType(LLVMContext &Ctx, EVT VT) {
   45     return EVT::getIntegerVT(Ctx, StoreSize);
   48   return EVT::getVectorVT(Ctx, MVT::i32, StoreSize / 32);
   52   EVT VT = Op.getValueType();
   58   EVT VT = Op.getValueType();
  625 bool AMDGPUTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
  627   EVT ScalarVT = VT.getScalarType();
  633 bool AMDGPUTargetLowering::ShouldShrinkFPConstant(EVT VT) const {
  634   EVT ScalarVT = VT.getScalarType();
  640                                                  EVT NewVT) const {
  651   EVT OldVT = N->getValueType(0);
  676 bool AMDGPUTargetLowering::isLoadBitCastBeneficial(EVT LoadTy, EVT CastTy,
  676 bool AMDGPUTargetLowering::isLoadBitCastBeneficial(EVT LoadTy, EVT CastTy,
  743 bool AMDGPUTargetLowering::isFAbsFree(EVT VT) const {
  751 bool AMDGPUTargetLowering::isFNegFree(EVT VT) const {
  758 bool AMDGPUTargetLowering:: storeOfVectorConstantIsCheap(EVT MemVT,
  764 bool AMDGPUTargetLowering::aggressivelyPreferBuildVectorSources(EVT VecVT) const {
  776 bool AMDGPUTargetLowering::isTruncateFree(EVT Source, EVT Dest) const {
  776 bool AMDGPUTargetLowering::isTruncateFree(EVT Source, EVT Dest) const {
  807 bool AMDGPUTargetLowering::isZExtFree(EVT Src, EVT Dest) const {
  807 bool AMDGPUTargetLowering::isZExtFree(EVT Src, EVT Dest) const {
  819 bool AMDGPUTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
  823 bool AMDGPUTargetLowering::isNarrowingProfitable(EVT SrcVT, EVT DestVT) const {
  823 bool AMDGPUTargetLowering::isNarrowingProfitable(EVT SrcVT, EVT DestVT) const {
  940     SmallVector<EVT, 16> ValueVTs;
  948       EVT ArgVT = ValueVTs[Value];
  949       EVT MemVT = ArgVT;
  981           MemVT = EVT::getIntegerVT(State.getContext(), MemoryBits);
  988           EVT ScalarVT = EVT::getIntegerVT(State.getContext(),
  988           EVT ScalarVT = EVT::getIntegerVT(State.getContext(),
  990           MemVT = EVT::getVectorVT(State.getContext(), ScalarVT, NumElements);
 1230   EVT VT = Op.getValueType();
 1251   EVT VT = Op.getValueType();
 1259 SDValue AMDGPUTargetLowering::combineFMinMaxLegacy(const SDLoc &DL, EVT VT,
 1366 std::pair<EVT, EVT>
 1366 std::pair<EVT, EVT>
 1367 AMDGPUTargetLowering::getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const {
 1368   EVT LoVT, HiVT;
 1369   EVT EltVT = VT.getVectorElementType();
 1372   LoVT = EVT::getVectorVT(*DAG.getContext(), EltVT, LoNumElts);
 1375              : EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts - LoNumElts);
 1383                                   const EVT &LoVT, const EVT &HiVT,
 1383                                   const EVT &LoVT, const EVT &HiVT,
 1401   EVT VT = Op.getValueType();
 1410   EVT MemVT = Load->getMemoryVT();
 1415   EVT LoVT, HiVT;
 1416   EVT LoMemVT, HiMemVT;
 1460   EVT VT = Op.getValueType();
 1463   EVT MemVT = Load->getMemoryVT();
 1468   EVT WideVT =
 1469       EVT::getVectorVT(*DAG.getContext(), VT.getVectorElementType(), 4);
 1470   EVT WideMemVT =
 1471       EVT::getVectorVT(*DAG.getContext(), MemVT.getVectorElementType(), 4);
 1486   EVT VT = Val.getValueType();
 1493   EVT MemVT = Store->getMemoryVT();
 1498   EVT LoVT, HiVT;
 1499   EVT LoMemVT, HiMemVT;
 1529   EVT VT = Op.getValueType();
 1602   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 1620       = DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(), DivBits));
 1636   EVT VT = Op.getValueType();
 1640   EVT HalfVT = VT.getHalfSizedIntegerVT(*DAG.getContext());
 1845   EVT VT = Op.getValueType();
 1960   EVT VT = Op.getValueType();
 1976     EVT HalfVT = VT.getHalfSizedIntegerVT(*DAG.getContext());
 2020   EVT VT = Op.getValueType();
 2046   EVT SetCCVT =
 2108   EVT SetCCVT =
 2142   EVT SetCCVT =
 2164   EVT VT = Op.getValueType();
 2180   EVT SetCCVT =
 2200   EVT SetCCVT =
 2248   EVT VT = Op.getValueType();
 2272   EVT SetCCVT =
 2286   EVT VT = Op.getValueType();
 2298   EVT VT = Op.getValueType();
 2343   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(),
 2423   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(),
 2504   EVT DestVT = Op.getValueType();
 2531   EVT DestVT = Op.getValueType();
 2685   EVT SrcVT = Src.getValueType();
 2708   EVT SrcVT = Src.getValueType();
 2727   EVT ExtraVT = cast<VTSDNode>(Op.getOperand(1))->getVT();
 2757   EVT VT = Op.getValueType();
 2823 bool AMDGPUTargetLowering::shouldCombineMemoryType(EVT VT) const {
 2855   EVT VT = LN->getMemoryVT();
 2883   EVT NewVT = getEquivalentMemType(*DAG.getContext(), VT);
 2905   EVT VT = SN->getMemoryVT();
 2934   EVT NewVT = getEquivalentMemType(*DAG.getContext(), VT);
 2962     EVT ExtVT = cast<VTSDNode>(N1)->getVT();
 2966     EVT SrcVT = Src.getValueType();
 3015   EVT VT = N->getValueType(0);
 3053     EVT XVT = X.getValueType();
 3122   EVT VT = N->getValueType(0);
 3169   EVT VT = N->getValueType(0);
 3177       EVT EltVT = Elt0.getValueType();
 3199           EVT SrcEltVT = SrcElt.getValueType();
 3216     EVT SrcVT = Src.getValueType();
 3226         EVT MidVT = VT.isVector() ?
 3227           EVT::getVectorVT(*DAG.getContext(), MVT::i32,
 3230         EVT NewShiftVT = getShiftAmountTy(MidVT, DAG.getDataLayout());
 3276   EVT VT = N->getValueType(0);
 3323   EVT VT = N->getValueType(0);
 3347   EVT VT = N->getValueType(0);
 3402   EVT VT = Op.getValueType();
 3403   EVT LegalVT = getTypeToTransformTo(*DAG.getContext(), VT);
 3467   EVT VT = N1.getValueType();
 3489   EVT VT = N.getValueType();
 3551   EVT VT = N->getValueType(0);
 3635   EVT VT = N->getValueType(0);
 3821     EVT SrcVT = Src.getValueType();
 3846     EVT SrcVT = Src.getValueType();
 3879     EVT DestVT = N->getValueType(0);
 3889         EVT SrcVT = Src.getValueType();
 3893           EVT DestEltVT = DestVT.getVectorElementType();
 4011       EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), WidthVal);
 4011       EVT SmallVT = EVT::getIntegerVT(*DAG.getContext(), WidthVal);
 4088                                                    unsigned Reg, EVT VT,
 4123                                                   EVT VT,
 4154                                              EVT VT, const SDLoc &SL,
 4359   EVT VT = Operand.getValueType();
 4375   EVT VT = Operand.getValueType();

lib/Target/AMDGPU/AMDGPUISelLowering.h

   78   bool shouldCombineMemoryType(EVT VT) const;
  104   static EVT getEquivalentMemType(LLVMContext &Context, EVT VT);
  104   static EVT getEquivalentMemType(LLVMContext &Context, EVT VT);
  118   std::pair<EVT, EVT> getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const;
  118   std::pair<EVT, EVT> getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const;
  118   std::pair<EVT, EVT> getSplitDestVTs(const EVT &VT, SelectionDAG &DAG) const;
  123                                           const EVT &LoVT, const EVT &HighVT,
  123                                           const EVT &LoVT, const EVT &HighVT,
  166   bool isFAbsFree(EVT VT) const override;
  167   bool isFNegFree(EVT VT) const override;
  168   bool isTruncateFree(EVT Src, EVT Dest) const override;
  168   bool isTruncateFree(EVT Src, EVT Dest) const override;
  172   bool isZExtFree(EVT Src, EVT Dest) const override;
  172   bool isZExtFree(EVT Src, EVT Dest) const override;
  173   bool isZExtFree(SDValue Val, EVT VT2) const override;
  175   bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
  175   bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
  180   bool isFPImmLegal(const APFloat &Imm, EVT VT,
  182   bool ShouldShrinkFPConstant(EVT VT) const override;
  185                              EVT ExtVT) const override;
  187   bool isLoadBitCastBeneficial(EVT, EVT, const SelectionDAG &DAG,
  187   bool isLoadBitCastBeneficial(EVT, EVT, const SelectionDAG &DAG,
  190   bool storeOfVectorConstantIsCheap(EVT MemVT,
  193   bool aggressivelyPreferBuildVectorSources(EVT VecVT) const override;
  226   SDValue combineFMinMaxLegacy(const SDLoc &DL, EVT VT, SDValue LHS,
  240   bool mergeStoresAfterLegalization(EVT) const override { return false; }
  279                                unsigned Reg, EVT VT,
  284                                unsigned Reg, EVT VT) const {
  291                                   unsigned Reg, EVT VT) const {
  298                               EVT VT,
  310                          EVT VT, const SDLoc &SL,

lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

  344   EVT OrigTy = TLI->getValueType(DL, Ty);
  463   EVT OrigTy = TLI->getValueType(DL, Ty);
  479   EVT OrigTy = TLI->getValueType(DL, Ty);

lib/Target/AMDGPU/R600ISelLowering.cpp

  529     EVT VT = Op.getValueType();
  695   EVT VecVT = Vector.getValueType();
  696   EVT EltVT = VecVT.getVectorElementType();
  758   EVT VT = Op.getValueType();
  791   EVT VT = Op.getValueType();
  827   EVT VT = Op.getValueType();
  866   EVT VT = Op.getValueType();
  901 SDValue R600TargetLowering::LowerImplicitParameter(SelectionDAG &DAG, EVT VT,
  942   EVT VT = Op.getValueType();
  959   EVT CompareVT = LHS.getValueType();
 1163   EVT MemVT = Store->getMemoryVT();
 1237   EVT VT = Value.getValueType();
 1238   EVT MemVT = StoreNode->getMemoryVT();
 1239   EVT PtrVT = Ptr.getValueType();
 1389   EVT MemVT = Load->getMemoryVT();
 1424   EVT MemEltVT = MemVT.getScalarType();
 1444   EVT MemVT = LoadNode->getMemoryVT();
 1453   EVT VT = Op.getValueType();
 1503     EVT MemVT = LoadNode->getMemoryVT();
 1597     EVT VT = In.VT;
 1598     EVT MemVT = VA.getLocVT();
 1652 EVT R600TargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &,
 1653                                            EVT VT) const {
 1659 bool R600TargetLowering::canMergeStoresTo(unsigned AS, EVT MemVT,
 1669     EVT VT, unsigned AddrSpace, unsigned Align, MachineMemOperand::Flags Flags,
 1693   EVT EltTy = VectorEntry.getValueType().getVectorElementType();
 1742   EVT EltTy = VectorEntry.getValueType().getVectorElementType();
 1804   EVT VT = LoadNode->getValueType(0);
 1829   EVT NewVT = MVT::v4i32;
 1907     EVT VT = InVec.getValueType();
 1936       EVT OpVT = Ops[0].getValueType();

lib/Target/AMDGPU/R600ISelLowering.h

   46   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &,
   47                          EVT VT) const override;
   49   bool canMergeStoresTo(unsigned AS, EVT MemVT,
   53       EVT VT, unsigned AS, unsigned Align,
   63   SDValue LowerImplicitParameter(SelectionDAG &DAG, EVT VT, const SDLoc &DL,

lib/Target/AMDGPU/SIISelLowering.cpp

  765                                            EVT DestVT, EVT SrcVT) const {
  765                                            EVT DestVT, EVT SrcVT) const {
  772 bool SITargetLowering::isShuffleMaskLegal(ArrayRef<int>, EVT) const {
  780                                                     EVT VT) const {
  785     EVT ScalarVT = VT.getScalarType();
  803                                                          EVT VT) const {
  809     EVT ScalarVT = VT.getScalarType();
  828   EVT VT, EVT &IntermediateVT,
  828   EVT VT, EVT &IntermediateVT,
  832     EVT ScalarVT = VT.getScalarType();
 1222 bool SITargetLowering::canMergeStoresTo(unsigned AS, EVT MemVT,
 1292     EVT VT, unsigned AddrSpace, unsigned Align, MachineMemOperand::Flags Flags,
 1310 EVT SITargetLowering::getOptimalMemOpType(
 1371 bool SITargetLowering::isTypeDesirableForOp(unsigned Op, EVT VT) const {
 1426 SDValue SITargetLowering::convertArgType(SelectionDAG &DAG, EVT VT, EVT MemVT,
 1426 SDValue SITargetLowering::convertArgType(SelectionDAG &DAG, EVT VT, EVT MemVT,
 1433     EVT NarrowedVT =
 1434         EVT::getVectorVT(*DAG.getContext(), MemVT.getVectorElementType(),
 1458   SelectionDAG &DAG, EVT VT, EVT MemVT,
 1458   SelectionDAG &DAG, EVT VT, EVT MemVT,
 1474     EVT IntVT = MemVT.changeTypeToInteger();
 1554   EVT VT,
 2133       EVT MemVT = VA.getLocVT();
 2168     EVT ValVT = VA.getValVT();
 2182         DAG.getValueType(EVT::getIntegerVT(*DAG.getContext(), NumBits)));
 2482     EVT ArgVT = TRI->getSpillSize(*ArgRC) == 8 ? MVT::i64 : MVT::i32;
 2982 Register SITargetLowering::getRegisterByName(const char* RegName, EVT VT,
 3872 bool SITargetLowering::hasBitPreservingFPLogic(EVT VT) const {
 3876 bool SITargetLowering::enableAggressiveFMAFusion(EVT VT) const {
 3887 EVT SITargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &Ctx,
 3888                                          EVT VT) const {
 3892   return EVT::getVectorVT(Ctx, MVT::i1, VT.getVectorNumElements());
 3895 MVT SITargetLowering::getScalarShiftAmountTy(const DataLayout &, EVT VT) const {
 3916 bool SITargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
 3951   EVT VT = Op.getValueType();
 3971   EVT VT = Op.getValueType();
 3992   EVT VT = Op.getValueType();
 4086 static SDValue adjustLoadValueTypeImpl(SDValue Result, EVT LoadVT,
 4094     EVT IntLoadVT = LoadVT.changeTypeToInteger();
 4121   EVT LoadVT = M->getValueType(0);
 4123   EVT EquivLoadVT = LoadVT;
 4126       EVT::getVectorVT(*DAG.getContext(), MVT::i32,
 4150   EVT LoadVT = M->getValueType(0);
 4151   EVT EltType = LoadVT.getScalarType();
 4152   EVT IntVT = LoadVT.changeTypeToInteger();
 4172   EVT CastVT = getEquivalentMemType(*DAG.getContext(), LoadVT);
 4183   EVT VT = N->getValueType(0);
 4197   EVT CmpVT = LHS.getValueType();
 4208   EVT CCVT = EVT::getIntegerVT(*DAG.getContext(), WavefrontSize);
 4208   EVT CCVT = EVT::getIntegerVT(*DAG.getContext(), WavefrontSize);
 4219   EVT VT = N->getValueType(0);
 4230   EVT CmpVT = Src0.getValueType();
 4241   EVT CCVT = EVT::getIntegerVT(*DAG.getContext(), WavefrontSize);
 4241   EVT CCVT = EVT::getIntegerVT(*DAG.getContext(), WavefrontSize);
 4293       EVT VT = N->getValueType(0);
 4322     EVT VT = N->getValueType(0);
 4323     EVT NewVT = getEquivalentMemType(*DAG.getContext(), VT);
 4327     EVT SelectVT = NewVT;
 4483   ArrayRef<EVT> Res(Intr->value_begin() + 1, Intr->value_end());
 4561                                             EVT VT) const {
 4572   EVT SrcVT = Src.getValueType();
 4585   EVT VT = Op.getValueType();
 4769   EVT VecVT = Vec.getValueType();
 4770   EVT InsVT = Ins.getValueType();
 4771   EVT EltVT = VecVT.getVectorElementType();
 4790   EVT VecVT = Vec.getValueType();
 4791   EVT EltVT = VecVT.getVectorElementType();
 4865   EVT ResultVT = Op.getValueType();
 4868   EVT VecVT = Vec.getValueType();
 4870   EVT EltVT = VecVT.getVectorElementType();
 4910   EVT ResultVT = Op.getValueType();
 4913   EVT PackVT = ResultVT.isInteger() ? MVT::v2i16 : MVT::v2f16;
 4914   EVT EltVT = PackVT.getVectorElementType();
 4962   EVT VT = Op.getValueType();
 4965     EVT HalfVT = MVT::getVectorVT(VT.getVectorElementType().getSimpleVT(), 2);
 5020                         const SDLoc &DL, unsigned Offset, EVT PtrVT,
 5078   EVT PtrVT = Op.getValueType();
 5136                                         EVT VT) {
 5145                                          EVT VT) {
 5219                                  ArrayRef<EVT> ResultTypes,
 5224   EVT ReqRetVT = ResultTypes[0];
 5225   EVT ReqRetEltVT = ReqRetVT.isVector() ? ReqRetVT.getVectorElementType() : ReqRetVT;
 5227   EVT AdjEltVT = Unpacked && IsD16 ? MVT::i32 : ReqRetEltVT;
 5228   EVT AdjVT = Unpacked ? ReqRetNumElts > 1 ? EVT::getVectorVT(Context, AdjEltVT, ReqRetNumElts)
 5228   EVT AdjVT = Unpacked ? ReqRetNumElts > 1 ? EVT::getVectorVT(Context, AdjEltVT, ReqRetNumElts)
 5240   EVT CastVT = NumElts > 1 ? EVT::getVectorVT(Context, AdjEltVT, NumElts)
 5240   EVT CastVT = NumElts > 1 ? EVT::getVectorVT(Context, AdjEltVT, NumElts)
 5247     CastVT = EVT::getVectorVT(Context, MVT::i32, NumElts / 2);
 5331   SmallVector<EVT, 3> ResultTypes(Op->value_begin(), Op->value_end());
 5332   SmallVector<EVT, 3> OrigResultTypes(Op->value_begin(), Op->value_end());
 5540     EVT NewVT = NumVDataDwords > 1 ?
 5541                   EVT::getVectorVT(*DAG.getContext(), MVT::f32, NumVDataDwords)
 5638 SDValue SITargetLowering::lowerSBuffer(EVT VT, SDLoc DL, SDValue Rsrc,
 5709   EVT VT = Op.getValueType();
 6026     EVT VT = Op.getValueType();
 6267     EVT VT = Op.getValueType();
 6268     EVT IntVT = VT.changeTypeToInteger();
 6271     EVT LoadVT = Op.getValueType();
 6328     EVT LoadVT = Op.getValueType();
 6358     EVT LoadVT = Op.getValueType();
 6382     EVT LoadVT = Op.getValueType();
 6433     EVT VT = Op.getValueType();
 6501     EVT VT = Op.getValueType();
 6575     EVT VT = Op.getValueType();
 6647     EVT VT = Op.getValueType();
 6668     EVT VT = Op.getValueType();
 6689     EVT VT = Op.getValueType();
 6711                                               ArrayRef<SDValue> Ops, EVT MemVT,
 6714   EVT VT = VTList.VTs[0];
 6715   EVT WidenedVT = VT;
 6716   EVT WidenedMemVT = MemVT;
 6719     WidenedVT = EVT::getVectorVT(*DAG.getContext(),
 6721     WidenedMemVT = EVT::getVectorVT(*DAG.getContext(),
 6742   EVT StoreVT = VData.getValueType();
 6753     EVT IntStoreVT = StoreVT.changeTypeToInteger();
 6756     EVT EquivStoreVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
 6756     EVT EquivStoreVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
 6945     EVT VDataType = VData.getValueType().getScalarType();
 6959     EVT VDataVT = VData.getValueType();
 6960     EVT EltType = VDataVT.getScalarType();
 7003     EVT VDataVT = VData.getValueType();
 7004     EVT EltType = VDataVT.getScalarType();
 7036     EVT VDataType = VData.getValueType().getScalarType();
 7064     EVT VT = Op.getOperand(2).getValueType();
 7081     EVT VT = Op.getOperand(3).getValueType();
 7196                                                      EVT LoadVT, SDLoc DL,
 7199   EVT IntVT = LoadVT.changeTypeToInteger();
 7215                                                       EVT VDataType, SDLoc DL,
 7232                                  const SDLoc &SL, EVT VT) {
 7265   EVT MemVT = Ld->getMemoryVT();
 7286   EVT TruncVT = EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits());
 7286   EVT TruncVT = EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits());
 7304   EVT VT = Ld->getValueType(0);
 7305   EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 7305   EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
 7324   EVT MemVT = Load->getMemoryVT();
 7337     EVT RealMemVT = (MemVT == MVT::i1) ? MVT::i8 : MVT::i16;
 7488   EVT VT = Op.getValueType();
 7521   EVT VT = Op.getValueType();
 7569                           EVT VT, SDValue A, SDValue B, SDValue GlueChain) {
 7589                            EVT VT, SDValue A, SDValue B, SDValue C,
 7645   EVT SetCCVT =
 7847   EVT VT = Op.getValueType();
 7864   EVT VT = Store->getMemoryVT();
 7947   EVT VT = Op.getValueType();
 7988   EVT VT = Op.getValueType();
 8005   EVT VT = N->getValueType(0);
 8006   EVT ScalarVT = VT.getScalarType();
 8014   EVT SrcVT = Src.getValueType();
 8047                                                EVT MemVT,
 8079   EVT VT = N->getValueType(0);
 8234   EVT VT = N->getValueType(0);
 8265           EVT NarrowVT = EVT::getIntegerVT(*DAG.getContext(), Bits);
 8265           EVT NarrowVT = EVT::getIntegerVT(*DAG.getContext(), Bits);
 8420   EVT VT = N->getValueType(0);
 8514     EVT SrcVT = ExtSrc.getValueType();
 8542   EVT VT = N->getValueType(0);
 8622   EVT VT = N->getValueType(0);
 8698   EVT VT = N->getValueType(0);
 8873   SelectionDAG &DAG, const SDLoc &SL, EVT VT, const APFloat &C) const {
 8907   EVT VT = N->getValueType(0);
 8916     EVT VT = N->getValueType(0);
 8933     EVT EltVT = Lo.getValueType();
 9030   EVT VT = K0->getValueType(0);
 9082   EVT VT = Op0.getValueType();
 9119   EVT VT = N->getValueType(0);
 9199   EVT VT = N->getValueType(0);
 9255   EVT VecVT = Vec.getValueType();
 9256   EVT EltVT = VecVT.getVectorElementType();
 9261     EVT EltVT = N->getValueType(0);
 9275     EVT EltVT = N->getValueType(0);
 9319     EVT IdxVT = Idx.getValueType();
 9345     EVT NewVT = getEquivalentMemType(*DAG.getContext(), VecVT);
 9375   EVT VecVT = Vec.getValueType();
 9376   EVT EltVT = VecVT.getVectorElementType();
 9393   EVT IdxVT = Idx.getValueType();
 9409   EVT VT = N0->getValueType(0);
 9434   EVT VT = N->getValueType(0);
 9471                            EVT VT,
 9483   EVT VT = N->getValueType(0);
 9560   EVT VT = N->getValueType(0);
 9611   EVT VT = N->getValueType(0);
 9654   EVT VT = N->getValueType(0);
 9697   EVT VT = N->getValueType(0);
 9776   EVT VT = LHS.getValueType();
10039     EVT VT = N->getValueType(0);
10045       EVT EltVT = Src.getValueType();
10880 bool SITargetLowering::denormalsEnabledForType(EVT VT) const {

lib/Target/AMDGPU/SIISelLowering.h

   30                                     EVT VT) const override;
   33                                          EVT VT) const override;
   36     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
   36     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
   43   SDValue lowerKernargMemParameter(SelectionDAG &DAG, EVT VT, EVT MemVT,
   43   SDValue lowerKernargMemParameter(SelectionDAG &DAG, EVT VT, EVT MemVT,
   53                             EVT VT,
   62   SDValue lowerSBuffer(EVT VT, SDLoc DL, SDValue Rsrc, SDValue Offset,
  103                               ArrayRef<SDValue> Ops, EVT MemVT,
  113                             EVT VT) const;
  116     SelectionDAG &DAG, EVT VT, EVT MemVT, const SDLoc &SL, SDValue Val,
  116     SelectionDAG &DAG, EVT VT, EVT MemVT, const SDLoc &SL, SDValue Val,
  141                                EVT MemVT,
  156   SDValue getCanonicalConstantFP(SelectionDAG &DAG, const SDLoc &SL, EVT VT,
  212   SDValue handleByteShortBufferLoads(SelectionDAG &DAG, EVT LoadVT, SDLoc DL,
  216   SDValue handleByteShortBufferStores(SelectionDAG &DAG, EVT VDataType,
  225   bool isFPExtFoldable(unsigned Opcode, EVT DestVT, EVT SrcVT) const override;
  225   bool isFPExtFoldable(unsigned Opcode, EVT DestVT, EVT SrcVT) const override;
  227   bool isShuffleMaskLegal(ArrayRef<int> /*Mask*/, EVT /*VT*/) const override;
  242   bool canMergeStoresTo(unsigned AS, EVT MemVT,
  251       EVT VT, unsigned AS, unsigned Align,
  255   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
  280   bool isTypeDesirableForOp(unsigned Op, EVT VT) const override;
  332   Register getRegisterByName(const char* RegName, EVT VT,
  346   bool hasBitPreservingFPLogic(EVT VT) const override;
  347   bool enableAggressiveFMAFusion(EVT VT) const override;
  348   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  349                          EVT VT) const override;
  350   MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override;
  351   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
  391   bool denormalsEnabledForType(EVT VT) const;

lib/Target/ARC/ARCISelLowering.cpp

  485       EVT RegVT = VA.getLocVT();
  715   EVT VT = Op.getValueType();
  740   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());

lib/Target/ARM/ARMCallLowering.cpp

   70   EVT VT = TLI.getValueType(DL, T, true);
  198   SmallVector<EVT, 4> SplitVTs;
  214     EVT SplitVT = SplitVTs[i];

lib/Target/ARM/ARMFastISel.cpp

  643   EVT CEVT = TLI.getValueType(DL, C->getType(), true);
  690   EVT evt = TLI.getValueType(DL, Ty, true);
 1353   EVT SrcEVT = TLI.getValueType(DL, Ty, true);
 1547   EVT SrcEVT = TLI.getValueType(DL, Src->getType(), true);
 1750   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1790   EVT FPVT = TLI.getValueType(DL, I->getType(), true);
 2137     EVT RVEVT = TLI.getValueType(DL, RV->getType());
 2187   EVT LCREVT = TLI.getValueType(DL, GVTy);
 2581   EVT SrcVT, DestVT;
 2749   EVT SrcEVT, DestEVT;
 2771   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 3039     EVT ArgVT = TLI.getValueType(DL, ArgTy);

lib/Target/ARM/ARMISelDAGToDAG.cpp

  223   void AddEmptyMVEPredicateToOps(SDValueVector &Ops, SDLoc Loc, EVT InactiveTy);
  272   SDNode *createGPRPairNode(EVT VT, SDValue V0, SDValue V1);
  273   SDNode *createSRegPairNode(EVT VT, SDValue V0, SDValue V1);
  274   SDNode *createDRegPairNode(EVT VT, SDValue V0, SDValue V1);
  275   SDNode *createQRegPairNode(EVT VT, SDValue V0, SDValue V1);
  278   SDNode *createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
  279   SDNode *createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
  280   SDNode *createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1, SDValue V2, SDValue V3);
 1475   EVT LoadedVT = LD->getMemoryVT();
 1550   EVT LoadedVT = LD->getMemoryVT();
 1581   EVT LoadedVT = LD->getMemoryVT();
 1631   EVT LoadedVT = LD->getMemoryVT();
 1689 SDNode *ARMDAGToDAGISel::createGPRPairNode(EVT VT, SDValue V0, SDValue V1) {
 1700 SDNode *ARMDAGToDAGISel::createSRegPairNode(EVT VT, SDValue V0, SDValue V1) {
 1711 SDNode *ARMDAGToDAGISel::createDRegPairNode(EVT VT, SDValue V0, SDValue V1) {
 1722 SDNode *ARMDAGToDAGISel::createQRegPairNode(EVT VT, SDValue V0, SDValue V1) {
 1733 SDNode *ARMDAGToDAGISel::createQuadSRegsNode(EVT VT, SDValue V0, SDValue V1,
 1748 SDNode *ARMDAGToDAGISel::createQuadDRegsNode(EVT VT, SDValue V0, SDValue V1,
 1763 SDNode *ARMDAGToDAGISel::createQuadQRegsNode(EVT VT, SDValue V0, SDValue V1,
 1916 static bool isPerfectIncrement(SDValue Inc, EVT VecTy, unsigned NumVecs) {
 1936   EVT VT = N->getValueType(0);
 1960   EVT ResTy;
 1967     ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
 1969   std::vector<EVT> ResTys;
 2008     EVT AddrTy = MemAddr.getValueType();
 2078   EVT VT = N->getOperand(Vec0Idx).getValueType();
 2102   std::vector<EVT> ResTys;
 2231   EVT VT = N->getOperand(Vec0Idx).getValueType();
 2265   std::vector<EVT> ResTys;
 2270     ResTys.push_back(EVT::getVectorVT(*CurDAG->getContext(),
 2362                                                 EVT InactiveTy) {
 2462   EVT VT = N->getValueType(0);
 2480   EVT DataTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, NumVecs * 2);
 2480   EVT DataTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, NumVecs * 2);
 2481   EVT ResultTys[] = {DataTy, MVT::Other};
 2515   EVT VT = N->getValueType(0);
 2554   EVT ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
 2554   EVT ResTy = EVT::getVectorVT(*CurDAG->getContext(), MVT::i64, ResTyElts);
 2556   std::vector<EVT> ResTys;
 2782   EVT VT = N->getValueType(0);
 2795   EVT XType = SRASrc0.getValueType();
 2812   EVT MemTy = cast<MemSDNode>(N)->getMemoryVT();
 3161     EVT VT = N->getValueType(0);
 3470     EVT VT = N->getValueType(0);
 3493     EVT VT = N->getValueType(0);
 3516     EVT VT = N->getValueType(0);
 3537     EVT VecVT = N->getValueType(0);
 3538     EVT EltVT = VecVT.getVectorElementType();
 3830       const EVT RetType[] = {MVT::i32, MVT::i32, MVT::Other};
 3847       std::vector<EVT> ResTys;
 3905       const EVT ResTys[] = {MVT::i32, MVT::Other};
 4429     SmallVector<EVT, 3> ResTypes;

lib/Target/ARM/ARMISelLowering.cpp

 1677 EVT ARMTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &,
 1678                                           EVT VT) const {
 1734     EVT VT = N->getValueType(i);
 2208         EVT PtrVT =
 2640         EVT RegVT = VA.getLocVT();
 2981   EVT PtrVT = Op.getValueType();
 3027   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3126   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3180   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3225   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3319                                      EVT PtrVT, const SDLoc &dl) {
 3438   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3506   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3542   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3593       EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3605       std::vector<EVT> ResultTys = {MVT::Other, MVT::Glue};
 3632     EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3637     const EVT VTy = Op.getValueType();
 3652     const EVT VTy = Op.getValueType();
 3682     EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3825   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
 4021       EVT RegVT = VA.getLocVT();
 4442   EVT VT = Op.getValueType();
 4454   EVT CarryVT = BoolCarry.getValueType();
 4464 static SDValue ConvertCarryFlagToBooleanCarry(SDValue Flags, EVT VT,
 4485   EVT VT = Op.getValueType();
 4514   EVT VT = Op.getValueType();
 4558     EVT VT = Op.getValueType();
 4590         EVT VT = Op.getValueType();
 4660 SDValue ARMTargetLowering::getCMOV(const SDLoc &dl, EVT VT, SDValue FalseVal,
 4869 bool ARMTargetLowering::isUnsupportedFloatingType(EVT VT) const {
 4880   EVT VT = Op.getValueType();
 4969       EVT VT = TrueVal.getValueType();
 5065   EVT VT = Op.getValueType();
 5106     EVT PtrType = Ptr.getValueType();
 5298   EVT PTy = getPointerTy(DAG.getDataLayout());
 5329   EVT VT = Op.getValueType();
 5341   EVT NewTy;
 5342   const EVT OpTy = Op.getOperand(0).getValueType();
 5360   EVT VT = Op.getValueType();
 5380   EVT VT = Op.getValueType();
 5396   EVT DestVecType;
 5425   EVT VT = Op.getValueType();
 5449   EVT VT = Op.getValueType();
 5450   EVT SrcVT = Tmp1.getValueType();
 5460     EVT OpVT = (VT == MVT::f32) ? MVT::v2i32 : MVT::v1i64;
 5534   EVT VT = Op.getValueType();
 5557   EVT VT = Op.getValueType();
 5570 Register ARMTargetLowering::getRegisterByName(const char* RegName, EVT VT,
 5611   EVT DstVT = BC->getValueType(0);
 5643   EVT VecVT = EVT::getVectorVT(
 5643   EVT VecVT = EVT::getVectorVT(
 5664   EVT SrcVT = Op.getValueType();
 5665   EVT DstVT = N->getValueType(0);
 5778 static SDValue getZeroVector(EVT VT, SelectionDAG &DAG, const SDLoc &dl) {
 5782   EVT VmovVT = VT.is128BitVector() ? MVT::v4i32 : MVT::v2i32;
 5792   EVT VT = Op.getValueType();
 5836   EVT VT = Op.getValueType();
 5892   EVT VT = N->getValueType(0);
 5900     EVT ElemTy = VT.getVectorElementType();
 5947   EVT VT = N->getValueType(0);
 5956   EVT VT8Bit = VT.is64BitVector() ? MVT::v8i8 : MVT::v16i8;
 6002 static bool isVShiftLImm(SDValue Op, EVT VT, bool isLong, int64_t &Cnt) {
 6016 static bool isVShiftRImm(SDValue Op, EVT VT, bool isNarrow, bool isIntrinsic,
 6033   EVT VT = N->getValueType(0);
 6066   EVT ShiftVT = N->getOperand(1).getValueType();
 6076   EVT VT = N->getValueType(0);
 6165   EVT VT = Op.getValueType();
 6169   EVT CmpVT;
 6192     EVT SplitVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, CmpElements);
 6192     EVT SplitVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, CmpElements);
 6371                                  const SDLoc &dl, EVT &VT, bool is128Bits,
 6511   EVT VT = Op.getValueType();
 6575   EVT VMovVT;
 6623 static bool isSingletonVEXTMask(ArrayRef<int> M, EVT VT, unsigned &Imm) {
 6651 static bool isVEXTMask(ArrayRef<int> M, EVT VT,
 6690 static bool isVREVMask(ArrayRef<int> M, EVT VT, unsigned BlockSize) {
 6716 static bool isVTBLMask(ArrayRef<int> M, EVT VT) {
 6751 static bool isVTRNMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6783 static bool isVTRN_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult){
 6815 static bool isVUZPMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6845 static bool isVUZP_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult){
 6886 static bool isVZIPMask(ArrayRef<int> M, EVT VT, unsigned &WhichResult) {
 6919 static bool isVZIP_v_undef_Mask(ArrayRef<int> M, EVT VT, unsigned &WhichResult){
 6951 static unsigned isNEONTwoResultShuffleMask(ArrayRef<int> ShuffleMask, EVT VT,
 6974 static bool isReverseMask(ArrayRef<int> M, EVT VT) {
 6988 static bool isVMOVNMask(ArrayRef<int> M, EVT VT, bool Top) {
 7034   EVT VT = Op.getValueType();
 7097   EVT VT = Op.getValueType();
 7112       EVT VmovVT;
 7249       EVT VecVT = EVT::getVectorVT(*DAG.getContext(), IVT, NumElts);
 7249       EVT VecVT = EVT::getVectorVT(*DAG.getContext(), IVT, NumElts);
 7279     EVT ExtVT = VT.getVectorElementType();
 7280     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElts / 2);
 7280     EVT HVT = EVT::getVectorVT(*DAG.getContext(), ExtVT, NumElts / 2);
 7299     EVT EltVT = EVT::getFloatingPointVT(EltSize);
 7299     EVT EltVT = EVT::getFloatingPointVT(EltSize);
 7300     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
 7300     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
 7335   EVT VT = Op.getValueType();
 7394   EVT SmallestEltTy = VT.getVectorElementType();
 7396     EVT SrcEltTy = Source.Vec.getValueType().getVectorElementType();
 7403   EVT ShuffleVT = EVT::getVectorVT(*DAG.getContext(), SmallestEltTy, NumElts);
 7403   EVT ShuffleVT = EVT::getVectorVT(*DAG.getContext(), SmallestEltTy, NumElts);
 7409     EVT SrcVT = Src.ShuffleVec.getValueType();
 7416     EVT EltVT = SrcVT.getVectorElementType();
 7418     EVT DestVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumSrcElts);
 7418     EVT DestVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumSrcElts);
 7470     EVT SrcEltTy = Src.ShuffleVec.getValueType().getVectorElementType();
 7498     EVT OrigEltTy = Entry.getOperand(0).getValueType().getVectorElementType();
 7565 bool ARMTargetLowering::isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const {
 7630   EVT VT = OpLHS.getValueType();
 7697   EVT VT = OpLHS.getValueType();
 7710 static EVT getVectorTyFromPredicateVector(EVT VT) {
 7710 static EVT getVectorTyFromPredicateVector(EVT VT) {
 7723 static SDValue PromoteMVEPredVector(SDLoc dl, SDValue Pred, EVT VT,
 7737   EVT NewVT = getVectorTyFromPredicateVector(VT);
 7760   EVT VT = Op.getValueType();
 7786   EVT NewVT = PredAsVector.getValueType();
 7803   EVT VT = Op.getValueType();
 7910       EVT SubVT = SubV1.getValueType();
 7967     EVT EltVT = EVT::getFloatingPointVT(EltSize);
 7967     EVT EltVT = EVT::getFloatingPointVT(EltSize);
 7968     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
 7968     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NumElts);
 7997   EVT VecVT = Op.getOperand(0).getValueType();
 8024   EVT EltVT = Elt.getValueType();
 8039     EVT IEltVT = MVT::getIntegerVT(EltVT.getScalarSizeInBits());
 8044     EVT VecVT = VecIn.getValueType();
 8045     EVT IVecVT = EVT::getVectorVT(*DAG.getContext(), IEltVT,
 8045     EVT IVecVT = EVT::getVectorVT(*DAG.getContext(), IEltVT,
 8060   EVT VecVT = Op.getOperand(0).getValueType();
 8084   EVT VT = Vec.getValueType();
 8102   EVT VT = Op.getValueType();
 8103   EVT Op1VT = V1.getValueType();
 8104   EVT Op2VT = V2.getValueType();
 8126   EVT ConcatVT = MVT::getVectorVT(ElType, NumElts);
 8129     EVT NewVT = NewV.getValueType();
 8130     EVT ConcatVT = ConVec.getValueType();
 8151   EVT VT = Op->getValueType(0);
 8179   EVT VT = Op.getValueType();
 8180   EVT Op1VT = V1.getValueType();
 8196   EVT SubVT = MVT::getVectorVT(ElType, NumElts);
 8217   EVT VT = N->getValueType(0);
 8285 static EVT getExtensionTo64Bits(const EVT &OrigVT) {
 8285 static EVT getExtensionTo64Bits(const EVT &OrigVT) {
 8306                                             const EVT &OrigTy,
 8307                                             const EVT &ExtTy,
 8317   EVT NewVT = getExtensionTo64Bits(OrigTy);
 8328   EVT ExtendedTy = getExtensionTo64Bits(LD->getMemoryVT());
 8385   EVT VT = N->getValueType(0);
 8426   EVT VT = Op.getValueType();
 8490   EVT Op1VT = Op1.getValueType();
 8570   EVT VT = Op.getValueType();
 8607   EVT VT = Op.getValueType();
 8683   EVT VT = N->getValueType(0);
 8732   EVT ArgVT = Arg.getValueType();
 8803   EVT VT = Op.getValueType();
 8930   EVT MemVT = LD->getMemoryVT();
 8949       EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits()),
 8960   EVT MemVT = ST->getMemoryVT();
 8983       EVT::getIntegerVT(*DAG.getContext(), MemVT.getSizeInBits()),
10863     EVT VT = N->getValueType(0);
10912   EVT VT = N->getValueType(0);
10976   EVT VT = N->getValueType(0);
11015   EVT VT = N->getValueType(0);
11026   EVT ElemTy = N00.getValueType().getVectorElementType();
11028   EVT ConcatVT = EVT::getVectorVT(*DAG.getContext(), ElemTy, NumElts * 2);
11028   EVT ConcatVT = EVT::getVectorVT(*DAG.getContext(), ElemTy, NumElts * 2);
11051   EVT VT = N->getValueType(0);
11123   EVT inputLaneType = Vec.getValueType().getVectorElementType();
11629 bool ARMTargetLowering::preferIncOfAddToSubOfNot(EVT VT) const {
11813   EVT VT = N->getValueType(0);
11833   EVT VT = N->getValueType(0);
12015   EVT VT = N->getValueType(0);
12027       EVT VbicVT;
12125   EVT VT = N->getValueType(0);
12266   EVT VT = N->getValueType(0);
12322   EVT VT = N->getValueType(0);
12334       EVT VorrVT;
12388                 EVT CanonicalVT = VT.is128BitVector() ? MVT::v4i32 : MVT::v2i32;
12419   EVT VT = N->getValueType(0);
12557     EVT VT = N->getValueType(0);
12662   EVT VT = N->getValueType(0);
12674   EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, NumElts);
12674   EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, NumElts);
12694   EVT VT = N->getValueType(0);
12695   EVT EltVT = VT.getVectorElementType();
12736   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
12736   EVT VecVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
12773   EVT VT = N->getValueType(0);
12795   EVT VT = N->getValueType(0);
12803   EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
12803   EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
12841   EVT VT = N->getValueType(0);
12963     EVT VecTy;
12989     EVT AlignedVecTy = VecTy;
13028     EVT Tys[6];
13063     EVT LoadVT = isLaneOp ? VecTy.getVectorElementType() : AlignedVecTy;
13102   EVT VT = N->getValueType(0);
13143   EVT Tys[5];
13202   EVT VT = N->getValueType(0);
13240   EVT VT = N->getValueType(0);
13256   EVT VT = StVal.getValueType();
13260   EVT StVT = St->getMemoryVT();
13279   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(), StVT.getScalarType(),
13279   EVT WideVecVT = EVT::getVectorVT(*DAG.getContext(), StVT.getScalarType(),
13310   EVT StoreVecVT =
13311       EVT::getVectorVT(*DAG.getContext(), StoreType,
13345   EVT FromVT = Trunc->getOperand(0).getValueType();
13346   EVT ToVT = Trunc.getValueType();
13350   EVT ToEltVT = ToVT.getVectorElementType();
13351   EVT FromEltVT = FromVT.getVectorElementType();
13370   EVT NewFromVT = EVT::getVectorVT(*DAG.getContext(), FromEltVT, NumElements);
13370   EVT NewFromVT = EVT::getVectorVT(*DAG.getContext(), FromEltVT, NumElements);
13371   EVT NewToVT = EVT::getVectorVT(*DAG.getContext(), ToEltVT, NumElements);
13371   EVT NewToVT = EVT::getVectorVT(*DAG.getContext(), ToEltVT, NumElements);
13398   EVT VT = StVal.getValueType();
13441     EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
13441     EVT FloatVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64,
13608     EVT VT = N->getOperand(1).getValueType();
13709     EVT VT = N->getOperand(1).getValueType();
13745   EVT VT = N->getValueType(0);
13837   EVT FromVT = LD->getValueType(0);
13838   EVT ToVT = N->getValueType(0);
13842   EVT ToEltVT = ToVT.getVectorElementType();
13843   EVT FromEltVT = FromVT.getVectorElementType();
13867   EVT NewFromVT = FromVT.getHalfNumVectorElementsVT(*DAG.getContext());
13868   EVT NewToVT = ToVT.getHalfNumVectorElementsVT(*DAG.getContext());
13904     EVT VT = N->getValueType(0);
13905     EVT EltVT = N0.getValueType();
14010   EVT VT = X.getValueType();
14206   EVT VT = N->getValueType(0);
14246   EVT VT = N->getValueType(0);
14564                                                           EVT VT) const {
14568 bool ARMTargetLowering::allowsMisalignedMemoryAccesses(EVT VT, unsigned,
14645 EVT ARMTargetLowering::getOptimalMemOpType(
14683 bool ARMTargetLowering::isTruncateFree(EVT SrcVT, EVT DstVT) const {
14683 bool ARMTargetLowering::isTruncateFree(EVT SrcVT, EVT DstVT) const {
14692 bool ARMTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
14696   EVT VT1 = Val.getValueType();
14713 bool ARMTargetLowering::isFNegFree(EVT VT) const {
14810   EVT VT = ExtVal.getValueType();
14840   if (!isTypeLegal(EVT::getEVT(Ty1)))
14861 static bool isLegalT1AddressImmediate(int64_t V, EVT VT) {
14887 static bool isLegalT2AddressImmediate(int64_t V, EVT VT,
14941 static bool isLegalAddressImmediate(int64_t V, EVT VT,
14976                                                       EVT VT) const {
15014                                                       EVT VT) const {
15033   EVT VT = getValueType(DL, Ty, true);
15123 static bool getARMIndexedAddressParts(SDNode *Ptr, EVT VT,
15182 static bool getT2IndexedAddressParts(SDNode *Ptr, EVT VT,
15207 static bool getMVEIndexedAddressParts(SDNode *Ptr, EVT VT, unsigned Align,
15264   EVT VT;
15310   EVT VT;
15421       EVT VT = cast<MemIntrinsicSDNode>(Op)->getMemoryVT();
15444     EVT VecVT = SrcSV.getValueType();
15454     EVT VT = Op.getValueType();
15484   EVT VT = Op.getValueType();
15590 const char *ARMTargetLowering::LowerXConstraint(EVT ConstraintVT) const {
15944     EVT ArgVT = N->getOperand(i).getValueType();
15966   EVT VT = Op->getValueType(0);
16149   EVT SrcVT = SrcVal.getValueType();
16150   EVT DstVT = Op.getValueType();
16224 bool ARMTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
16259     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
16275     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
16300     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
16322     Info.memVT = EVT::getVectorVT(I.getType()->getContext(), MVT::i64, NumElts);
16393 bool ARMTargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
16393 bool ARMTargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,

lib/Target/ARM/ARMISelLowering.h

  321     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  322                            EVT VT) const override;
  336     bool isDesirableToTransformToIntegerOp(unsigned Opc, EVT VT) const override;
  341     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
  346     EVT getOptimalMemOpType(uint64_t Size,
  353     bool isTruncateFree(EVT SrcVT, EVT DstVT) const override;
  353     bool isTruncateFree(EVT SrcVT, EVT DstVT) const override;
  354     bool isZExtFree(SDValue Val, EVT VT2) const override;
  358     bool isFNegFree(EVT VT) const override;
  378     bool isLegalT2ScaledAddressingMode(const AddrMode &AM, EVT VT) const;
  382     bool isLegalT1ScaledAddressingMode(const AddrMode &AM, EVT VT) const;
  432     const char *LowerXConstraint(EVT ConstraintVT) const override;
  499     isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const override;
  505     bool isFPImmLegal(const APFloat &Imm, EVT VT,
  520     bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
  520     bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
  578     bool canMergeStoresTo(unsigned AddressSpace, EVT MemVT,
  587     bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
  595     bool hasStandaloneRem(EVT VT) const override {
  629     bool preferIncOfAddToSubOfNot(EVT VT) const override;
  735     Register getRegisterByName(const char* RegName, EVT VT,
  750     bool isFMAFasterThanFMulAndFAdd(EVT VT) const override { return false; }
  820     bool isUnsupportedFloatingType(EVT VT) const;
  822     SDValue getCMOV(const SDLoc &dl, EVT VT, SDValue FalseVal, SDValue TrueVal,

lib/Target/ARM/ARMSelectionDAGInfo.cpp

  151   EVT VT = MVT::i32;

lib/Target/ARM/ARMTargetTransformInfo.cpp

  168   EVT SrcTy = TLI->getValueType(DL, Src);
  169   EVT DstTy = TLI->getValueType(DL, Dst);
  454     EVT SelCondTy = TLI->getValueType(DL, CondTy);
  455     EVT SelValTy = TLI->getValueType(DL, ValTy);
  533   std::vector<EVT> MemOps;
  877     EVT VT = TLI->getValueType(DL, I.getType(), true);

lib/Target/AVR/AVRISelDAGToDAG.cpp

  343   EVT VT = ST->getValue().getValueType();

lib/Target/AVR/AVRISelLowering.cpp

  272 EVT AVRTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &,
  273                                           EVT VT) const {
  283   EVT VT = Op.getValueType();
  344   EVT VT = Op->getValueType(0);
  447   EVT VT = LHS.getValueType();
  776   EVT VT;
  833   EVT VT;
 1070       EVT RegVT = VA.getLocVT();
 1114       EVT LocVT = VA.getLocVT();
 1199     EVT RegVT = VA.getLocVT();
 1908   EVT Ty = Op.getValueType();
 2009 Register AVRTargetLowering::getRegisterByName(const char *RegName, EVT VT,

lib/Target/AVR/AVRISelLowering.h

   76   MVT getScalarShiftAmountTy(const DataLayout &, EVT LHSTy) const override {
  105   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  106                          EVT VT) const override;
  128   Register getRegisterByName(const char* RegName, EVT VT,

lib/Target/BPF/BPFISelDAGToDAG.cpp

  227     EVT VT = Node->getValueType(0);

lib/Target/BPF/BPFISelLowering.cpp

  229       EVT RegVT = VA.getLocVT();
  754 EVT BPFTargetLowering::getSetCCResultType(const DataLayout &, LLVMContext &,
  755                                           EVT VT) const {
  760                                               EVT VT) const {

lib/Target/BPF/BPFISelLowering.h

   61   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
   62                          EVT VT) const override;
   64   MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override;
  102   EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,

lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

   71   EVT LoadedVT = LD->getMemoryVT();
  148   EVT ValueVT = LD->getValueType(0);
  202     EVT ValTy = (IntNo == Intrinsic::hexagon_circ_ldd) ? MVT::i64 : MVT::i32;
  203     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  335     EVT ValTy =
  337     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  383     EVT ValTy = MVT::i32;
  387     EVT RTys[] = { ValTy, MVT::i32, MVT::Other };
  422     EVT RTys[] = { MVT::i32, MVT::Other };
  470   EVT StoredVT = ST->getMemoryVT();
  471   EVT ValueVT = Value.getValueType();
  996     EVT VT = I->getValueType(0);
 1066     EVT VT = T0.getValueType();
 1141     EVT VT = Addr.getValueType();
 1162     EVT OpVT = OpI1.getValueType();
 1169       EVT UVT = U->getValueType(0);
 1180       EVT BVT = Ops[I1N].getValueType();
 1317   EVT T = N.getValueType();
 1444       EVT T = Opc == ISD::SIGN_EXTEND
 1477   EVT RT = R.getValueType();
 1503     EVT T = Op0.getValueType();
 2161     EVT VT = N->getValueType(0);
 2204       EVT VT = NewRoot.getValueType();

lib/Target/Hexagon/HexagonISelLowering.cpp

  243 Register HexagonTargetLowering::getRegisterByName(const char* RegName, EVT VT,
  551   EVT VT = LSN->getMemoryVT();
  842         EVT OrigTy = cast<VTSDNode>(Op.getOperand(1))->getVT();
  918   EVT ValTy = Op.getValueType();
  954   EVT VT = Op.getValueType();
  975   EVT VT = Op.getValueType();
  997   EVT VT = Op.getValueType();
 1052   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 1067   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 1075       GlobalAddressSDNode *GA, SDValue Glue, EVT PtrVT, unsigned ReturnReg,
 1841   return isTruncateFree(EVT::getEVT(Ty1), EVT::getEVT(Ty2));
 1841   return isTruncateFree(EVT::getEVT(Ty1), EVT::getEVT(Ty2));
 1844 bool HexagonTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 1844 bool HexagonTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 1850 bool HexagonTargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
 1855 bool HexagonTargetLowering::shouldExpandBuildVectorWithShuffles(EVT VT,
 1861                                                EVT VT) const {
 2787   EVT CarryTy = C.getValueType();
 2967   EVT VT = Table.getValueType();
 3053 bool HexagonTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
 3176 EVT HexagonTargetLowering::getOptimalMemOpType(uint64_t Size,
 3195     EVT VT, unsigned AS, unsigned Align, MachineMemOperand::Flags Flags,
 3221       ISD::LoadExtType ExtTy, EVT NewVT) const {

lib/Target/Hexagon/HexagonISelLowering.h

  126     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  126     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  140     bool isFMAFasterThanFMulAndFAdd(EVT) const override;
  143     bool shouldExpandBuildVectorWithShuffles(EVT VT,
  146     bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override;
  198         GlobalAddressSDNode *GA, SDValue InFlag, EVT PtrVT,
  232     Register getRegisterByName(const char* RegName, EVT VT,
  253     EVT getSetCCResultType(const DataLayout &, LLVMContext &C,
  254                            EVT VT) const override {
  258         return EVT::getVectorVT(C, MVT::i1, VT.getVectorNumElements());
  294     bool isFPImmLegal(const APFloat &Imm, EVT VT,
  303     EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
  307     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
  316                                EVT NewVT) const override;

lib/Target/Hexagon/HexagonISelLoweringHVX.cpp

 1068         EVT NTy = getTypeToTransformTo(*DAG.getContext(), Ty);

lib/Target/Hexagon/HexagonInstrInfo.cpp

 2637 bool HexagonInstrInfo::isValidAutoIncImm(const EVT VT, int Offset) const {

lib/Target/Hexagon/HexagonInstrInfo.h

  401   bool isValidAutoIncImm(const EVT VT, const int Offset) const;

lib/Target/Hexagon/HexagonTargetTransformInfo.cpp

   53   EVT VecVT = EVT::getEVT(VecTy);
   53   EVT VecVT = EVT::getEVT(VecTy);

lib/Target/Lanai/LanaiISelDAGToDAG.cpp

  283   EVT VT = Node->getValueType(0);
  319   EVT VT = Node->getValueType(0);

lib/Target/Lanai/LanaiISelLowering.cpp

  216   const char *RegName, EVT /*VT*/,
  460       EVT RegVT = VA.getLocVT();
  884   EVT VT = Op->getValueType(0);
 1058   EVT VT = Op.getValueType();
 1080   EVT VT = Op.getValueType();
 1237   EVT VT = Op.getValueType();
 1377     EVT VT = N->getValueType(0);
 1387     EVT VT = N->getValueType(0);
 1422   EVT VT = N->getValueType(0);

lib/Target/Lanai/LanaiISelLowering.h

   93   Register getRegisterByName(const char *RegName, EVT VT,

lib/Target/MSP430/MSP430ISelDAGToDAG.cpp

  306   EVT VT = LD->getMemoryVT();

lib/Target/MSP430/MSP430ISelLowering.cpp

  356 unsigned MSP430TargetLowering::getShiftAmountThreshold(EVT VT) const {
  627       EVT RegVT = VA.getLocVT();
  947   EVT VT = Op.getValueType();
 1184   EVT VT = Op.getValueType();
 1225   EVT VT      = Op.getValueType();
 1285   EVT VT = Op.getValueType();
 1333   EVT VT = LD->getMemoryVT();
 1384 bool MSP430TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 1384 bool MSP430TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
 1396 bool MSP430TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
 1396 bool MSP430TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
 1401 bool MSP430TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {

lib/Target/MSP430/MSP430ISelLowering.h

   78     MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  113     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  113     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  124     bool isZExtFree(EVT VT1, EVT VT2) const override;
  124     bool isZExtFree(EVT VT1, EVT VT2) const override;
  125     bool isZExtFree(SDValue Val, EVT VT2) const override;
  127     unsigned getShiftAmountThreshold(EVT VT) const override;

lib/Target/Mips/Mips16ISelDAGToDAG.cpp

   45 Mips16DAGToDAGISel::selectMULT(SDNode *N, unsigned Opc, const SDLoc &DL, EVT Ty,
  101   EVT ValTy = Addr.getValueType();
  187   EVT NodeTy = Node->getValueType(0);

lib/Target/Mips/Mips16ISelDAGToDAG.h

   27                                            const SDLoc &DL, EVT Ty, bool HasLo,

lib/Target/Mips/Mips16ISelLowering.cpp

  159     EVT VT, unsigned, unsigned, MachineMemOperand::Flags, bool *Fast) const {

lib/Target/Mips/Mips16ISelLowering.h

   24     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,

lib/Target/Mips/MipsCCState.cpp

   54 static bool originalEVTTypeIsVectorFloat(EVT Ty) {

lib/Target/Mips/MipsCallLowering.cpp

   28                                            const EVT &VT) {
   42                                                 const EVT &VT) {
   66     EVT VT = TLI.getValueType(DL, Args[ArgsIndex].Ty);
   97                         const EVT &VT) override;
  106                    Register ArgsReg, const EVT &VT) override;
  138                                             const EVT &VT) {
  216                                        Register ArgsReg, const EVT &VT) {
  233                         const EVT &VT) override;
  242                    Register ArgsReg, const EVT &VT) override;
  252                                             const EVT &VT) {
  352                                        Register ArgsReg, const EVT &VT) {
  383 static CCValAssign::LocInfo determineLocInfo(const MVT RegisterVT, const EVT VT,
  681     EVT VT = TLI.getValueType(DL, Arg.Ty);
  707   SmallVector<EVT, 4> SplitEVTs;

lib/Target/Mips/MipsCallLowering.h

   38                      unsigned ArgLocsStartIndex, const EVT &VT);
   46     bool assign(Register VReg, const CCValAssign &VA, const EVT &VT);
   52                                   const EVT &VT) = 0;
   60                              const EVT &VT) = 0;

lib/Target/Mips/MipsFastISel.cpp

  448   EVT CEVT = TLI.getValueType(DL, C->getType(), true);
  597   EVT evt = TLI.getValueType(DL, Ty, true);
 1000   EVT SrcVT = TLI.getValueType(DL, Src->getType(), true);
 1001   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1079   EVT SrcVT = TLI.getValueType(DL, Src->getType(), true);
 1080   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1366     EVT ArgVT = TLI.getValueType(DL, ArgTy);
 1736     EVT RVEVT = TLI.getValueType(DL, RV->getType());
 1785   EVT SrcVT, DestVT;
 1814   EVT SrcEVT, DestEVT;
 1919   EVT DestEVT = TLI.getValueType(DL, I->getType(), true);

lib/Target/Mips/MipsISelDAGToDAG.cpp

  226   EVT VT = Node->getValueType(0);

lib/Target/Mips/MipsISelLowering.cpp

  113                                                       EVT VT) const {
  126                                                            EVT VT) const {
  134     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  134     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  146 SDValue MipsTargetLowering::getGlobalReg(SelectionDAG &DAG, EVT Ty) const {
  151 SDValue MipsTargetLowering::getTargetNode(GlobalAddressSDNode *N, EVT Ty,
  157 SDValue MipsTargetLowering::getTargetNode(ExternalSymbolSDNode *N, EVT Ty,
  163 SDValue MipsTargetLowering::getTargetNode(BlockAddressSDNode *N, EVT Ty,
  169 SDValue MipsTargetLowering::getTargetNode(JumpTableSDNode *N, EVT Ty,
  175 SDValue MipsTargetLowering::getTargetNode(ConstantPoolSDNode *N, EVT Ty,
  560 EVT MipsTargetLowering::getSetCCResultType(const DataLayout &, LLVMContext &,
  561                                            EVT VT) const {
  573   EVT Ty = N->getValueType(0);
  689   EVT FalseTy = False.getValueType();
  791   EVT ValTy = N->getValueType(0);
  907     EVT ValTy = N->getValueType(0);
  939       EVT ValTy = N->getOperand(0)->getValueType(0);
 1045   EVT VTs[2] = {MVT::i32, MVT::i32};
 1094   EVT ValTy = N->getValueType(0);
 1115   EVT ValTy = N->getValueType(0);
 1955   EVT Ty = Op.getValueType();
 2003   EVT Ty = Op.getValueType();
 2025   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2098   EVT Ty = Op.getValueType();
 2111   EVT Ty = Op.getValueType();
 2147   EVT VT = Node->getValueType(0);
 2205   EVT TyX = Op.getOperand(0).getValueType();
 2206   EVT TyY = Op.getOperand(1).getValueType();
 2254   EVT TyX = MVT::getIntegerVT(WidthX), TyY = MVT::getIntegerVT(WidthY);
 2384   EVT VT = Op.getValueType();
 2428   EVT Ty = ABI.IsN64() ? MVT::i64 : MVT::i32;
 2537   EVT VT = LD->getValueType(0), MemVT = LD->getMemoryVT();
 2538   EVT BasePtrVT = Ptr.getValueType();
 2554   EVT MemVT = LD->getMemoryVT();
 2565   EVT VT = Op.getValueType();
 2619   EVT MemVT = SD->getMemoryVT(), BasePtrVT = Ptr.getValueType();
 2636   EVT VT = Value.getValueType();
 2670   EVT FPTy = EVT::getFloatingPointVT(Val.getValueSizeInBits());
 2670   EVT FPTy = EVT::getFloatingPointVT(Val.getValueSizeInBits());
 2680   EVT MemVT = SD->getMemoryVT();
 2697   EVT ValTy = Op->getValueType(0);
 2707   EVT FPTy = EVT::getFloatingPointVT(Op.getValueSizeInBits());
 2707   EVT FPTy = EVT::getFloatingPointVT(Op.getValueSizeInBits());
 2923     EVT Ty = ABI.IsN64() ? MVT::i64 : MVT::i32;
 3232   EVT Ty = Callee.getValueType();
 3405                                       EVT ArgVT, const SDLoc &DL,
 3408   EVT ValVT = VA.getValVT();
 3502     EVT ValVT = VA.getValVT();
 3629 MipsTargetLowering::shouldSignExtendTypeInLibCall(EVT Type, bool IsSigned) const {
 3868 EVT MipsTargetLowering::getTypeForExtReturn(LLVMContext &Context, EVT VT,
 3868 EVT MipsTargetLowering::getTypeForExtReturn(LLVMContext &Context, EVT VT,
 3871   EVT MinVT = getRegisterType(Context, Cond ? MVT::i64 : MVT::i32);
 4036       EVT Type = Op.getValueType();
 4046       EVT Type = Op.getValueType();
 4056       EVT Type = Op.getValueType();
 4066       EVT Type = Op.getValueType();
 4076       EVT Type = Op.getValueType();
 4086       EVT Type = Op.getValueType();
 4096       EVT Type = Op.getValueType();
 4141 EVT MipsTargetLowering::getOptimalMemOpType(
 4151 bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
 4196   EVT PtrTy = getPointerTy(DAG.getDataLayout());
 4237   EVT PtrTy = getPointerTy(DAG.getDataLayout()),
 4569 Register MipsTargetLowering::getRegisterByName(const char* RegName, EVT VT,

lib/Target/Mips/MipsISelLowering.h

  278     MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  282     EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
  282     EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
  293                                       EVT VT) const override;
  299                                            EVT VT) const override;
  303         LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  303         LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
  337     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  338                            EVT VT) const override;
  351     Register getRegisterByName(const char* RegName, EVT VT,
  385     SDValue getGlobalReg(SelectionDAG &DAG, EVT Ty) const;
  392     SDValue getAddrLocal(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG,
  411     SDValue getAddrGlobal(NodeTy *N, const SDLoc &DL, EVT Ty, SelectionDAG &DAG,
  424     SDValue getAddrGlobalLargeGOT(NodeTy *N, const SDLoc &DL, EVT Ty,
  443     SDValue getAddrNonPIC(NodeTy *N, const SDLoc &DL, EVT Ty,
  460    SDValue getAddrNonPICSym64(NodeTy *N, const SDLoc &DL, EVT Ty,
  487     SDValue getAddrGPRel(NodeTy *N, const SDLoc &DL, EVT Ty,
  517     SDValue getTargetNode(GlobalAddressSDNode *N, EVT Ty, SelectionDAG &DAG,
  521     SDValue getTargetNode(ExternalSymbolSDNode *N, EVT Ty, SelectionDAG &DAG,
  525     SDValue getTargetNode(BlockAddressSDNode *N, EVT Ty, SelectionDAG &DAG,
  529     SDValue getTargetNode(JumpTableSDNode *N, EVT Ty, SelectionDAG &DAG,
  533     SDValue getTargetNode(ConstantPoolSDNode *N, EVT Ty, SelectionDAG &DAG,
  627     bool shouldSignExtendTypeInLibCall(EVT Type, bool IsSigned) const override;
  672     EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
  681     bool isFPImmLegal(const APFloat &Imm, EVT VT,

lib/Target/Mips/MipsSEISelDAGToDAG.cpp

  209   EVT VT = LHS.getValueType();
  269     EVT ValTy = Addr.getValueType();
  285       EVT ValTy = Addr.getValueType();
  552   EVT EltTy = N->getValueType(0).getVectorElementType();
  628   EVT EltTy = N->getValueType(0).getVectorElementType();
  659   EVT EltTy = N->getValueType(0).getVectorElementType();
  693   EVT EltTy = N->getValueType(0).getVectorElementType();
  715   EVT EltTy = N->getValueType(0).getVectorElementType();
  754     EVT NodeTys[] = {VT, VT};
  943     EVT PtrVT = getTargetLowering()->getPointerTy(CurDAG->getDataLayout());
  986     EVT ResVecTy = BVN->getValueType(0);
  987     EVT ViaVecTy;

lib/Target/Mips/MipsSEISelDAGToDAG.h

   40                                            const SDLoc &dl, EVT Ty, bool HasLo,

lib/Target/Mips/MipsSEISelLowering.cpp

  412   EVT ResTy = Op->getValueType(0);
  424     EVT VT, unsigned, unsigned, MachineMemOperand::Flags, bool *Fast) const {
  508     EVT ExtendTy = cast<VTSDNode>(Op0Op2)->getVT();
  602   EVT Ty = N->getValueType(0);
  716 static bool shouldTransformMulToShiftsAddsSubs(APInt C, EVT VT,
  792 static SDValue genConstMult(SDValue X, APInt C, const SDLoc &DL, EVT VT,
  793                             EVT ShiftTy, SelectionDAG &DAG) {
  832   EVT VT = N->getValueType(0);
  844 static SDValue performDSPShiftCombine(unsigned Opc, SDNode *N, EVT Ty,
  872   EVT Ty = N->getValueType(0);
  895   EVT Ty = N->getValueType(0);
  916       EVT ExtendTy = cast<VTSDNode>(Op0Op0->getOperand(2))->getVT();
  941   EVT Ty = N->getValueType(0);
  949 static bool isLegalDSPCondCode(EVT Ty, ISD::CondCode CC) {
  968   EVT Ty = N->getValueType(0);
  981   EVT Ty = N->getValueType(0);
  999   EVT Ty = N->getValueType(0);
 1182   EVT PtrVT = Ptr.getValueType();
 1211   EVT PtrVT = Ptr.getValueType();
 1268   EVT Ty = Op.getOperand(0).getValueType();
 1342   SmallVector<EVT, 2> ResTys;
 1365   EVT ResTy = Op->getValueType(0);
 1366   EVT EltTy = Vec->getValueType(0).getVectorElementType();
 1375   EVT ResVecTy = Op->getValueType(0);
 1376   EVT ViaVecTy = ResVecTy;
 1427 static SDValue getBuildVectorSplat(EVT VecTy, SDValue SplatValue,
 1429   EVT ViaVecTy = VecTy;
 1466   EVT VecTy = Op->getValueType(0);
 1509   EVT ResTy = Op->getValueType(0);
 1521   EVT ResTy = Op->getValueType(0);
 1532   EVT ResTy = Op->getValueType(0);
 1612     EVT VecTy = Op->getValueType(0);
 1613     EVT EltTy = VecTy.getVectorElementType();
 1627     EVT VecTy = Op->getValueType(0);
 1628     EVT EltTy = VecTy.getVectorElementType();
 1655     EVT VecTy = Op->getValueType(0);
 1691     EVT VecTy = Op->getValueType(0);
 1881     EVT ResTy = Op->getValueType(0);
 1892     EVT ResTy = Op->getValueType(0);
 1991     EVT ResTy = Op->getValueType(0);
 2000     EVT ResTy = Op->getValueType(0);
 2075     EVT ResTy = Op->getValueType(0);
 2287     EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2299   EVT ResTy = Op->getValueType(0);
 2300   EVT PtrTy = Address->getValueType(0);
 2374   EVT PtrTy = Address->getValueType(0);
 2412   EVT ResTy = Op->getValueType(0);
 2414   EVT VecTy = Op0->getValueType(0);
 2421     EVT EltTy = VecTy.getVectorElementType();
 2462   EVT ResTy = Op->getValueType(0);
 2485     EVT ViaVecTy;
 2518     EVT ResTy = Node->getValueType(0);
 2553 static SDValue lowerVECTOR_SHUFFLE_SHF(SDValue Op, EVT ResTy,
 2634 static bool isVECTOR_SHUFFLE_SPLATI(SDValue Op, EVT ResTy,
 2666 static SDValue lowerVECTOR_SHUFFLE_ILVEV(SDValue Op, EVT ResTy,
 2712 static SDValue lowerVECTOR_SHUFFLE_ILVOD(SDValue Op, EVT ResTy,
 2759 static SDValue lowerVECTOR_SHUFFLE_ILVR(SDValue Op, EVT ResTy,
 2806 static SDValue lowerVECTOR_SHUFFLE_ILVL(SDValue Op, EVT ResTy,
 2854 static SDValue lowerVECTOR_SHUFFLE_PCKEV(SDValue Op, EVT ResTy,
 2897 static SDValue lowerVECTOR_SHUFFLE_PCKOD(SDValue Op, EVT ResTy,
 2933 static SDValue lowerVECTOR_SHUFFLE_VSHF(SDValue Op, EVT ResTy,
 2939   EVT MaskVecTy = ResTy.changeVectorElementTypeToInteger();
 2940   EVT MaskEltTy = MaskVecTy.getVectorElementType();
 2987   EVT ResTy = Op->getValueType(0);

lib/Target/Mips/MipsSEISelLowering.h

   44         EVT VT, unsigned AS = 0, unsigned Align = 1,
   56     bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override {

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

  374     SmallVector<EVT, 16> vtparts;
  379       EVT elemtype = vtparts[i];
 1586       SmallVector<EVT, 16> vtparts;
 1590         EVT elemtype = vtparts[i];

lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp

  843   EVT LoadedVT = LD->getMemoryVT();
 1000   EVT LoadedVT = MemSD->getMemoryVT();
 1059   EVT EltVT = N->getValueType(0);
 1267   EVT EltVT = Mem->getMemoryVT();
 1283   EVT NodeVT = (EltVT == MVT::i8) ? MVT::i16 : EltVT;
 1284   SmallVector<EVT, 5> InstVTs;
 1674   EVT OrigType = N->getValueType(0);
 1710   EVT StoreVT = ST->getMemoryVT();
 1877   EVT EltVT = Op1.getValueType();
 1879   EVT StoreVT = MemSD->getMemoryVT();
 2116   EVT EltVT = Node->getValueType(0);
 2117   EVT MemVT = Mem->getMemoryVT();
 2156     EVT EVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other, MVT::Glue };

lib/Target/NVPTX/NVPTXISelLowering.cpp

  163                                Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
  166   SmallVector<EVT, 16> TempVTs;
  196     EVT VT = TempVTs[i];
  202       EVT EltVT = VT.getVectorElementType();
  234     unsigned Idx, uint32_t AccessSize, const SmallVectorImpl<EVT> &ValueVTs,
  245   EVT EltVT = ValueVTs[Idx];
 1212   EVT VT = Operand.getValueType();
 1327         SmallVector<EVT, 16> vtparts;
 1460     EVT VT = Outs[OIdx].VT;
 1464       SmallVector<EVT, 16> VTs;
 1517         EVT EltVT = VTs[j];
 1555           EVT TheStoreType = ExtendIntegerParam ? MVT::i32 : VTs[j];
 1578     SmallVector<EVT, 16> VTs;
 1604       EVT elemtype = VTs[j];
 1635     SmallVector<EVT, 16> resvtparts;
 1765     SmallVector<EVT, 16> VTs;
 1773     SmallVector<EVT, 6> LoadVTs;
 1784       EVT TheLoadType = VTs[i];
 1785       EVT EltType = Ins[i].VT;
 1896     EVT VVT = SubOp.getNode()->getValueType(0);
 1897     EVT EltVT = VVT.getVectorElementType();
 1943   EVT VectorVT = Vector.getValueType();
 1945   EVT EltVT = VectorVT.getVectorElementType();
 1966   EVT VT = Op.getValueType();
 2027   EVT VT = Op.getValueType();
 2078   EVT VT = Op.getValueType();
 2100   EVT VT = Op.getValueType();
 2119   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 2141   EVT VT = Op.getValueType();
 2151   EVT SetCCVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT);
 2232     EVT MemVT = Load->getMemoryVT();
 2268   EVT VT = Store->getMemoryVT();
 2291   EVT ValVT = Val.getValueType();
 2335     EVT EltVT = ValVT.getVectorElementType();
 2426 NVPTXTargetLowering::getParamSymbol(SelectionDAG &DAG, int idx, EVT v) const {
 2519         SmallVector<EVT, 16> vtparts;
 2533         EVT ObjectVT = getValueType(DL, Ty);
 2556       SmallVector<EVT, 16> VTs;
 2574           EVT EltVT = VTs[parti];
 2576           EVT LoadVT = EltVT;
 2585           EVT VecVT = EVT::getVectorVT(F->getContext(), LoadVT, NumElts);
 2585           EVT VecVT = EVT::getVectorVT(F->getContext(), LoadVT, NumElts);
 2635     EVT ObjectVT = getValueType(DL, Ty);
 2674   SmallVector<EVT, 16> VTs;
 2731       EVT TheStoreType = ExtendIntegerRetVal ? MVT::i32 : VTs[i];
 4348   EVT VT=N0.getValueType();
 4509     EVT MemVT = Mem->getMemoryVT();
 4550   EVT VT = N->getValueType(0);
 4586     EVT OrigVT = Op.getOperand(0).getValueType();
 4592     EVT OrigVT = Op.getOperand(0).getValueType();
 4644   EVT MulType = N->getValueType(0);
 4684   EVT DemotedVT;
 4736   EVT CCType = N->getValueType(0);
 4781   EVT ResVT = N->getValueType(0);
 4825   EVT EltVT = ResVT.getVectorElementType();
 4850     EVT ListVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other };
 4861     EVT ListVTs[] = {MVT::v2f16, MVT::v2f16, MVT::v2f16, MVT::v2f16,
 4926     EVT ResVT = N->getValueType(0);
 4932       EVT EltVT = ResVT.getVectorElementType();
 4982         EVT ListVTs[] = { EltVT, EltVT, EltVT, EltVT, MVT::Other };

lib/Target/NVPTX/NVPTXISelLowering.h

  471   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Ctx,
  472                          EVT VT) const override {
  474       return EVT::getVectorVT(Ctx, MVT::i1, VT.getVectorNumElements());
  509   MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  541   bool isFMAFasterThanFMulAndFAdd(EVT) const override { return true; }
  543   bool enableAggressiveFMAFusion(EVT VT) const override { return true; }
  553   SDValue getParamSymbol(SelectionDAG &DAG, int idx, EVT) const;

lib/Target/PowerPC/PPCFastISel.cpp

  275   EVT Evt = TLI.getValueType(DL, Ty, true);
  825   EVT SrcEVT = TLI.getValueType(DL, Ty, true);
  960   EVT SrcVT = TLI.getValueType(DL, Src->getType(), true);
  961   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
  978   EVT SrcVT = TLI.getValueType(DL, Src->getType(), true);
  979   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1074   EVT SrcEVT = TLI.getValueType(DL, Src->getType(), true);
 1270   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1747         EVT RVEVT = TLI.getValueType(DL, RV->getType());
 1875   EVT SrcVT = TLI.getValueType(DL, Src->getType(), true);
 1876   EVT DestVT = TLI.getValueType(DL, I->getType(), true);
 1906   EVT SrcEVT, DestEVT;
 2242   EVT CEVT = TLI.getValueType(DL, C->getType(), true);

lib/Target/PowerPC/PPCISelDAGToDAG.cpp

  637   EVT MemVT = ST->getMemoryVT();
  638   EVT RegVT = ST->getValue().getValueType();
  680   EVT MemVT = LD->getMemoryVT();
  681   EVT RegVT = LD->getValueType(0);
 1363       EVT FromType = V.getOperand(0).getValueType();
 1364       EVT ToType = V.getValueType();
 1397       EVT FromType = cast<VTSDNode>(V.getOperand(1))->getVT();
 1413         EVT VT = LD->getMemoryVT();
 2672      EVT InVT = InputOp.getValueType();
 2817   EVT InVT = LHS.getValueType();
 3594   EVT InputVT = LHS.getValueType();
 4010   EVT PtrVT =
 4107     EVT VecVT = LHS.getValueType();
 4114     EVT ResVT = VecVT.changeVectorElementTypeToInteger();
 4474     EVT LoadedVT = LD->getMemoryVT();
 4605            auto ResultType = Val.getNode()->getValueType(0);
 4789     EVT InVT = N->getOperand(0).getValueType();
 4809     EVT PtrVT =
 5133     EVT VT = isPPC64 ? MVT::i64 : MVT::i32;
 5172     EVT VT;
 5259   EVT VT = N->getValueType(0);
 5478   EVT VT = N->getValueType(0);
 6334       SmallVector<EVT, 2> NewVTs;

lib/Target/PowerPC/PPCISelLowering.cpp

 1296 bool PPCTargetLowering::preferIncOfAddToSubOfNot(EVT VT) const {
 1423 EVT PPCTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &C,
 1424                                           EVT VT) const {
 1429     return EVT::getVectorVT(C, MVT::i1, VT.getVectorNumElements());
 1434 bool PPCTargetLowering::enableAggressiveFMAFusion(EVT VT) const {
 2207   EVT VT = N->getValueType(0);
 2332 static void fixupFuncForFI(SelectionDAG &DAG, int FrameIdx, EVT VT) {
 2508   EVT MemVT = LD->getMemoryVT();
 2551   EVT VT;
 2665   EVT PtrVT = HiPart.getValueType();
 2693   EVT VT = Is64Bit ? MVT::i64 : MVT::i32;
 2707   EVT PtrVT = Op.getValueType();
 2784   EVT PtrVT = Op.getValueType();
 2812   EVT PtrVT = Op.getValueType();
 2850   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2937   EVT PtrVT = Op.getValueType();
 3019   EVT LHSVT = Op.getOperand(0).getValueType();
 3021     EVT VT = Op.getValueType();
 3031   EVT VT = Node->getValueType(0);
 3032   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3152   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3183   EVT PtrVT = getPointerTy(MF.getDataLayout());
 3277 static unsigned CalculateStackSlotSize(EVT ArgVT, ISD::ArgFlagsTy Flags,
 3293 static unsigned CalculateStackSlotAlignment(EVT ArgVT, EVT OrigVT,
 3293 static unsigned CalculateStackSlotAlignment(EVT ArgVT, EVT OrigVT,
 3339 static bool CalculateStackSlotUsed(EVT ArgVT, EVT OrigVT,
 3339 static bool CalculateStackSlotUsed(EVT ArgVT, EVT OrigVT,
 3457   EVT PtrVT = getPointerTy(MF.getDataLayout());
 3483       EVT ValVT = VA.getValVT();
 3677                                              EVT ObjectVT, SelectionDAG &DAG,
 3705   EVT PtrVT = getPointerTy(MF.getDataLayout());
 3761     EVT ObjectVT = Ins[ArgNo].VT;
 3762     EVT OrigVT = Ins[ArgNo].ArgVT;
 3846             EVT ObjType = (ObjSize == 1 ? MVT::i8 :
 4112   EVT PtrVT = getPointerTy(MF.getDataLayout());
 4155       EVT ObjectVT = Ins[ArgNo].VT;
 4205     EVT ObjectVT = Ins[ArgNo].VT;
 4255           EVT ObjType = ObjSize == 1 ? MVT::i8 : MVT::i16;
 4806     EVT VT = isPPC64 ? MVT::i64 : MVT::i32;
 4835   EVT VT = isPPC64 ? MVT::i64 : MVT::i32;
 4852     EVT VT = Subtarget.isPPC64() ? MVT::i64 : MVT::i32;
 4890   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
 4951             SmallVectorImpl<SDValue> &Ops, std::vector<EVT> &NodeTys,
 4958   EVT PtrVT = DAG.getTargetLoweringInfo().getPointerTy(DAG.getDataLayout());
 5224   std::vector<EVT> NodeTys;
 5275   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 5678   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 5753     EVT ArgVT = Outs[i].VT;
 5754     EVT OrigVT = Outs[i].ArgVT;
 5877     EVT ArgVT = Outs[i].VT;
 5878     EVT OrigVT = Outs[i].ArgVT;
 5934         EVT VT = (Size==1) ? MVT::i8 : ((Size==2) ? MVT::i16 : MVT::i32);
 6335   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 6365     EVT ArgVT = Outs[i].VT;
 6484         EVT VT = (Size==1) ? MVT::i8 : MVT::i16;
 6660       EVT ArgType = Outs[i].VT;
 6976   EVT IntVT = Op.getValueType();
 6993   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 7018   EVT PtrVT = getPointerTy(MF.getDataLayout());
 7041   EVT PtrVT = getPointerTy(MF.getDataLayout());
 7068   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 7085   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 7193   EVT TrgVT = Op.getValueType();
 7195   EVT EltVT = TrgVT.getVectorElementType();
 7197   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
 7197   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
 7237   EVT ResVT = Op.getValueType();
 7238   EVT CmpVT = Op.getOperand(0).getValueType();
 7505 bool PPCTargetLowering::canReuseLoadAddress(SDValue Op, EVT MemVT,
 7632   EVT VecVT = Vec.getValueType();
 7636   EVT EltVT = VecVT.getVectorElementType();
 7638   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
 7638   EVT WideVT = EVT::getVectorVT(*DAG.getContext(), EltVT, WideNumElts);
 7663   EVT WideVT = Wide.getValueType();
 7701   EVT InVT = Op.getOperand(0).getValueType();
 7702   EVT OutVT = Op.getValueType();
 7843       EVT PtrVT = getPointerTy(DAG.getDataLayout());
 7889   EVT PtrVT = getPointerTy(MF.getDataLayout());
 7977   EVT VT = Op.getValueType();
 7978   EVT PtrVT = getPointerTy(MF.getDataLayout());
 7981   EVT NodeTys[] = {
 8018   EVT VT = Op.getValueType();
 8030   EVT AmtVT = Amt.getValueType();
 8047   EVT VT = Op.getValueType();
 8059   EVT AmtVT = Amt.getValueType();
 8077   EVT VT = Op.getValueType();
 8087   EVT AmtVT = Amt.getValueType();
 8110 static SDValue BuildSplatI(int Val, unsigned SplatSize, EVT VT,
 8118   EVT ReqVT = VT != MVT::Other ? VT : VTys[SplatSize-1];
 8124   EVT CanonicalVT = VTys[SplatSize-1];
 8133                                 const SDLoc &dl, EVT DestVT = MVT::Other) {
 8143                                 EVT DestVT = MVT::Other) {
 8153                                 EVT DestVT = MVT::Other) {
 8161 static SDValue BuildVSLDOI(SDValue LHS, SDValue RHS, unsigned Amt, EVT VT,
 8189   EVT VecVT = V->getValueType(0);
 8275     EVT PtrVT = getPointerTy(DAG.getDataLayout());
 8477     EVT VT = (SplatSize == 1 ? MVT::v16i8 :
 8656   EVT VT = OpLHS.getValueType();
 8886   EVT VT = Op.getValueType();
 9168   EVT EltVT = V1.getValueType().getVectorElementType();
 9477   EVT VTs[] = { Op.getOperand(2).getValueType(), MVT::Glue };
 9578   EVT MemVT = AtomicNode->getMemoryVT();
 9612   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 9632   EVT VT = Op.getValueType();
 9684   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 9720     EVT MemVT = LN->getMemoryVT();
 9727     EVT ScalarVT = Op.getValueType().getScalarType(),
 9809     EVT MemVT = SN->getMemoryVT();
 9816     EVT ScalarVT = Value.getValueType().getScalarType(),
 9884   EVT PtrVT = getPointerTy(DAG.getDataLayout());
10000   EVT VT = Op.getValueType();
10209     EVT SVT = getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
10223     EVT VT = N->getValueType(0);
10241     EVT TrgVT = N->getValueType(0);
10242     EVT OpVT = N->getOperand(0).getValueType();
11634 static int getEstimateRefinementSteps(EVT VT, const PPCSubtarget &Subtarget) {
11649   EVT VT = Operand.getValueType();
11670   EVT VT = Operand.getValueType();
11721 static bool isConsecutiveLSLoc(SDValue Loc, EVT VT, LSBaseSDNode *Base,
11765     EVT VT = LS->getMemoryVT();
11771     EVT VT;
11817     EVT VT;
11876   EVT VT = LD->getMemoryVT();
12371   DenseMap<SDNode *, EVT> SelectTruncOp[2];
12570   EVT ShiftAmountTy = getShiftAmountTy(N->getValueType(0), DAG.getDataLayout());
12600       EVT VT = N->getValueType(0);
12601       EVT OpVT = LHS.getValueType();
12648     EVT SrcVT = FirstInput.getOperand(0).getValueType();
12650     EVT TargetVT = N->getValueType(0);
12699     EVT NewVT = TargetVT == MVT::v2i64 ? MVT::v2f64 : MVT::v4f32;
12826   EVT Ty = N->getValueType(0);
13263   EVT Op1VT = N->getOperand(1).getValueType();
13264   EVT ResVT = Val.getValueType();
13330   EVT VT = SVN->getValueType(0);
13418     EVT Op1VT = N->getOperand(1).getValueType();
13442       EVT mVT = cast<StoreSDNode>(N)->getMemoryVT();
13476       EVT MemVT = cast<StoreSDNode>(N)->getMemoryVT();
13503     EVT VT = LD->getValueType(0);
13620     EVT MemVT = LD->getMemoryVT();
14054       EVT VTs[] = { LHS.getOperand(2).getValueType(), MVT::Glue };
14098   EVT VT = N->getValueType(0);
14416     EVT TCVT = MVT::i64; // All constants taken to be 64 bits so that negative
14549   EVT PtrVT = getPointerTy(MF.getDataLayout());
14570 Register PPCTargetLowering::getRegisterByName(const char* RegName, EVT VT,
14642     EVT VT;
14688     EVT VT;
14728     EVT VT;
14773     EVT VT;
14819 EVT PPCTargetLowering::getOptimalMemOpType(
14865 bool PPCTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
14865 bool PPCTargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
14873 bool PPCTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
14877     EVT MemVT = LD->getMemoryVT();
14893 bool PPCTargetLowering::isFPExtFree(EVT DestVT, EVT SrcVT) const {
14893 bool PPCTargetLowering::isFPExtFree(EVT DestVT, EVT SrcVT) const {
14910 bool PPCTargetLowering::allowsMisalignedMemoryAccesses(EVT VT,
14946 bool PPCTargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
14990                      EVT VT , unsigned DefinedValues) const {
15081 bool PPCTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
15104   EVT VT = N0.getValueType();
15359   EVT VT = N->getValueType(0);
15440 bool PPCTargetLowering::hasBitPreservingFPLogic(EVT VT) const {
15475   EVT VT = N->getValueType(0);
15525   EVT VT = N->getOperand(1).getValueType();

lib/Target/PowerPC/PPCISelLowering.h

  637     MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  657     bool preferIncOfAddToSubOfNot(EVT VT) const override;
  659     bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
  676     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  677                            EVT VT) const override;
  682     bool enableAggressiveFMAFusion(EVT VT) const override;
  739     Register getRegisterByName(const char* RegName, EVT VT,
  842     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  842     bool isTruncateFree(EVT VT1, EVT VT2) const override;
  844     bool isZExtFree(SDValue Val, EVT VT2) const override;
  846     bool isFPExtFree(EVT DestVT, EVT SrcVT) const override;
  846     bool isFPExtFree(EVT DestVT, EVT SrcVT) const override;
  853     bool convertSelectOfConstantsToMath(EVT VT) const override {
  858                                            EVT VT) const override {
  890     EVT
  898         EVT VT, unsigned AddrSpace, unsigned Align = 1,
  906     bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
  912     shouldExpandBuildVectorWithShuffles(EVT VT,
  948     bool isFPImmLegal(const APFloat &Imm, EVT VT,
  988     bool canReuseLoadAddress(SDValue Op, EVT MemVT, ReuseLoadInfo &RLI,
 1115     SDValue extendArgForPPC64(ISD::ArgFlagsTy Flags, EVT ObjectVT,
 1226     bool hasBitPreservingFPLogic(EVT VT) const override;

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

  415           EVT EVTy =

lib/Target/RISCV/RISCVISelDAGToDAG.cpp

  111   EVT VT = Node->getValueType(0);

lib/Target/RISCV/RISCVISelLowering.cpp

  217 EVT RISCVTargetLowering::getSetCCResultType(const DataLayout &DL, LLVMContext &,
  218                                             EVT VT) const {
  297 bool RISCVTargetLowering::isTruncateFree(EVT SrcVT, EVT DstVT) const {
  297 bool RISCVTargetLowering::isTruncateFree(EVT SrcVT, EVT DstVT) const {
  306 bool RISCVTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
  309     EVT MemVT = LD->getMemoryVT();
  320 bool RISCVTargetLowering::isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const {
  320 bool RISCVTargetLowering::isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const {
  324 bool RISCVTargetLowering::hasBitPreservingFPLogic(EVT VT) const {
  409 static SDValue getTargetNode(GlobalAddressSDNode *N, SDLoc DL, EVT Ty,
  414 static SDValue getTargetNode(BlockAddressSDNode *N, SDLoc DL, EVT Ty,
  420 static SDValue getTargetNode(ConstantPoolSDNode *N, SDLoc DL, EVT Ty,
  430   EVT Ty = getPointerTy(DAG.getDataLayout());
  470   EVT Ty = Op.getValueType();
  507   EVT Ty = getPointerTy(DAG.getDataLayout());
  547   EVT Ty = getPointerTy(DAG.getDataLayout());
  579   EVT Ty = Op.getValueType();
  677   EVT VT = Op.getValueType();
  703   EVT VT = Op.getValueType();
  727   EVT VT = Lo.getValueType();
  766   EVT VT = Lo.getValueType();
 1030   EVT Ty = N0.getValueType();
 1691   EVT LocVT = VA.getLocVT();
 1722   EVT LocVT = VA.getLocVT();
 1746   EVT LocVT = VA.getLocVT();
 1747   EVT ValVT = VA.getValVT();
 1748   EVT PtrVT = MVT::getIntegerVT(DAG.getDataLayout().getPointerSizeInBits(0));
 1894   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2099   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2888 bool RISCVTargetLowering::shouldExtendTypeInLibCall(EVT Type) const {

lib/Target/RISCV/RISCVISelLowering.h

   74   bool isTruncateFree(EVT SrcVT, EVT DstVT) const override;
   74   bool isTruncateFree(EVT SrcVT, EVT DstVT) const override;
   75   bool isZExtFree(SDValue Val, EVT VT2) const override;
   76   bool isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const override;
   76   bool isSExtCheaperThanZExt(EVT SrcVT, EVT DstVT) const override;
   78   bool hasBitPreservingFPLogic(EVT VT) const override;
  111   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  112                          EVT VT) const override;
  114   bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
  148   bool shouldExtendTypeInLibCall(EVT Type) const override;

lib/Target/Sparc/SparcISelLowering.cpp

 1019 Register SparcTargetLowering::getRegisterByName(const char* RegName, EVT VT,
 1845 EVT SparcTargetLowering::getSetCCResultType(const DataLayout &, LLVMContext &,
 1846                                             EVT VT) const {
 1933   EVT VT = Op.getValueType();
 1943   EVT VT = getPointerTy(DAG.getDataLayout());
 2024   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2125   EVT ArgVT = Arg.getValueType();
 2334   EVT VT = Op.getValueType();
 2363   EVT OpVT = Op.getOperand(0).getValueType();
 2366   EVT floatVT = (OpVT == MVT::i32) ? MVT::f32 : MVT::f64;
 2391   EVT VT = Op.getValueType();
 2412   EVT OpVT = Op.getOperand(0).getValueType();
 2522   EVT VT = Node->getValueType(0);
 2525   EVT PtrVT = VAListPtr.getValueType();
 2549   EVT VT = Size->getValueType(0);
 2620   EVT VT = Op.getValueType();
 2666   EVT VT = Op.getValueType();
 2739   EVT addrVT = LdNode->getBasePtr().getValueType();
 2772   EVT MemVT = LdNode->getMemoryVT();
 2807   EVT addrVT = StNode->getBasePtr().getValueType();
 2821   EVT MemVT = St->getMemoryVT();
 2939   EVT VT = MVT::i64;
 2940   EVT WideVT = MVT::i128;
 2996     EVT PtrVT = getPointerTy(DAG.getDataLayout());

lib/Target/Sparc/SparcISelLowering.h

   97     MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  101     Register getRegisterByName(const char* RegName, EVT VT,
  123     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  124                            EVT VT) const override;
  192     bool ShouldShrinkFPConstant(EVT VT) const override {

lib/Target/SystemZ/SystemZCallingConv.h

   35   bool IsShortVectorType(EVT ArgVT) {

lib/Target/SystemZ/SystemZISelDAGToDAG.cpp

  158   void getAddressOperands(const SystemZAddressingMode &AM, EVT VT,
  160   void getAddressOperands(const SystemZAddressingMode &AM, EVT VT,
  284   SDValue getUNDEF(const SDLoc &DL, EVT VT) const;
  287   SDValue convertTo(const SDLoc &DL, EVT VT, SDValue N) const;
  624                                              EVT VT, SDValue &Base,
  649                                              EVT VT, SDValue &Base,
  935 SDValue SystemZDAGToDAGISel::getUNDEF(const SDLoc &DL, EVT VT) const {
  940 SDValue SystemZDAGToDAGISel::convertTo(const SDLoc &DL, EVT VT,
  953   EVT VT = N->getValueType(0);
 1023   EVT OpcodeVT = MVT::i64;
 1053   EVT VT = N->getValueType(0);
 1111   EVT VT = Node->getValueType(0);
 1150   EVT VT = Node->getValueType(0);
 1179   EVT VT = N->getValueType(0);
 1219   EVT VT = Vec.getValueType();
 1338   EVT MemVT = StoreNode->getMemoryVT();
 1573     EVT VT = Node->getValueType(0);
 1853   EVT VT = Node->getValueType(0);

lib/Target/SystemZ/SystemZISelLowering.cpp

   56 static bool is32Bit(EVT VT) {
  639 EVT SystemZTargetLowering::getSetCCResultType(const DataLayout &DL,
  640                                               LLVMContext &, EVT VT) const {
  646 bool SystemZTargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
  779 bool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
  799     EVT VT, unsigned, unsigned, MachineMemOperand::Flags, bool *Fast) const {
  939 bool SystemZTargetLowering::isTruncateFree(EVT FromVT, EVT ToVT) const {
  939 bool SystemZTargetLowering::isTruncateFree(EVT FromVT, EVT ToVT) const {
 1222 static void VerifyVectorType(MVT VT, EVT ArgVT) {
 1304   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 1320     EVT LocVT = VA.getLocVT();
 1472   EVT PtrVT = getPointerTy(MF.getDataLayout());
 2581 static void lowerGR128Binary(SelectionDAG &DAG, const SDLoc &DL, EVT VT,
 2659                                             const SDLoc &DL, EVT VT,
 2681                                                 const SDLoc &DL, EVT VT,
 2742   EVT VT = Op.getValueType();
 2826   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2864   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2909   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 2931   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3019   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3029   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3039   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3061   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3092   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3108   EVT InVT = In.getValueType();
 3109   EVT ResVT = Op.getValueType();
 3159   EVT PtrVT = getPointerTy(DAG.getDataLayout());
 3280   EVT VT = Op.getValueType();
 3328   EVT VT = Op.getValueType();
 3349   EVT VT = Op.getValueType();
 3369   EVT VT = Op.getValueType();
 3548   EVT VT = Op.getValueType();
 3673   EVT NarrowVT = Node->getMemoryVT();
 3674   EVT WideVT = MVT::i32;
 3684   EVT PtrVT = Addr.getValueType();
 3744   EVT MemVT = Node->getMemoryVT();
 3788   EVT NarrowVT = Node->getMemoryVT();
 3789   EVT WideVT = NarrowVT == MVT::i64 ? MVT::i64 : MVT::i32;
 3807   EVT PtrVT = Addr.getValueType();
 4151   EVT VT = ShuffleOp.getValueType();
 4288   GeneralShuffle(EVT vt) : VT(vt) {}
 4302   EVT VT;
 4325   EVT FromVT = Op.getNode() ? Op.getValueType() : VT;
 4467 static SDValue buildScalarToVector(SelectionDAG &DAG, const SDLoc &DL, EVT VT,
 4483 static SDValue buildMergeScalars(SelectionDAG &DAG, const SDLoc &DL, EVT VT,
 4522   EVT VT = BVN->getValueType(0);
 4579 SystemZTargetLowering::buildVector(SelectionDAG &DAG, const SDLoc &DL, EVT VT,
 4726   EVT VT = Op.getValueType();
 4756   EVT VT = Op.getValueType();
 4801   EVT VT = Op.getValueType();
 4832   EVT VT = Op.getValueType();
 4833   EVT VecVT = Op0.getValueType();
 4855   EVT OutVT = Op.getValueType();
 4856   EVT InVT = PackedOp.getValueType();
 4861     EVT OutVT = MVT::getVectorVT(MVT::getIntegerVT(FromBits),
 4874   EVT VT = Op.getValueType();
 5254 bool SystemZTargetLowering::canTreatAsByteVector(EVT VT) const {
 5266 SDValue SystemZTargetLowering::combineExtract(const SDLoc &DL, EVT ResVT,
 5267                                               EVT VecVT, SDValue Op,
 5308       EVT OpVT = Op.getValueType();
 5320         EVT VT = MVT::getIntegerVT(Op.getValueSizeInBits());
 5324       EVT VT = MVT::getIntegerVT(ResVT.getSizeInBits());
 5337       EVT ExtVT = Op.getValueType();
 5338       EVT OpVT = Op.getOperand(0).getValueType();
 5373     const SDLoc &DL, EVT TruncVT, SDValue Op, DAGCombinerInfo &DCI) const {
 5380     EVT VecVT = Vec.getValueType();
 5398           EVT ResVT = (TruncBytes < 4 ? MVT::i32 : TruncVT);
 5412   EVT VT = N->getValueType(0);
 5441   EVT VT = N->getValueType(0);
 5442   EVT EVT = cast<VTSDNode>(N->getOperand(1))->getVT();
 5462   EVT VT = N->getValueType(0);
 5471         EVT ShiftVT = N0.getOperand(1).getValueType();
 5499     EVT VT = Op1.getValueType();
 5504       EVT InVT = VT.changeVectorElementTypeToInteger();
 5505       EVT OutVT = MVT::getVectorVT(MVT::getIntegerVT(ElemBytes * 16),
 5522   EVT LdVT = N->getValueType(0);
 5559 bool SystemZTargetLowering::canLoadStoreByteSwapped(EVT VT) const {
 5568 static bool isVectorElementSwap(ArrayRef<int> M, EVT VT) {
 5589   EVT MemVT = SN->getMemoryVT();
 5702     EVT VecVT = Op.getValueType();
 5703     EVT EltVT = VecVT.getVectorElementType();
 5718     EVT VecVT = Op0.getValueType();
 5852       EVT LoadVT = N->getValueType(0);
 5898       EVT VecVT = N->getValueType(0);
 5899       EVT EltVT = N->getValueType(0).getVectorElementType();
 5927       EVT VecVT = N->getValueType(0);
 6134   EVT VT = N->getValueType(0);
 6187   EVT VT = Op.getValueType();
 6310   EVT VT = Op.getValueType();
 6402   EVT VT = Op.getValueType();
 6449       EVT VT = Op.getValueType();

lib/Target/SystemZ/SystemZISelLowering.h

  379   MVT getScalarShiftAmountTy(const DataLayout &, EVT) const override {
  405   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &,
  406                          EVT) const override;
  407   bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
  408   bool isFPImmLegal(const APFloat &Imm, EVT VT,
  415   bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AS,
  420   bool isTruncateFree(EVT, EVT) const override;
  420   bool isTruncateFree(EVT, EVT) const override;
  532                        const SDLoc &DL, EVT VT,
  535                            EVT VT, ISD::CondCode CC,
  580   SDValue buildVector(SelectionDAG &DAG, const SDLoc &DL, EVT VT,
  591   bool canTreatAsByteVector(EVT VT) const;
  592   SDValue combineExtract(const SDLoc &DL, EVT ElemVT, EVT VecVT, SDValue OrigOp,
  592   SDValue combineExtract(const SDLoc &DL, EVT ElemVT, EVT VecVT, SDValue OrigOp,
  595   SDValue combineTruncateExtract(const SDLoc &DL, EVT TruncVT, SDValue Op,
  601   bool canLoadStoreByteSwapped(EVT VT) const;

lib/Target/SystemZ/SystemZSelectionDAGInfo.cpp

   28   EVT PtrVT = Src.getValueType();
   79   EVT PtrVT = Dst.getValueType();
  148   EVT PtrVT = Src1.getValueType();
  198   EVT PtrVT = Src.getValueType();
  252   EVT PtrVT = Src.getValueType();
  264   EVT PtrVT = Src.getValueType();
  271   EVT PtrVT = Src.getValueType();

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  327   EVT VT = TLI->getValueType(DL, DataType);

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  118     EVT VT = TLI.getValueType(DL, Ty, /*AllowUnknown=*/true);
 1129   EVT VT = TLI.getValueType(DL, I->getOperand(0)->getType());
 1130   EVT RetVT = TLI.getValueType(DL, I->getType());

lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

  309                                                       EVT VT) const {
  531     EVT /*VT*/, unsigned /*AddrSpace*/, unsigned /*Align*/,
  544 bool WebAssemblyTargetLowering::isIntDivCheap(EVT VT,
  561 EVT WebAssemblyTargetLowering::getSetCCResultType(const DataLayout &DL,
  563                                                   EVT VT) const {
  747       EVT VT = Arg.getValueType();
  814   SmallVector<EVT, 8> InTys;
 1033     EVT VT = Src.getValueType();
 1083   EVT VT = Op.getValueType();
 1093   EVT VT = Op.getValueType();
 1139   EVT VT = Op.getValueType();
 1186   EVT PtrVT = getPointerTy(DAG.getMachineFunction().getDataLayout());
 1219     EVT VT = Op.getValueType();
 1293   const EVT VecT = Op.getValueType();
 1294   const EVT LaneT = Op.getOperand(0).getValueType();
 1488   EVT LaneT = Op.getSimpleValueType().getVectorElementType();

lib/Target/WebAssembly/WebAssemblyISelLowering.h

   49   MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override;
   62   bool allowsMisalignedMemoryAccesses(EVT, unsigned AddrSpace, unsigned Align,
   65   bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
   67   EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
   68                          EVT VT) const override;

lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp

   34   SmallVector<EVT, 4> VTs;
   37   for (EVT VT : VTs) {

lib/Target/X86/X86CallLowering.cpp

   61   SmallVector<EVT, 4> SplitVTs;
   69   EVT VT = SplitVTs[0];
   81   EVT PartVT = TLI.getRegisterType(Context, VT);
  202     SmallVector<EVT, 4> SplitEVTs;

lib/Target/X86/X86FastISel.cpp

   84   bool X86FastEmitCompare(const Value *LHS, const Value *RHS, EVT VT,
   90   bool X86FastEmitStore(EVT VT, const Value *Val, X86AddressMode &AM,
   92   bool X86FastEmitStore(EVT VT, unsigned ValReg, bool ValIsKill,
   96   bool X86FastEmitExtend(ISD::NodeType Opc, EVT DstVT, unsigned Src, EVT SrcVT,
   96   bool X86FastEmitExtend(ISD::NodeType Opc, EVT DstVT, unsigned Src, EVT SrcVT,
  159   bool isScalarFPTypeInSSEReg(EVT VT) const {
  292   EVT evt = TLI.getValueType(DL, Ty, /*AllowUnknown=*/true);
  482 bool X86FastISel::X86FastEmitStore(EVT VT, unsigned ValReg, bool ValIsKill,
  656 bool X86FastISel::X86FastEmitStore(EVT VT, const Value *Val,
  704 bool X86FastISel::X86FastEmitExtend(ISD::NodeType Opc, EVT DstVT,
  705                                     unsigned Src, EVT SrcVT,
 1221     EVT SrcVT = TLI.getValueType(DL, RV->getType());
 1222     EVT DstVT = VA.getValVT();
 1338 static unsigned X86ChooseCmpOpcode(EVT VT, const X86Subtarget *Subtarget) {
 1365 static unsigned X86ChooseCmpImmediateOpcode(EVT VT, const ConstantInt *RHSC) {
 1392 bool X86FastISel::X86FastEmitCompare(const Value *Op0, const Value *Op1, EVT VT,
 1520   EVT DstVT = TLI.getValueType(DL, I->getType());
 1579   EVT DstVT = TLI.getValueType(DL, I->getType());
 1637       EVT VT = TLI.getValueType(DL, CI->getOperand(0)->getType());
 2062     EVT CmpVT = TLI.getValueType(DL, CmpLHS->getType());
 2315     EVT CmpVT = TLI.getValueType(DL, CmpLHS->getType());
 2530   EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType());
 2531   EVT DstVT = TLI.getValueType(DL, I->getType());
 2769     EVT PtrTy = TLI.getPointerTy(DL);
 3094     EVT ArgVT = TLI.getValueType(DL, ArgTy);
 3554     EVT CopyVT = VA.getValVT();
 3581       EVT ResVT = VA.getValVT();
 3643     EVT SrcVT = TLI.getValueType(DL, I->getOperand(0)->getType());
 3644     EVT DstVT = TLI.getValueType(DL, I->getType());
 3848   EVT CEVT = TLI.getValueType(DL, C->getType(), true);

lib/Target/X86/X86ISelDAGToDAG.cpp

  544     EVT OpVT = N->getOperand(0).getValueType();
  916         EVT IntVT = EVT(VecVT).changeVectorElementTypeToInteger();
 2552   EVT VT = N.getValueType();
 2947   EVT MemVT = StoreNode->getMemoryVT();
 3636   EVT VT = N->getValueType(0);
 3674       EVT SubVT = ShiftAmt.getValueType();
 3845   EVT VT = Node->getValueType(0);

lib/Target/X86/X86ISelLowering.cpp

 1918   EVT PtrTy = getPointerTy(DAG.getDataLayout());
 1938                                                      EVT VT) const {
 1958                                                           EVT VT) const {
 1977     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
 1977     LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
 1995 EVT X86TargetLowering::getSetCCResultType(const DataLayout &DL,
 1997                                           EVT VT) const {
 2005     EVT LegalVT = VT;
 2011       return EVT::getVectorVT(Context, MVT::i1, NumElts);
 2019         return EVT::getVectorVT(Context, MVT::i1, NumElts);
 2084 EVT X86TargetLowering::getOptimalMemOpType(
 2142     EVT VT, unsigned, unsigned Align, MachineMemOperand::Flags Flags,
 2408 static SDValue lowerMasksToReg(const SDValue &ValArg, const EVT &ValLoc,
 2410   EVT ValVT = ValArg.getValueType();
 2421     EVT TempValLoc = ValVT == MVT::v8i1 ? MVT::i8 : MVT::i16;
 2504     EVT ValVT = ValToCopy.getValueType();
 2706 EVT X86TargetLowering::getTypeForExtReturn(LLVMContext &Context, EVT VT,
 2706 EVT X86TargetLowering::getTypeForExtReturn(LLVMContext &Context, EVT VT,
 2720   EVT MinVT = getRegisterType(Context, ReturnMVT);
 2784 static SDValue lowerRegToMasks(const SDValue &ValArg, const EVT &ValVT,
 2785                                const EVT &ValLoc, const SDLoc &Dl,
 2838     EVT CopyVT = VA.getLocVT();
 3020   EVT ValVT;
 3056     EVT ArgVT = Ins[i].ArgVT;
 3222       EVT RegVT = VA.getLocVT();
 3560   EVT VT = getPointerTy(DAG.getDataLayout());
 3572                                         EVT PtrVT, unsigned SlotSize,
 3762     EVT RegVT = VA.getLocVT();
 4850 bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
 4861                                               EVT NewVT) const {
 4874   EVT VT = Load->getValueType(0);
 4905 bool X86TargetLowering::reduceSelectOfFPConstantLoads(EVT CmpOpVT) const {
 4914 bool X86TargetLowering::convertSelectOfConstantsToMath(EVT VT) const {
 4923 bool X86TargetLowering::decomposeMulByConstant(LLVMContext &Context, EVT VT,
 4952 bool X86TargetLowering::shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 4952 bool X86TargetLowering::shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 4958 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 4958 bool X86TargetLowering::isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 4981   EVT VecVT = VecOp.getValueType();
 4987   EVT ScalarVT = VecVT.getScalarType();
 4991 bool X86TargetLowering::shouldFormOverflowOp(unsigned Opcode, EVT VT) const {
 5008 bool X86TargetLowering::isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
 5008 bool X86TargetLowering::isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
 5026 bool X86TargetLowering::canMergeStoresTo(unsigned AddressSpace, EVT MemVT,
 5054   EVT VT = Y.getValueType();
 5070   EVT VT = Y.getValueType();
 5120   EVT VT = N->getValueType(0);
 5132   EVT VT = Y.getValueType();
 5153 bool X86TargetLowering::shouldSplatInsEltVarIndex(EVT VT) const {
 5460   EVT VT = Vec.getValueType();
 5461   EVT ElVT = VT.getVectorElementType();
 5463   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
 5463   EVT ResultVT = EVT::getVectorVT(*DAG.getContext(), ElVT,
 5511   EVT VT = Vec.getValueType();
 5512   EVT ElVT = VT.getVectorElementType();
 5513   EVT ResultVT = Result.getValueType();
 5583     EVT VT = Src.getValueType();
 5584     EVT SubVT = Sub.getValueType();
 5610                          const SDLoc &DL, EVT VT, ArrayRef<SDValue> Ops,
 5639       EVT OpVT = Op.getValueType();
 5800   EVT SubVT = V1.getValueType();
 5801   EVT SubSVT = SubVT.getScalarType();
 5804   EVT VT = EVT::getVectorVT(*DAG.getContext(), SubSVT, 2 * SubNumElts);
 5804   EVT VT = EVT::getVectorVT(*DAG.getContext(), SubSVT, 2 * SubNumElts);
 5812 static SDValue getOnesVector(EVT VT, SelectionDAG &DAG, const SDLoc &dl) {
 5838 static SDValue getExtendInVec(unsigned Opcode, const SDLoc &DL, EVT VT,
 5840   EVT InVT = In.getValueType();
 5963   EVT VT = Op.getValueType();
 6231       EVT SrcVT = Op.getOperand(0).getValueType();
 6355 static void getPackDemandedElts(EVT VT, const APInt &DemandedElts,
 6380 static void getHorizDemandedElts(EVT VT, const APInt &DemandedElts,
 6978     EVT SubVT = Sub.getValueType();
 7020       EVT SubSVT = SubInput.getValueType().getScalarType();
 7021       EVT AltVT = EVT::getVectorVT(*DAG.getContext(), SubSVT,
 7021       EVT AltVT = EVT::getVectorVT(*DAG.getContext(), SubSVT,
 7058     EVT SrcVT = SrcVec.getValueType();
 7204     EVT SrcVT = Src.getValueType();
 7286   EVT VT = Op.getValueType();
 7307   EVT VT = Op.getValueType();
 7326   EVT VT = V.getValueType();
 7372     EVT SubVT = Sub.getValueType();
 7392     EVT SrcVT = V.getValueType();
 7657 static SDValue getVShift(bool isLeft, EVT VT, SDValue SrcOp, unsigned NumBits,
 7679     EVT PVT = LD->getValueType(0);
 7730     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
 7730     EVT NVT = EVT::getVectorVT(*DAG.getContext(), PVT, NumElems);
 7790 static SDValue EltsFromConsecutiveLoads(EVT VT, ArrayRef<SDValue> Elts,
 7853   EVT EltBaseVT = EltBase.getValueType();
 7964       EVT HalfVT =
 7965           EVT::getVectorVT(*DAG.getContext(), VT.getScalarType(), HalfNumElems);
 8025       EVT RepeatVT =
 8027               ? EVT::getIntegerVT(*DAG.getContext(), ScalarSize)
 8028               : EVT::getFloatingPointVT(ScalarSize);
 8030         RepeatVT = EVT::getVectorVT(*DAG.getContext(), RepeatVT,
 8032       EVT BroadcastVT =
 8033           EVT::getVectorVT(*DAG.getContext(), RepeatVT.getScalarType(),
 8053 static SDValue combineToConsecutiveLoads(EVT VT, SDNode *N, const SDLoc &DL,
 8318     EVT CVT = Ld.getValueType();
 8598   EVT VT = N->getValueType(0);
 9285   EVT IndicesVT = EVT(VT).changeVectorElementTypeToInteger();
 9318     EVT SrcVT = Idx.getValueType();
 9406         EVT VT = Idx.getValueType();
 9516   EVT ShuffleIdxVT = EVT(ShuffleVT).changeVectorElementTypeToInteger();
10513                                      ArrayRef<int> Mask, const EVT &VectorType,
12367   EVT EltVT = VT.getVectorElementType();
12368   EVT V0VT = V0.getValueType();
12373   EVT V0EltVT = V0VT.getVectorElementType();
12437   EVT VT = N0.getValueType();
12450   EVT WideVT = WideVec.getValueType();
12602     EVT SVT = BroadcastVT.getScalarType();
17936            SDValue *InFlag, const EVT PtrVT, unsigned ReturnReg,
17968                                 const EVT PtrVT) {
17982                                 const EVT PtrVT) {
17989                                            const EVT PtrVT,
18028                                    const EVT PtrVT, TLSModel::Model model,
18472 SDValue X86TargetLowering::BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain,
18908   EVT DstTy = Op.getValueType();
18909   EVT TheVT = Op.getOperand(0).getValueType();
19184 static SDValue truncateVectorWithPACK(unsigned Opcode, EVT DstVT, SDValue In,
19195   EVT SrcVT = In.getValueType();
19216   EVT PackedSVT = EVT::getIntegerVT(Ctx, SrcVT.getScalarSizeInBits() / 2);
19216   EVT PackedSVT = EVT::getIntegerVT(Ctx, SrcVT.getScalarSizeInBits() / 2);
19220   EVT InVT = MVT::i16, OutVT = MVT::i8;
19229     InVT = EVT::getVectorVT(Ctx, InVT, 128 / InVT.getSizeInBits());
19230     OutVT = EVT::getVectorVT(Ctx, OutVT, 128 / OutVT.getSizeInBits());
19243   InVT = EVT::getVectorVT(Ctx, InVT, SubSizeInBits / InVT.getSizeInBits());
19244   OutVT = EVT::getVectorVT(Ctx, OutVT, SubSizeInBits / OutVT.getSizeInBits());
19273     EVT PackedVT = EVT::getVectorVT(Ctx, PackedSVT, NumElems);
19273     EVT PackedVT = EVT::getVectorVT(Ctx, PackedSVT, NumElems);
19280   EVT PackedVT = EVT::getVectorVT(Ctx, PackedSVT, NumSubElts);
19280   EVT PackedVT = EVT::getVectorVT(Ctx, PackedSVT, NumSubElts);
19284   PackedVT = EVT::getVectorVT(Ctx, PackedSVT, NumElems);
19387       EVT LoVT, HiVT;
19699   EVT VecVT = X.getValueType();
19898   EVT VT = MVT::Other;
19972   EVT VT = VecIns[0].getValueType();
20139   EVT CmpVT = Op0.getValueType();
20216   EVT VT = Op.getValueType();
20234   EVT VT = Op.getValueType();
20265   EVT VT = Op.getValueType();
20321   EVT VT = N->getValueType(0);
21101   EVT CarryVT = Carry.getValueType();
21877   EVT WideVT = TLI.getTypeToTransformTo(*DAG.getContext(), StoreVT);
22205   EVT VT = Node->getValueType(0);
22348   EVT ArgVT = Op.getNode()->getValueType(0);
23069       EVT MaskVT = Src3.getValueType().changeVectorElementTypeToInteger();
23683   EVT MaskVT = Mask.getValueType().changeVectorElementTypeToInteger();
23920                 SDValue Ptr, EVT MemVT, MachineMemOperand *MMO,
23934                       SDValue Val, SDValue Ptr, SDValue Mask, EVT MemVT,
24144     EVT MemVT  = MemIntr->getMemoryVT();
24189   EVT PtrVT = getPointerTy(DAG.getDataLayout());
24217   EVT VT = Op.getValueType();
24252 Register X86TargetLowering::getRegisterByName(const char* RegName, EVT VT,
24314   EVT PtrVT = getPointerTy(DAG.getDataLayout());
24920     EVT SetCCResultType = TLI.getSetCCResultType(DAG.getDataLayout(),
25385   EVT VT = Op.getValueType();
25407     EVT ArgVT = Op->getOperand(i).getValueType();
27203   EVT VT = Node->getMemoryVT();
27263   EVT CarryVT = Carry.getValueType();
27288   EVT ArgVT = Arg.getValueType();
27370     EVT EltVT = InOp.getOperand(0).getValueType();
27406       EVT WideVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
27849     EVT VT = N->getValueType(0);
27872     EVT VT = N->getValueType(0);
27873     EVT InVT = N->getOperand(0).getValueType();
27880     EVT InWideVT = EVT::getVectorVT(*DAG.getContext(),
27880     EVT InWideVT = EVT::getVectorVT(*DAG.getContext(),
27883     EVT WideVT = EVT::getVectorVT(*DAG.getContext(),
27883     EVT WideVT = EVT::getVectorVT(*DAG.getContext(),
27927     EVT VT = N->getValueType(0);
27941     EVT VT = N->getValueType(0);
27953         EVT ResVT = getTypeToTransformTo(*DAG.getContext(), VT);
27980     EVT InVT = In.getValueType();
27988       EVT EltVT = VT.getVectorElementType();
28046     EVT VT = N->getValueType(0);
28048     EVT InVT = In.getValueType();
28095       EVT LoVT, HiVT;
28119     EVT VT = N->getValueType(0);
28121     EVT SrcVT = Src.getValueType();
28217     EVT VT = N->getValueType(0);
28221     EVT SrcVT = Src.getValueType();
28278     EVT T = N->getValueType(0);
28438     EVT DstVT = N->getValueType(0);
28439     EVT SrcVT = N->getOperand(0).getValueType();
28470       EVT WideVT = getTypeToTransformTo(*DAG.getContext(), DstVT);
28479     EVT VT = N->getValueType(0);
28488       EVT WideVT = getTypeToTransformTo(*DAG.getContext(), VT);
28531       EVT WideVT = getTypeToTransformTo(*DAG.getContext(), VT);
29024   if (!isTypeLegal(EVT::getEVT(Ty1)))
29047 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
29047 bool X86TargetLowering::isTruncateFree(EVT VT1, EVT VT2) const {
29060 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
29060 bool X86TargetLowering::isZExtFree(EVT VT1, EVT VT2) const {
29065 bool X86TargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
29066   EVT VT1 = Val.getValueType();
29093   EVT SrcVT = ExtVal.getOperand(0).getValueType();
29103 X86TargetLowering::isFMAFasterThanFMulAndFAdd(EVT VT) const {
29123 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
29123 bool X86TargetLowering::isNarrowingProfitable(EVT VT1, EVT VT2) const {
29132 bool X86TargetLowering::isShuffleMaskLegal(ArrayRef<int> M, EVT VT) const {
29150                                                EVT VT) const {
31431   EVT VT = Op.getValueType();
31488   EVT VT = Op.getValueType();
31510     EVT SrcVT = Src.getValueType();
31670   EVT VT = Op.getValueType();
32831     EVT BaseVT = Src.getValueType();
32849   EVT RootVT = Root.getValueType();
32858   EVT WideSVT = WideInputs[0].getValueType().getScalarType();
33442     EVT VT0 = BC0.getValueType();
33443     EVT VT1 = BC1.getValueType();
33467     EVT SrcVT = Src.getValueType();
33468     EVT BCVT = BC.getValueType();
33490       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), BCVT.getScalarType(),
33490       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), BCVT.getScalarType(),
33570       EVT SrcVT = Src.getValueType();
33839   EVT VT = N->getValueType(0);
33979   EVT VT = N->getValueType(0);
34025   EVT VT = N->getValueType(0);
34146   EVT VT = N->getValueType(0);
34259   EVT VT = Op.getValueType();
34711   EVT VT = Op.getValueType();
34997   EVT VT = Op.getValueType();
35071   EVT EltVT = N->getValueType(0);
35076   EVT OriginalVT = InVec.getValueType();
35082   EVT CurrentVT = InVec.getValueType();
35192 static SDValue signExtendBitcastSrcVector(SelectionDAG &DAG, EVT SExtVT,
35214 static SDValue combineBitcastvxi1(SelectionDAG &DAG, EVT VT, SDValue Src,
35217   EVT SrcVT = Src.getValueType();
35307   EVT IntVT =
35308       EVT::getIntegerVT(*DAG.getContext(), SrcVT.getVectorNumElements());
35315   EVT SrcVT = Op.getValueType();
35327   EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), Imm.getBitWidth());
35327   EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), Imm.getBitWidth());
35343   EVT DstVT = N->getValueType(0);
35345   EVT SrcVT = Op.getValueType();
35462   EVT VT = N->getValueType(0);
35463   EVT SrcVT = N0.getValueType();
35719   EVT InVT = Zext0.getOperand(0).getValueType();
35751   EVT ExtractVT = Extract->getValueType(0);
35762   EVT SrcVT = Src.getValueType();
35763   EVT SrcSVT = SrcVT.getScalarType();
35774     SrcVT = EVT::getVectorVT(*DAG.getContext(), SrcSVT, NumSubElts);
35829   EVT ExtractVT = Extract->getValueType(0);
35850   EVT MatchVT = Match.getValueType();
35861       EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
35861       EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
35871       EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
35871       EVT MovmskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
35944   EVT SetccVT =
35959   EVT VT = Extract->getOperand(0).getValueType();
36045   EVT VT = N->getValueType(0);
36046   EVT SrcVT = Src.getValueType();
36047   EVT SrcSVT = SrcVT.getVectorElementType();
36171   EVT VT = ExtElt->getValueType(0);
36172   EVT VecVT = Vec.getValueType();
36182     EVT OpVT = Vec.getOperand(0).getValueType().getScalarType();
36283   EVT VT = ExtElt->getValueType(0);
36284   EVT VecVT = Rdx.getValueType();
36388   EVT SrcVT = InputVector.getValueType();
36389   EVT VT = N->getValueType(0);
36493       EVT BCVT = EVT::getIntegerVT(*DAG.getContext(), NumSrcElts);
36493       EVT BCVT = EVT::getIntegerVT(*DAG.getContext(), NumSrcElts);
36523   EVT VT = LHS.getValueType();
36524   EVT CondVT = Cond.getValueType();
36637   EVT VT = N->getValueType(0);
36671   EVT VT = N->getValueType(0);
36753   EVT VT = N->getValueType(0);
36818   EVT VT = LHS.getValueType();
36819   EVT CondVT = Cond.getValueType();
37038       EVT SrcVT = SelectableLHS ? LHS.getOperand(0).getValueType()
37041       EVT SrcCondVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumSrcElts);
37041       EVT SrcCondVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumSrcElts);
37784       EVT VT = N->getValueType(0);
37801   EVT VT = N->getOperand(0).getValueType();
37884   EVT VT = N->getOperand(0).getValueType();
37889   EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16, NumElts);
37889   EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16, NumElts);
37931                                  EVT VT, const SDLoc &DL) {
38026   EVT VT = N->getValueType(0);
38071   EVT VT = N->getValueType(0);
38113   EVT VT = N->getValueType(0);
38256   EVT VT = N0.getValueType();
38314   EVT VT = N0.getValueType();
38337   EVT CVT = N1.getValueType();
38368   EVT VT = N0.getValueType();
38420   EVT VT = N->getValueType(0);
38519   EVT VT = N->getValueType(0);
38554   EVT VT = N->getValueType(0);
38627   EVT VT = N->getValueType(0);
38669     EVT     VT    = CMP00.getValueType();
38785   EVT VT = N->getValueType(0);
38793   EVT NarrowVT = Narrow.getValueType();
38851   EVT VT = N->getValueType(0);
38861   EVT N00Type = N00.getValueType();
38862   EVT N10Type = N10.getValueType();
38889   EVT VT0 = Op0.getValueType();
38890   EVT VT1 = Op1.getValueType();
39041   EVT VT = N->getValueType(0);
39114   EVT VT = N->getValueType(0);
39131   EVT SrcVT = Src.getValueType();
39142   EVT SubVecVT = SubVec.getValueType();
39150   EVT SetccVT = SubVec.getOperand(0).getValueType();
39172   EVT VT = N->getValueType(0);
39208       EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
39208       EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
39252     EVT SrcVecVT = SrcVec.getValueType();
39385     EVT VT, SDValue Mask, SDValue X, SDValue Y, const SDLoc &DL,
39387   EVT MaskVT = Mask.getValueType();
39442   EVT VT = N->getValueType(0);
39456   EVT MaskVT = Mask.getValueType();
39489 static SDValue lowerX86CmpEqZeroToCtlzSrl(SDValue Op, EVT ExtTy,
39492   EVT VT = Cmp.getOperand(0).getValueType();
39561   EVT VT = OR->getValueType(0);
39595   EVT VT = N->getValueType(0);
39613       EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
39613       EVT MaskVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
39773   EVT ResultType = N->getValueType(0);
39794   EVT ShiftTy = Shift.getValueType();
39808   EVT ShiftOpTy = ShiftOp.getValueType();
39810   EVT SetCCResultType = TLI.getSetCCResultType(DAG.getDataLayout(),
39828   EVT VT = N->getValueType(0);
39880 static SDValue detectUSatPattern(SDValue In, EVT VT, SelectionDAG &DAG,
39882   EVT InVT = In.getValueType();
39927 static SDValue detectSSatPattern(SDValue In, EVT VT, bool MatchPackUS = false) {
39961 static SDValue combineTruncateWithSat(SDValue In, EVT VT, const SDLoc &DL,
39967   EVT SVT = VT.getVectorElementType();
39968   EVT InVT = In.getValueType();
39969   EVT InSVT = InVT.getVectorElementType();
40007         EVT MidVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
40007         EVT MidVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
40046         InVT = EVT::getVectorVT(*DAG.getContext(), InSVT,
40053       EVT TruncVT = EVT::getVectorVT(*DAG.getContext(), SVT, ResElts);
40053       EVT TruncVT = EVT::getVectorVT(*DAG.getContext(), SVT, ResElts);
40066 static SDValue detectAVGPattern(SDValue In, EVT VT, SelectionDAG &DAG,
40071   EVT InVT = In.getValueType();
40074   EVT ScalarVT = VT.getVectorElementType();
40081   EVT InScalarVT = InVT.getVectorElementType();
40206   EVT RegVT = Ld->getValueType(0);
40207   EVT MemVT = Ld->getMemoryVT();
40230     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
40230     EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), MemVT.getScalarType(),
40251     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
40251     EVT IntVT = EVT::getIntegerVT(*DAG.getContext(), NumElts);
40311   EVT EltVT = MaskedOp->getMemoryVT().getVectorElementType();
40342   EVT VT = ML->getValueType(0);
40343   EVT EltVT = VT.getVectorElementType();
40361   EVT VT = ML->getValueType(0);
40440   EVT VT = MS->getValue().getValueType();
40441   EVT EltVT = VT.getVectorElementType();
40457   EVT VT = Mst->getValue().getValueType();
40492   EVT StVT = St->getMemoryVT();
40496   EVT VT = StoredVal.getValueType();
40503     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), VT.getVectorNumElements());
40503     EVT NewVT = EVT::getIntegerVT(*DAG.getContext(), VT.getVectorNumElements());
40737     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, VecSize / 64);
40737     EVT VecVT = EVT::getVectorVT(*DAG.getContext(), MVT::f64, VecSize / 64);
40915   EVT VT = N->getValueType(0);
40944   EVT VT = N->getValueType(0);
40945   EVT SrcVT = Src.getValueType();
41035   EVT InVT = In.getValueType();
41036   EVT OutVT = N->getValueType(0);
41049   EVT InVT = In.getValueType();
41050   EVT OutVT = N->getValueType(0);
41063   EVT OutVT = N->getValueType(0);
41071   EVT InVT = In.getValueType();
41080   EVT OutSVT = OutVT.getVectorElementType();
41081   EVT InSVT = InVT.getVectorElementType();
41169 static SDValue combinePMULH(SDValue Src, EVT VT, const SDLoc &DL,
41185   EVT InVT = Src.getValueType();
41223 static SDValue detectPMADDUBSW(SDValue In, EVT VT, SelectionDAG &DAG,
41230   EVT ScalarVT = VT.getVectorElementType();
41342     EVT InVT = Ops[0].getValueType();
41346     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
41346     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
41356   EVT VT = N->getValueType(0);
41396   EVT VT = N->getValueType(0);
41428   EVT VT = Op->getValueType(0);
41543   EVT OrigVT = N->getValueType(0);
41548   EVT VT = Arg.getValueType();
41549   EVT SVT = VT.getScalarType();
41603   EVT VT = Op.getValueType();
41604   EVT SVT = VT.getScalarType();
41642   EVT VT = Op.getValueType();
41643   EVT SVT = VT.getScalarType();
41765   EVT VT = N->getValueType(0);
41814   EVT VT = N->getValueType(0);
41919   EVT VT = N->getValueType(0);
41947   EVT SetCCType = TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
41979   EVT VT = N->getValueType(0);
42021   EVT VT = N->getValueType(0);
42101   EVT DstVT = N->getValueType(0);
42105   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
42142   EVT CMovVT = DstVT;
42166   EVT VT = N->getValueType(0);
42169   EVT ExtraVT = cast<VTSDNode>(N1)->getVT();
42208   EVT VT = Ext->getValueType(0);
42278   EVT TargetVT = Extend->getValueType(0);
42282   EVT VT = CMovN.getValueType();
42301   EVT ExtendVT = TargetVT;
42334   EVT VT = N->getValueType(0);
42335   EVT SVT = VT.getScalarType();
42336   EVT InSVT = N0.getValueType().getScalarType();
42349   EVT SclVT = N0.getOperand(0).getValueType();
42367     EVT BroadcastVT =
42368         EVT::getVectorVT(*DAG.getContext(), SclVT, EltSizeInBits);
42395   EVT CCVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
42395   EVT CCVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, NumElts);
42412   EVT VT = N->getValueType(0);
42420   EVT SVT = VT.getVectorElementType();
42437   EVT N00VT = N0.getOperand(0).getValueType();
42438   EVT MatchingVecType = N00VT.changeVectorElementTypeToInteger();
42454   EVT VT = N->getValueType(0);
42455   EVT InVT = N0.getValueType();
42494   EVT VT = N->getValueType(0);
42501   EVT ScalarVT = VT.getScalarType();
42555   EVT VT = N->getValueType(0);
42583   EVT VT = N->getValueType(0);
42657   EVT OpVT = X.getValueType();
42683   EVT VT = SetCC->getValueType(0);
42701     EVT VecVT = MVT::v16i8;
42702     EVT CmpVT = PreferKOT ? MVT::v16i1 : VecVT;
42707     EVT CastVT = VecVT;
42726       EVT TmpCastVT = CastVT;
42788       EVT KRegVT = CmpVT == MVT::v64i1 ? MVT::i64 :
42820   EVT VT = N->getValueType(0);
42821   EVT OpVT = LHS.getValueType();
42981         EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
42981         EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
43010       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
43010       EVT NewVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32, NumElts);
43036       EVT IndexVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
43036       EVT IndexVT = EVT::getVectorVT(*DAG.getContext(), EltVT,
43114   EVT VT = N->getValueType(0);
43131     EVT IntVT = BV->getValueType(0);
43162   EVT TruncVT = Trunc.getValueType();
43163   EVT SrcVT = ExtElt.getValueType();
43170   EVT SrcVecVT = ExtElt.getOperand(0).getValueType();
43173   EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), TruncVT, NumElts);
43173   EVT BitcastVT = EVT::getVectorVT(*DAG.getContext(), TruncVT, NumElts);
43184   EVT VT = N->getValueType(0);
43185   EVT InVT = Op0.getValueType();
43192     EVT DstVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43192     EVT DstVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43219   EVT VT = N->getValueType(0);
43220   EVT InVT = Op0.getValueType();
43227     EVT DstVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43227     EVT DstVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43240       EVT TruncVT = MVT::i32;
43242         TruncVT = EVT::getVectorVT(*DAG.getContext(), TruncVT,
43264     EVT LdVT = Ld->getValueType(0);
43366   EVT VT = Op.getValueType();
43510     EVT VT = N->getValueType(0);
43564   EVT VT = N->getValueType(0);
43640   EVT ZVT = Z.getValueType();
43696   EVT VT = N->getValueType(0);
43726   EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
43726   EVT ReducedVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
43728   EVT MAddVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43728   EVT MAddVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43760   EVT VT = N->getValueType(0);
43830                             const SDLoc &DL, EVT VT,
43921     EVT InVT = Ops[0].getValueType();
43925     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43925     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
43927     EVT TruncVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
43927     EVT TruncVT = EVT::getVectorVT(*DAG.getContext(), MVT::i16,
43942                               const SDLoc &DL, EVT VT,
43975   EVT InVT = N00.getValueType();
44047     EVT OpVT = Ops[0].getValueType();
44051     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
44051     EVT ResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i32,
44069   EVT VT = N->getValueType(0);
44122   EVT VT = N->getValueType(0);
44129   EVT EltVT = VT.getVectorElementType();
44179   EVT ExtType = SubusLHS.getValueType();
44180   EVT ShrinkedType;
44220       EVT VT = Op0.getValueType();
44230   EVT VT = N->getValueType(0);
44382   EVT VT = N->getValueType(0);
44383   EVT SrcVT = N->getOperand(0).getValueType();
44597   EVT InVecVT = InVec.getValueType();
44598   EVT InVecBCVT = InVecBC.getValueType();
44652         EVT NewExtVT = EVT::getVectorVT(*DAG.getContext(),
44652         EVT NewExtVT = EVT::getVectorVT(*DAG.getContext(),
44750   EVT VT = N->getValueType(0);
44841   EVT VT = N->getValueType(0);
44852       EVT MemVT = EVT::getVectorVT(*DAG.getContext(), SVT,
44852       EVT MemVT = EVT::getVectorVT(*DAG.getContext(), SVT,
44879   EVT VT = N->getValueType(0);
45039 bool X86TargetLowering::isTypeDesirableForOp(unsigned Opc, EVT VT) const {
45101 bool X86TargetLowering::IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const {
45102   EVT VT = Op.getValueType();
45184         ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const {
45184         ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const {
45572 LowerXConstraint(EVT ConstraintVT) const {
46151 bool X86TargetLowering::isIntDivCheap(EVT VT, AttributeList Attr) const {

lib/Target/X86/X86ISelLowering.h

  708     MVT getScalarShiftAmountTy(const DataLayout &, EVT VT) const override {
  742     EVT getOptimalMemOpType(uint64_t Size, unsigned DstAlign, unsigned SrcAlign,
  756     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AS, unsigned Align,
  791         ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const override;
  791         ArrayRef<int> ShuffleMask, EVT SrcVT, EVT TruncVT) const override;
  797     bool isTypeDesirableForOp(unsigned Opc, EVT VT) const override;
  803     bool IsDesirableToPromoteOp(SDValue Op, EVT &PVT) const override;
  825     bool mergeStoresAfterLegalization(EVT MemVT) const override {
  829     bool canMergeStoresTo(unsigned AddressSpace, EVT MemVT,
  838     bool hasBitPreservingFPLogic(EVT VT) const override {
  842     bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const override {
  842     bool isMultiStoresCheaperThanBitsMerge(EVT LTy, EVT HTy) const override {
  877     shouldTransformSignedTruncationCheck(EVT XVT,
  896     bool shouldSplatInsEltVarIndex(EVT VT) const override;
  898     bool convertSetCCLogicToBitwiseLogic(EVT VT) const override {
  906     EVT getSetCCResultType(const DataLayout &DL, LLVMContext &Context,
  907                            EVT VT) const override;
  960     const char *LowerXConstraint(EVT ConstraintVT) const override;
 1036     bool isTruncateFree(EVT VT1, EVT VT2) const override;
 1036     bool isTruncateFree(EVT VT1, EVT VT2) const override;
 1049     bool isZExtFree(EVT VT1, EVT VT2) const override;
 1049     bool isZExtFree(EVT VT1, EVT VT2) const override;
 1050     bool isZExtFree(SDValue Val, EVT VT2) const override;
 1059     bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
 1064     bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
 1064     bool isNarrowingProfitable(EVT VT1, EVT VT2) const override;
 1077     bool isFPImmLegal(const APFloat &Imm, EVT VT,
 1084     bool isShuffleMaskLegal(ArrayRef<int> Mask, EVT VT) const override;
 1089     bool isVectorClearMaskLegal(ArrayRef<int> Mask, EVT VT) const override;
 1097     bool ShouldShrinkFPConstant(EVT VT) const override {
 1107                                EVT NewVT) const override;
 1111     bool isScalarFPTypeInSSEReg(EVT VT) const {
 1121     bool reduceSelectOfFPConstantLoads(EVT CmpOpVT) const override;
 1123     bool convertSelectOfConstantsToMath(EVT VT) const override;
 1125     bool decomposeMulByConstant(LLVMContext &Context, EVT VT,
 1128     bool shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 1128     bool shouldUseStrictFP_TO_INT(EVT FpVT, EVT IntVT,
 1133     bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 1133     bool isExtractSubvectorCheap(EVT ResVT, EVT SrcVT,
 1142     bool isExtractVecEltCheap(EVT VT, unsigned Index) const override {
 1143       EVT EltVT = VT.getScalarType();
 1150     bool shouldFormOverflowOp(unsigned Opcode, EVT VT) const override;
 1152     bool storeOfVectorConstantIsCheap(EVT MemVT, unsigned NumElem,
 1159     bool isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
 1159     bool isLoadBitCastBeneficial(EVT LoadVT, EVT BitcastVT,
 1168     Register getRegisterByName(const char* RegName, EVT VT,
 1206     SDValue BuildFILD(SDValue Op, EVT SrcVT, SDValue Chain, SDValue StackSlot,
 1215                                       EVT VT) const override;
 1219                                            EVT VT) const override;
 1222         LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
 1222         LLVMContext &Context, CallingConv::ID CC, EVT VT, EVT &IntermediateVT,
 1225     bool isIntDivCheap(EVT VT, AttributeList Attr) const override;
 1397     EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
 1397     EVT getTypeForExtReturn(LLVMContext &Context, EVT VT,
 1523                    SDVTList VTs, EVT MemVT,
 1541                          const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 1559                         SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
 1571                       SDVTList VTs, EVT MemVT, MachineMemOperand *MMO)
 1583                          const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 1596                             const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 1611                                  const DebugLoc &dl, SDVTList VTs, EVT MemVT,
 1629                           EVT MemVT, MachineMemOperand *MMO)
 1643                            EVT MemVT, MachineMemOperand *MMO)

lib/Target/X86/X86InstrInfo.cpp

 5635     EVT VT = *TRI.legalclasstypes_begin(*RC);
 5661   std::vector<EVT> VTs;
 5668     EVT VT = N->getValueType(i);
 5966   EVT VT = Load1->getValueType(0);

lib/Target/X86/X86SelectionDAGInfo.cpp

   77       EVT IntPtr = TLI.getPointerTy(DAG.getDataLayout());
  105   EVT AVT;
  169     EVT AddrVT = Dst.getValueType();
  170     EVT SizeVT = Size.getValueType();
  238     SDValue Chain, SDValue Dst, SDValue Src, uint64_t Size, EVT SizeVT,
  280   EVT DstVT = Dst.getValueType();
  281   EVT SrcVT = Src.getValueType();

lib/Target/X86/X86TargetTransformInfo.cpp

 1636   EVT SrcTy = TLI->getValueType(DL, Src);
 1637   EVT DstTy = TLI->getValueType(DL, Dst);
 2484   auto VT = TLI->getValueType(DL, SrcVTy);
 2594   EVT VT = TLI->getValueType(DL, ValTy);
 3398   EVT VT = TLI->getValueType(DL, DataType);
 3528   EVT ETy = TLI->getValueType(DL, VT);

lib/Target/XCore/XCoreISelLowering.cpp

  178 bool XCoreTargetLowering::isZExtFree(SDValue Val, EVT VT2) const {
  182   EVT VT1 = Val.getValueType();
  326   EVT PtrVT = Op.getValueType();
  739   EVT VT = Node->getValueType(0); // not an aggregate
  742   EVT PtrVT = VAListPtr.getValueType();
  919       EVT VT = Op.getValueType();
 1301       EVT RegVT = VA.getLocVT();
 1639     EVT VT = N0.getValueType();
 1675     EVT VT = N0.getValueType();
 1713     EVT VT = N0.getValueType();

lib/Target/XCore/XCoreISelLowering.h

   99     bool isZExtFree(SDValue Val, EVT VT2) const override;
  103     MVT getScalarShiftAmountTy(const DataLayout &DL, EVT) const override {

unittests/CodeGen/AArch64SelectionDAGTest.cpp

   84   auto Int8VT = EVT::getIntegerVT(Context, 8);
   84   auto Int8VT = EVT::getIntegerVT(Context, 8);
   85   auto Int16VT = EVT::getIntegerVT(Context, 16);
   85   auto Int16VT = EVT::getIntegerVT(Context, 16);
   86   auto InVecVT = EVT::getVectorVT(Context, Int8VT, 4);
   86   auto InVecVT = EVT::getVectorVT(Context, Int8VT, 4);
   87   auto OutVecVT = EVT::getVectorVT(Context, Int16VT, 2);
   87   auto OutVecVT = EVT::getVectorVT(Context, Int16VT, 2);
   99   auto IntVT = EVT::getIntegerVT(Context, 8);
   99   auto IntVT = EVT::getIntegerVT(Context, 8);
  100   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  100   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  101   auto IdxVT = EVT::getIntegerVT(Context, 64);
  101   auto IdxVT = EVT::getIntegerVT(Context, 64);
  114   auto Int8VT = EVT::getIntegerVT(Context, 8);
  114   auto Int8VT = EVT::getIntegerVT(Context, 8);
  115   auto Int16VT = EVT::getIntegerVT(Context, 16);
  115   auto Int16VT = EVT::getIntegerVT(Context, 16);
  116   auto InVecVT = EVT::getVectorVT(Context, Int8VT, 4);
  116   auto InVecVT = EVT::getVectorVT(Context, Int8VT, 4);
  117   auto OutVecVT = EVT::getVectorVT(Context, Int16VT, 2);
  117   auto OutVecVT = EVT::getVectorVT(Context, Int16VT, 2);
  128   auto IntVT = EVT::getIntegerVT(Context, 8);
  128   auto IntVT = EVT::getIntegerVT(Context, 8);
  129   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  129   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  130   auto IdxVT = EVT::getIntegerVT(Context, 64);
  130   auto IdxVT = EVT::getIntegerVT(Context, 64);
  145   auto IntVT = EVT::getIntegerVT(Context, 8);
  145   auto IntVT = EVT::getIntegerVT(Context, 8);
  146   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  146   auto VecVT = EVT::getVectorVT(Context, IntVT, 3);
  147   auto IdxVT = EVT::getIntegerVT(Context, 64);
  147   auto IdxVT = EVT::getIntegerVT(Context, 64);
  165   auto IntVT = EVT::getIntegerVT(Context, 8);
  165   auto IntVT = EVT::getIntegerVT(Context, 8);
  186   auto IntVT = EVT::getIntegerVT(Context, 8);
  186   auto IntVT = EVT::getIntegerVT(Context, 8);

unittests/CodeGen/ScalableVectorMVTsTest.cpp

   48   EVT Vnx4i32 = EVT::getVectorVT(Ctx, MVT::i32, 4, /*Scalable=*/true);
   48   EVT Vnx4i32 = EVT::getVectorVT(Ctx, MVT::i32, 4, /*Scalable=*/true);
   53   EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32, EltCnt);
   53   EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32, EltCnt);
   57   EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64, {2, true});
   57   EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64, {2, true});
   69   EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64, {2, true});
   69   EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64, {2, true});
   78   EVT V8i32 = EVT::getVectorVT(Ctx, MVT::i32, 8);
   78   EVT V8i32 = EVT::getVectorVT(Ctx, MVT::i32, 8);
   80   EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, false});
   80   EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, false});
  103   EVT Enxv8i64 = EVT::getEVT(ScV8Int64Ty);
  103   EVT Enxv8i64 = EVT::getEVT(ScV8Int64Ty);
  113   EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, true});
  113   EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, true});

usr/include/c++/7.4.0/bits/alloc_traits.h

  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  475 	{ __a.construct(__p, std::forward<_Args>(__args)...); }
  486 	destroy(allocator_type& __a, _Up* __p)

usr/include/c++/7.4.0/bits/allocator.h

  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }

usr/include/c++/7.4.0/bits/move.h

   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
  184     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
  185 			      is_move_constructible<_Tp>,
  186 			      is_move_assignable<_Tp>>::value>::type
  187     swap(_Tp& __a, _Tp& __b)
  187     swap(_Tp& __a, _Tp& __b)
  198       _Tp __tmp = _GLIBCXX_MOVE(__a);

usr/include/c++/7.4.0/bits/ptr_traits.h

  126       typedef _Tp* pointer;
  128       typedef _Tp  element_type;
  141       pointer_to(__make_not_void<element_type>& __r) noexcept
  141       pointer_to(__make_not_void<element_type>& __r) noexcept

usr/include/c++/7.4.0/bits/stl_construct.h

   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
  204 	     allocator<_Tp>&)

usr/include/c++/7.4.0/bits/stl_function.h

  108       typedef _Arg 	argument_type;   
  111       typedef _Result 	result_type;  
  870     : public unary_function<_Tp,_Tp>
  870     : public unary_function<_Tp,_Tp>
  872       _Tp&
  873       operator()(_Tp& __x) const
  876       const _Tp&
  877       operator()(const _Tp& __x) const

usr/include/c++/7.4.0/bits/stl_iterator.h

 1224     __make_move_if_noexcept_iterator(_Tp* __i)

usr/include/c++/7.4.0/bits/stl_iterator_base_types.h

  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;

usr/include/c++/7.4.0/bits/stl_map.h

  102       typedef _Key					key_type;
  104       typedef std::pair<const _Key, _Tp>		value_type;

usr/include/c++/7.4.0/bits/stl_pair.h

  100 	return __and_<is_constructible<_T1, const _U1&>,
  100 	return __and_<is_constructible<_T1, const _U1&>,
  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  107 	return __and_<is_convertible<const _U1&, _T1>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  114 	return __and_<is_constructible<_T1, _U1&&>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  121 	return __and_<is_convertible<_U1&&, _T1>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  133 	return __and_<is_constructible<_T1, const _U1&>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  147 	return __and_<is_constructible<_T1, _U1&&>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  332        explicit pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  342 	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
  379 		__and_<is_copy_assignable<_T1>,
  380 		       is_copy_assignable<_T2>>::value,
  390 		__and_<is_move_assignable<_T1>,
  391 		       is_move_assignable<_T2>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  405 	operator=(const pair<_U1, _U2>& __p)
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)
  523                    typename __decay_and_strip<_T2>::__type>
  524     make_pair(_T1&& __x, _T2&& __y)
  524     make_pair(_T1&& __x, _T2&& __y)
  527       typedef typename __decay_and_strip<_T2>::__type __ds_type2;
  529       return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));

usr/include/c++/7.4.0/bits/stl_set.h

  110       typedef _Key     key_type;
  111       typedef _Key     value_type;
  119 	rebind<_Key>::other _Key_alloc_type;

usr/include/c++/7.4.0/bits/stl_tree.h

  218       typedef _Rb_tree_node<_Val>* _Link_type;
  231       __gnu_cxx::__aligned_membuf<_Val> _M_storage;
  233       _Val*
  237       const _Val*
  258       typedef _Tp  value_type;
  259       typedef _Tp& reference;
  260       typedef _Tp* pointer;
  265       typedef _Rb_tree_iterator<_Tp>        _Self;
  267       typedef _Rb_tree_node<_Tp>*           _Link_type;
  328       typedef _Tp        value_type;
  329       typedef const _Tp& reference;
  330       typedef const _Tp* pointer;
  332       typedef _Rb_tree_iterator<_Tp> iterator;
  337       typedef _Rb_tree_const_iterator<_Tp>        _Self;
  339       typedef const _Rb_tree_node<_Tp>*           _Link_type;
  447         rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
  454       typedef _Rb_tree_node<_Val>* 		_Link_type;
  455       typedef const _Rb_tree_node<_Val>*	_Const_Link_type;
  554 	  operator()(_Arg&& __arg) const
  563       typedef _Key 				key_type;
  564       typedef _Val 				value_type;
  621 	_M_construct_node(_Link_type __node, _Args&&... __args)
  625 	      ::new(__node) _Rb_tree_node<_Val>;
  640         _M_create_node(_Args&&... __args)
  758       static const _Key&
  782       static const _Key&
  834 	_M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
  894 		     const _Key& __k);
  898 		     const _Key& __k) const;
  902 		     const _Key& __k);
  906 		     const _Key& __k) const;
 1011         _M_insert_unique(_Arg&& __x);

usr/include/c++/7.4.0/bits/stl_uninitialized.h

  144 		      const _Tp& __x)
  182 		       const _Tp& __x)
  204 			const _Tp& __x)
  244     uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
  288 			   _ForwardIterator __result, allocator<_Tp>&)

usr/include/c++/7.4.0/bits/stl_vector.h

   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
  962 	emplace_back(_Args&&... __args);
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);
 1561 	_Up*
 1562 	_M_data_ptr(_Up* __ptr) const _GLIBCXX_NOEXCEPT

usr/include/c++/7.4.0/bits/vector.tcc

  101 				     std::forward<_Args>(__args)...);
  105 	  _M_realloc_insert(end(), std::forward<_Args>(__args)...);
  418 				   std::forward<_Args>(__args)...);

usr/include/c++/7.4.0/ext/aligned_buffer.h

   52       struct _Tp2 { _Tp _M_t; };
   54       alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
   69       _Tp*
   73       const _Tp*

usr/include/c++/7.4.0/ext/alloc_traits.h

  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };

usr/include/c++/7.4.0/ext/new_allocator.h

   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
   84 	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }

usr/include/c++/7.4.0/initializer_list

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

usr/include/c++/7.4.0/tuple

  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  159       static constexpr _Head&
  162       static constexpr const _Head&
  194       static constexpr _Head&
  197       static constexpr const _Head&
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  242 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
  248 		    const _Head& __head, const _Tail&... __tail)
  248 		    const _Head& __head, const _Tail&... __tail)
  350       static constexpr _Head&
  353       static constexpr const _Head&
  360       constexpr _Tuple_impl(const _Head& __head)
  365         constexpr _Tuple_impl(_UHead&& __head)
  390 		    const _Head& __head)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  646         constexpr tuple(_UElements&&... __elements)
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
  947         constexpr tuple(const _T1& __a1, const _T2& __a2)
  947         constexpr tuple(const _T1& __a1, const _T2& __a2)
  956         explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
  956         explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
  971         constexpr tuple(_U1&& __a1, _U2&& __a2)
  971         constexpr tuple(_U1&& __a1, _U2&& __a2)
 1066 	tuple(allocator_arg_t __tag, const _Alloc& __a)
 1078 	      const _T1& __a1, const _T2& __a2)
 1078 	      const _T1& __a1, const _T2& __a2)
 1090 	      const _T1& __a1, const _T2& __a2)
 1090 	      const _T1& __a1, const _T2& __a2)
 1241         operator=(const pair<_U1, _U2>& __in)
 1241         operator=(const pair<_U1, _U2>& __in)
 1250         operator=(pair<_U1, _U2>&& __in)
 1250         operator=(pair<_U1, _U2>&& __in)
 1252 	  this->_M_head(*this) = std::forward<_U1>(__in.first);
 1253 	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
 1302     constexpr _Head&
 1307     constexpr const _Head&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1588     constexpr tuple<_Elements&...>
 1589     tie(_Elements&... __args) noexcept

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1358     : public __is_nt_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2104     { typedef typename remove_cv<_Up>::type __type; };
 2118       typedef typename remove_reference<_Tp>::type __remove_type;
 2131       typedef _Tp __type;
 2144 	typename decay<_Tp>::type>::__type __type;
 2171     { typedef _Iffalse type; };
 2574       typename remove_reference<_Tp>::type>::type>::type

utils/unittest/googletest/include/gtest/gtest-printers.h

  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

utils/unittest/googletest/include/gtest/gtest.h

 1377                                    const T1& lhs, const T2& rhs) {
 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1390                             const T2& rhs) {
 1419                                  const T1& lhs,
 1420                                  const T2& rhs) {

utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h

   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);

utils/unittest/googletest/include/gtest/internal/gtest-internal.h

   94 ::std::string PrintToString(const T& value);