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

Declarations

include/llvm/Analysis/ConstantFolding.h

   28 class ConstantVector;

References

include/llvm/ADT/DenseMapInfo.h

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

include/llvm/Analysis/TargetTransformInfoImpl.h

  607     if (isa<ConstantDataVector>(Val) || isa<ConstantVector>(Val)) {

include/llvm/Analysis/Utils/Local.h

   65         OpC = ConstantVector::getSplat(IntPtrTy->getVectorNumElements(), OpC);

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
   92     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

include/llvm/Support/PointerLikeTypeTraits.h

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

lib/Analysis/ConstantFolding.cpp

  144     return FoldBitCast(ConstantVector::get(Ops), DestTy, DL);
  148   if (!isa<ConstantDataVector>(C) && !isa<ConstantVector>(C))
  191     if (!isa<ConstantVector>(C) &&  // FIXME: Remove ConstantVector.
  235     return ConstantVector::get(Result);
  281   return ConstantVector::get(Result);
  459   if (isa<ConstantArray>(C) || isa<ConstantVector>(C) ||
 1079   if (!isa<ConstantVector>(C) && !isa<ConstantExpr>(C))
 1087     if (isa<ConstantVector>(NewC) || isa<ConstantExpr>(NewC)) {
 1113   return ConstantVector::get(Ops);
 1992   if (isa<ConstantVector>(Operands[0]) ||
 2222   if ((isa<ConstantVector>(Operands[0]) ||
 2436     return ConstantVector::get(NewElements);
 2463   return ConstantVector::get(Result);

lib/Analysis/InstructionSimplify.cpp

  670     return ConstantVector::getSplat(V->getType()->getVectorNumElements(),
 1183   if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) {

lib/Analysis/TargetTransformInfo.cpp

  557   if (isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) {

lib/Analysis/ValueTracking.cpp

 1677   if (const auto *CV = dyn_cast<ConstantVector>(V)) {
 1677   if (const auto *CV = dyn_cast<ConstantVector>(V)) {

lib/Analysis/VectorUtils.cpp

  654   return ConstantVector::get(Mask);
  664   return ConstantVector::get(MaskVec);
  674   return ConstantVector::get(Mask);
  683   return ConstantVector::get(Mask);
  696   return ConstantVector::get(Mask);
  791   if (auto *CV = dyn_cast<ConstantVector>(Mask))
  791   if (auto *CV = dyn_cast<ConstantVector>(Mask))

lib/AsmParser/LLParser.cpp

 3164     ID.ConstantVal = ConstantVector::get(Elts);

lib/Bitcode/Reader/BitcodeReader.cpp

 2450         V = ConstantVector::get(Elts);

lib/Bitcode/Reader/ValueList.cpp

  209       } else if (isa<ConstantVector>(UserC)) {
  210         NewC = ConstantVector::get(NewOps);

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2434                                      const ConstantVector *CV, AsmPrinter &AP) {
 2732   if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))
 2732   if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))

lib/CodeGen/CodeGenPrepare.cpp

 6426       return ConstantVector::getSplat(End, Val);
 6436     return ConstantVector::get(ConstVec);

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2157   } else if (auto CV = dyn_cast<ConstantVector>(&C)) {

lib/CodeGen/MIRParser/MIParser.cpp

 2329     Dest = MachineOperand::CreateShuffleMask(ConstantVector::get(ShufMask));

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 1961     Constant *CP = ConstantVector::get(CV);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1535     if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) {
 1535     if (const ConstantVector *CV = dyn_cast<ConstantVector>(C)) {
 7851       isa<ConstantVector>(OpVal) || isa<ConstantDataVector>(OpVal)) {

lib/ExecutionEngine/ExecutionEngine.cpp

  921     const ConstantVector *CV = dyn_cast<ConstantVector>(C);
  921     const ConstantVector *CV = dyn_cast<ConstantVector>(C);
 1138   if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {
 1138   if (const ConstantVector *CP = dyn_cast<ConstantVector>(Init)) {

lib/IR/AsmWriter.cpp

 1474   if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {

lib/IR/ConstantFold.cpp

   68   return ConstantVector::get(Result);
  156       return ConstantExpr::getBitCast(ConstantVector::get(V), DestPTy);
  572   if ((isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) &&
  584     return ConstantVector::get(res);
  740   if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
  740   if (ConstantVector *CondV = dyn_cast<ConstantVector>(Cond)) {
  763       return ConstantVector::get(Result);
  854   return ConstantVector::get(Result);
  895   return ConstantVector::get(Result);
  938   return ConstantVector::get(Result);
  980     return ConstantVector::get(Result);
 1323     return ConstantVector::get(Result);
 1935     return ConstantVector::get(ResElts);
 2179                ? ConstantVector::getSplat(

lib/IR/Constants.cpp

   50   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
   50   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
   76   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
   76   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  110   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  110   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  136   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  136   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  162   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  162   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
  338     C = ConstantVector::getSplat(VTy->getNumElements(), C);
  355   return ConstantVector::getSplat(VTy->getNumElements(),
  627     return ConstantVector::getSplat(VTy->getNumElements(), TrueC);
  635     return ConstantVector::getSplat(VTy->getNumElements(), FalseC);
  658     return ConstantVector::getSplat(VTy->getNumElements(), C);
  682     return ConstantVector::getSplat(VTy->getNumElements(), C);
  727     return ConstantVector::getSplat(VTy->getNumElements(), C);
  739     return ConstantVector::getSplat(VTy->getNumElements(), C);
  752     return ConstantVector::getSplat(VTy->getNumElements(), C);
  763     return ConstantVector::getSplat(VTy->getNumElements(), C);
  774     return ConstantVector::getSplat(VTy->getNumElements(), C);
  785     return ConstantVector::getSplat(VTy->getNumElements(), C);
  796     return ConstantVector::getSplat(VTy->getNumElements(), C);
  844     return ConstantVector::getSplat(VTy->getNumElements(), C);
 1405   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
 1405   if (const ConstantVector *CV = dyn_cast<ConstantVector>(this))
 2051       Idx = ConstantVector::getSplat(NumVecElts, Idx);
 2688   return ConstantVector::getSplat(NumElts, V);

lib/IR/ConstantsContext.h

  368   using ValType = ConstantAggrKeyType<ConstantVector>;
  377   ConstantAggrKeyType(ArrayRef<Constant *> Operands, const ConstantClass *)
  380   ConstantAggrKeyType(const ConstantClass *C,
  392   bool operator==(const ConstantClass *C) const {
  405   using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
  407   ConstantClass *create(TypeClass *Ty) const {
  408     return new (Operands.size()) ConstantClass(Ty, Operands);
  572   using ValType = typename ConstantInfo<ConstantClass>::ValType;
  573   using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
  581     using ConstantClassInfo = DenseMapInfo<ConstantClass *>;
  583     static inline ConstantClass *getEmptyKey() {
  587     static inline ConstantClass *getTombstoneKey() {
  591     static unsigned getHashValue(const ConstantClass *CP) {
  596     static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
  596     static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
  608     static bool isEqual(const LookupKey &LHS, const ConstantClass *RHS) {
  616     static bool isEqual(const LookupKeyHashed &LHS, const ConstantClass *RHS) {
  622   using MapTy = DenseSet<ConstantClass *, MapInfo>;
  637   ConstantClass *create(TypeClass *Ty, ValType V, LookupKeyHashed &HashKey) {
  638     ConstantClass *Result = V.create(Ty);
  648   ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
  653     ConstantClass *Result = nullptr;
  666   void remove(ConstantClass *CP) {
  673   ConstantClass *replaceOperandsInPlace(ArrayRef<Constant *> Operands,
  674                                         ConstantClass *CP, Value *From,

lib/IR/Core.cpp

 1427   return wrap(ConstantVector::get(makeArrayRef(

lib/IR/Instructions.cpp

 1839   Op<2>() = ConstantVector::get(NewMask);
 1858   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {
 1858   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {

lib/IR/LLVMContextImpl.cpp

   88   for (auto *I : VectorConstants)

lib/IR/LLVMContextImpl.h

 1299   using VectorConstantsTy = ConstantUniqueMap<ConstantVector>;

lib/Target/AArch64/AArch64InstructionSelector.cpp

 3689   Constant *CPVal = ConstantVector::get(CstIdxs);

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

  490             Constant *Mask = ConstantVector::get(Indices);

lib/Target/Hexagon/HexagonISelLowering.cpp

  894   const ConstantVector *CV = dyn_cast<ConstantVector>(ConstVal);
  894   const ConstantVector *CV = dyn_cast<ConstantVector>(ConstVal);
  913   return ConstantVector::get(NewConst);

lib/Target/Hexagon/HexagonISelLoweringHVX.cpp

  397     Constant *CV = ConstantVector::get(Tmp);

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

 1931   if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV)) {

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

  219   if (isa<ConstantVector>(C)) {

lib/Target/PowerPC/PPCISelLowering.cpp

 8306       Constant *CP = ConstantVector::get(CV);

lib/Target/X86/X86ISelLowering.cpp

 8090   return ConstantVector::get(ArrayRef<Constant *>(ConstantVec));
 9667     Constant *CV = ConstantVector::get(ConstVecOps);
18572   Constant *C1 = ConstantVector::get(CV1);

lib/Target/X86/X86MCInstLower.cpp

 2386       } else if (auto *CV = dyn_cast<ConstantVector>(C)) {

lib/Transforms/IPO/GlobalOpt.cpp

 2426   return ConstantVector::get(Elts);
 2537           CurrentGV->setInitializer(ConstantVector::get(Elts));

lib/Transforms/InstCombine/InstCombineCalls.cpp

  107   return ConstantVector::get(BoolVec);
  518     return ConstantVector::get(ConstantVec);
  533   auto ShiftVec = ConstantVector::get(ShiftVecAmts);
  733     return ConstantVector::get(Args);
  789           ConstantAggregateZero::get(ShufTy), ConstantVector::get(ShuffleMask));
  870                                             ConstantVector::get(ShuffleMask));
  895     return ConstantVector::get(Args);
  955   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, NumElts));
 1005   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, NumElts));
 1042   auto ShuffleMask = ConstantVector::get(makeArrayRef(Indexes, Size));
 3485         Constant *Folded = ConstantVector::get({

lib/Transforms/InstCombine/InstCombineInternal.h

  293   return ConstantVector::get(Out);

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  124   return ConstantVector::get(Elts);
 1432   if (isa<ConstantVector>(Op1) || isa<ConstantDataVector>(Op1)) {
 1460       Constant *NewRHSV = ConstantVector::get(Elts);

lib/Transforms/InstCombine/InstCombineSelect.cpp

 1831                                ConstantVector::get(Mask));

lib/Transforms/InstCombine/InstCombineShifts.cpp

  146   if (auto *CV = dyn_cast<ConstantVector>(C)) {
  146   if (auto *CV = dyn_cast<ConstantVector>(C)) {
  152     return ConstantVector::get(NewOps);
  704             Mask = ConstantVector::getSplat(VT->getNumElements(), Mask);
  739             Mask = ConstantVector::getSplat(VT->getNumElements(), Mask);

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

 1138     Constant *NewCV = ConstantVector::get(Elts);
 1318         if (auto *CV = dyn_cast<ConstantVector>(Shuffle->getOperand(0))) {
 1318         if (auto *CV = dyn_cast<ConstantVector>(Shuffle->getOperand(0))) {
 1325         if (auto *CV = dyn_cast<ConstantVector>(Shuffle->getOperand(1))) {
 1325         if (auto *CV = dyn_cast<ConstantVector>(Shuffle->getOperand(1))) {
 1350       I->setOperand(2, ConstantVector::get(Elts));
 1370     if (auto *CV = dyn_cast<ConstantVector>(Sel->getCondition())) {
 1370     if (auto *CV = dyn_cast<ConstantVector>(Sel->getCondition())) {
 1471       if (auto *CV = dyn_cast<ConstantVector>(II->getOperand(2)))
 1471       if (auto *CV = dyn_cast<ConstantVector>(II->getOperand(2)))

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  573                                         ConstantVector::get(ExtendMask));
  811   return new ShuffleVectorInst(FirstIE, UndefVec, ConstantVector::get(Mask));
  844   Constant *NewMask = ConstantVector::get(NewMaskVec);
  893   Constant *NewMask = ConstantVector::get(NewMaskVec);
  980                                  ConstantVector::get(NewShufElts),
  981                                  ConstantVector::get(NewMaskElts));
 1020                                  ConstantVector::get(Values),
 1021                                  ConstantVector::get(Mask));
 1092                                      ConstantVector::get(Mask));
 1310                                           ConstantVector::get(MaskValues));
 1553   return new ShuffleVectorInst(NewIns, UndefVec, ConstantVector::get(NewMask));
 1753   return new ShuffleVectorInst(X, Y, ConstantVector::get(NewMask));
 1884   return new ShuffleVectorInst(X, Y, ConstantVector::get(NewMask));
 1920     SVI.setOperand(2, ConstantVector::get(Elts));
 2033                                         ConstantVector::get(ShuffleMask),
 2235     return new ShuffleVectorInst(newLHS, newRHS, ConstantVector::get(Elts));

lib/Transforms/InstCombine/InstructionCombining.cpp

  809   if (ConstantVector *CV = dyn_cast<ConstantVector>(V)) {
  809   if (ConstantVector *CV = dyn_cast<ConstantVector>(V)) {
 1544       Constant *NewC = ConstantVector::get(NewVecC);
 3418         if (!isa<ConstantVector>(U) && !isa<ConstantExpr>(U))

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1522     if (auto *Vector = dyn_cast<ConstantVector>(Mask)) {
 1522     if (auto *Vector = dyn_cast<ConstantVector>(Mask)) {

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 2153       ShadowMul = ConstantVector::get(Elements);

lib/Transforms/Scalar/SROA.cpp

 2205                               ConstantVector::get(Mask), Name + ".extract");
 2244                               ConstantVector::get(Mask), Name + ".expand");
 2251   V = IRB.CreateSelect(ConstantVector::get(Mask), V, Old, Name + "blend");

lib/Transforms/Utils/FunctionComparator.cpp

  329     const ConstantVector *LV = cast<ConstantVector>(L);
  329     const ConstantVector *LV = cast<ConstantVector>(L);
  330     const ConstantVector *RV = cast<ConstantVector>(R);
  330     const ConstantVector *RV = cast<ConstantVector>(R);

lib/Transforms/Utils/LoopUtils.cpp

  842         ConstantVector::get(ShuffleMask), "rdx.shuf");

lib/Transforms/Utils/ValueMapper.cpp

  479   if (isa<ConstantVector>(C))
  480     return getVM()[V] = ConstantVector::get(Ops);

lib/Transforms/Vectorize/LoopVectorize.cpp

 1717                        ? ConstantVector::getSplat(VF, cast<Constant>(Mul))
 1910     Constant *Cv = ConstantVector::get(Indices);
 1928   Constant *Cv = ConstantVector::get(Indices);
 2115                                      ConstantVector::get(ShuffleMask),
 3583                                              ConstantVector::get(ShuffleMask))
 3688       Identity = ConstantVector::getSplat(VF, Iden);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4212       Value *ShuffleMask = ConstantVector::get(Mask);
 5705   return ConstantVector::get(ShuffleMask);

tools/clang/lib/CodeGen/CGBuiltin.cpp

 4337   Value* SV = llvm::ConstantVector::getSplat(nElts, C);
 6678       Value *SV = llvm::ConstantVector::get(ConstantInt::get(Int32Ty, 1-Lane));
 6747       Value *SV = llvm::ConstantVector::get(cast<llvm::Constant>(Ops[2]));
 8364     Value *SV = llvm::ConstantVector::getSplat(VTy->getNumElements(), cst);
 8393     Value* SV = llvm::ConstantVector::getSplat(VTy->getNumElements(),
 9476     return llvm::ConstantVector::get(CstOps);
12681       Constant *ShuffleMask = llvm::ConstantVector::get(ShuffleElts);
12723       Constant *ShuffleMask = llvm::ConstantVector::get(ShuffleElts);
12749     Constant *ShuffleMask = llvm::ConstantVector::get(ShuffleElts);
12791     Constant *ShuffleMask = llvm::ConstantVector::get(ShuffleElts);

tools/clang/lib/CodeGen/CGDecl.cpp

  867       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
  904       isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
 1071       return llvm::ConstantVector::get(Values);
 1271   return llvm::ConstantVector::get(Values);

tools/clang/lib/CodeGen/CGExpr.cpp

 1732         llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 1874   llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 2112       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 2125       llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
 2144       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 3852   llvm::Constant *CV = llvm::ConstantVector::get(CElts);

tools/clang/lib/CodeGen/CGExprConstant.cpp

 2074     return llvm::ConstantVector::get(Inits);

tools/clang/lib/CodeGen/CGExprScalar.cpp

 1641   Value *SV = llvm::ConstantVector::get(indices);
 1845             llvm::Constant *Mask = llvm::ConstantVector::get(Args);
 1898       llvm::Constant *Mask = llvm::ConstantVector::get(Args);
 1914     llvm::Constant *Mask = llvm::ConstantVector::get(Args);
 4337   llvm::Constant *Mask = llvm::ConstantVector::get(Args);

tools/llvm-diff/DifferenceEngine.cpp

  411     if (isa<ConstantVector>(L)) {
  412       ConstantVector *CVL = cast<ConstantVector>(L);
  412       ConstantVector *CVL = cast<ConstantVector>(L);
  413       ConstantVector *CVR = cast<ConstantVector>(R);
  413       ConstantVector *CVR = cast<ConstantVector>(R);

tools/llvm-stress/llvm-stress.cpp

  249       return ConstantVector::get(VectorValue);
  425                 return PT->push_back(ConstantVector::getAllOnesValue(Ty));
  428                 return PT->push_back(ConstantVector::getNullValue(Ty));
  512     Constant *Mask = ConstantVector::get(Idxs);

tools/polly/lib/CodeGen/BlockGenerators.cpp

 1070     Constant *SV = llvm::ConstantVector::get(Indices);

unittests/Analysis/VectorUtilsTest.cpp

   90   Constant *NonSplatC = ConstantVector::get({ScalarC, OtherScalarC});
   97   Constant *SplatWithUndefC = ConstantVector::get({ScalarC, UndefScalar});

unittests/FuzzMutate/OperationsTest.cpp

   95   Constant *v8i8 = ConstantVector::getSplat(8, i8);
   96   Constant *v4f16 = ConstantVector::getSplat(4, f16);

unittests/IR/ConstantsTest.cpp

  448     Constant *CDV = ConstantVector::get(Vals);
  456     Constant *CDV = ConstantVector::get(Vals);

unittests/IR/InstructionsTest.cpp

  323   Constant *C2xi32a = ConstantVector::get(ConstVa);
  324   Constant *C2xi32b = ConstantVector::get(ConstVb);
  817   Constant *Identity = ConstantVector::get({C0, CU, C2, C3, C4});
  825   Constant *Select = ConstantVector::get({CU, C1, C5});
  833   Constant *Reverse = ConstantVector::get({C3, C2, C1, CU});
  841   Constant *SingleSource = ConstantVector::get({C2, C2, C0, CU});
  849   Constant *ZeroEltSplat = ConstantVector::get({C0, C0, CU, C0});
  857   Constant *Transpose = ConstantVector::get({C0, C4, C2, C6});
  885   Constant *V0 = ConstantVector::get({C0, C1, C2, C3});
  886   Constant *V1 = ConstantVector::get({C3, C2, C1, C0});
  890                                                  ConstantVector::get({C0, C1, CU, CU}));
  899                                                  ConstantVector::get({C0, C1, C2}));
  908                                                  ConstantVector::get({C4, CU, C6}));
  917                                                  ConstantVector::get({C4, C1, C6}));
  926                                                  ConstantVector::get({CU, C1, C2, C3, CU, CU}));
  935                                                  ConstantVector::get({C4, C5, C6, CU, CU, CU}));
  944                                                  ConstantVector::get({C0, C1, C2, C3, CU, C1}));
  953                                                  ConstantVector::get({C4, CU, C2, C3, CU, CU}));
  962                                                  ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7}));
  971                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6}));
  980                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7, CU}));
  989   ShuffleVectorInst *Id12 = new ShuffleVectorInst(V0, ConstantVector::get({CU, CU, CU, CU}),
  990                                                   ConstantVector::get({C0, CU, C2, C3, CU, CU, C6, C7}));

unittests/IR/PatternMatch.cpp

  918   auto *IdxVec = ConstantVector::get(VecElemIdxs);
 1012   Constant *VectorZeroUndef = ConstantVector::get(Elems);
 1040   Constant *VectorZeroUndef = ConstantVector::get(Elems);

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };