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

Declarations

include/llvm/IR/Instruction.def

  216 HANDLE_OTHER_INST(63, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.

References

include/llvm/ADT/ArrayRef.h

  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)

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/CodeGen/TargetLowering.h

 2472                                     ArrayRef<ShuffleVectorInst *> Shuffles,
 2484   virtual bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
 2364     return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);

include/llvm/IR/InstVisitor.h

  195   RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction);}

include/llvm/IR/Instructions.h

 1982   ShuffleVectorInst *cloneImpl() const;
 2280   public FixedNumOperandTraits<ShuffleVectorInst, 3> {

include/llvm/IR/NoFolder.h

  329     return new ShuffleVectorInst(V1, V2, Mask);

include/llvm/IR/OperandTraits.h

   31   static Use *op_begin(SubClass* U) {
   33         !std::is_polymorphic<SubClass>::value,
   37   static Use *op_end(SubClass* U) {

include/llvm/IR/User.h

  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
   77     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/CFLGraph.h

  502     void visitShuffleVectorInst(ShuffleVectorInst &Inst) {

lib/Analysis/InstructionSimplify.cpp

 4340   if (auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
 4340   if (auto *SourceShuf = dyn_cast<ShuffleVectorInst>(SourceOp)) {
 4377   ShuffleVectorInst::getShuffleMask(Mask, Indices);
 4408     ShuffleVectorInst::commuteShuffleMask(Indices, InVecNumElts);
 4413   if (auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
 4413   if (auto *OpShuf = dyn_cast<ShuffleVectorInst>(Op0))
 5365     auto *SVI = cast<ShuffleVectorInst>(I);
 5365     auto *SVI = cast<ShuffleVectorInst>(I);

lib/Analysis/TargetTransformInfo.cpp

  549   if (auto *ShuffleInst = dyn_cast<ShuffleVectorInst>(V))
  549   if (auto *ShuffleInst = dyn_cast<ShuffleVectorInst>(V))
  849 static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
  935   ShuffleVectorInst *LS = dyn_cast<ShuffleVectorInst>(RD->LHS);
  935   ShuffleVectorInst *LS = dyn_cast<ShuffleVectorInst>(RD->LHS);
  938   ShuffleVectorInst *RS = dyn_cast<ShuffleVectorInst>(RD->RHS);
  938   ShuffleVectorInst *RS = dyn_cast<ShuffleVectorInst>(RD->RHS);
 1053 static std::pair<Value *, ShuffleVectorInst *>
 1055   ShuffleVectorInst *S = nullptr;
 1057   if ((S = dyn_cast<ShuffleVectorInst>(L)))
 1060   S = dyn_cast<ShuffleVectorInst>(R);
 1114     ShuffleVectorInst *Shuffle;
 1288     const ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);
 1288     const ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);

lib/Analysis/ValueTracking.cpp

 2613       auto *Shuf = cast<ShuffleVectorInst>(U);

lib/Analysis/VectorUtils.cpp

  287   if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) {
  287   if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V)) {

lib/AsmParser/LLParser.cpp

 3629       if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
 6648   if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
 6651   Inst = new ShuffleVectorInst(Op0, Op1, Op2);

lib/Bitcode/Reader/BitcodeReader.cpp

 4167       I = new ShuffleVectorInst(Vec1, Vec2, Mask);

lib/CodeGen/CodeGenPrepare.cpp

  369     bool optimizeShuffleVectorInst(ShuffleVectorInst *SVI);
 6100 static bool isBroadcastShuffle(ShuffleVectorInst *SVI) {
 6116 bool CodeGenPrepare::optimizeShuffleVectorInst(ShuffleVectorInst *SVI) {
 6150           new ShuffleVectorInst(SVI->getOperand(0), SVI->getOperand(1),
 7056     return optimizeShuffleVectorInst(cast<ShuffleVectorInst>(I));

lib/CodeGen/GlobalISel/CombinerHelper.cpp

  216   ShuffleVectorInst::getShuffleMask(MI.getOperand(3).getShuffleMask(), Mask);

lib/CodeGen/GlobalISel/LegalizerHelper.cpp

 4114   ShuffleVectorInst::getShuffleMask(ShufMask, Mask);

lib/CodeGen/InterleavedAccessPass.cpp

  119                           ArrayRef<ShuffleVectorInst *> Shuffles);
  285   SmallVector<ShuffleVectorInst *, 4> Shuffles;
  298     ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(*UI);
  298     ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(*UI);
  355     ArrayRef<ShuffleVectorInst *> Shuffles) {
  373     for (auto *Shuffle : Shuffles) {
  422   ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(SI->getValueOperand());
  422   ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(SI->getValueOperand());

lib/CodeGen/InterleavedLoadCombinePass.cpp

  669   ShuffleVectorInst *SVI;
  712     ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V);
  712     ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V);
  785   static bool computeFromSVI(ShuffleVectorInst *SVI, VectorInfo &Result,
 1266         if (auto SVI = dyn_cast<ShuffleVectorInst>(&I)) {

lib/CodeGen/MachineVerifier.cpp

 1439     ShuffleVectorInst::getShuffleMask(Mask, MaskIdxes);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3047       } else if (const ShuffleVectorInst *ShufInst =
 3048                      dyn_cast<ShuffleVectorInst>(U)) {
 3565   ShuffleVectorInst::getShuffleMask(MaskV, Mask);

lib/ExecutionEngine/Interpreter/Execution.cpp

 1864 void Interpreter::visitShuffleVectorInst(ShuffleVectorInst &I){

lib/ExecutionEngine/Interpreter/Interpreter.h

  165   void visitShuffleVectorInst(ShuffleVectorInst &I);

lib/FuzzMutate/Operations.cpp

  298     return ShuffleVectorInst::isValidOperands(Cur[0], Cur[1], V);
  313     return new ShuffleVectorInst(Srcs[0], Srcs[1], Srcs[2], "S", Inst);

lib/IR/AsmWriter.cpp

 4029     if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)

lib/IR/ConstantFold.cpp

  875     int Elt = ShuffleVectorInst::getMaskValue(Mask, i);

lib/IR/Constants.cpp

 3016     return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]);

lib/IR/Instructions.cpp

 1795               OperandTraits<ShuffleVectorInst>::op_begin(this),
 1796               OperandTraits<ShuffleVectorInst>::operands(this),
 1812               OperandTraits<ShuffleVectorInst>::op_begin(this),
 1813               OperandTraits<ShuffleVectorInst>::operands(this),
 4248 ShuffleVectorInst *ShuffleVectorInst::cloneImpl() const {
 4249   return new ShuffleVectorInst(getOperand(0), getOperand(1), getOperand(2));

lib/IR/Verifier.cpp

  458   void visitShuffleVectorInst(ShuffleVectorInst &EI);
 3266 void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {

lib/Target/AArch64/AArch64ISelLowering.cpp

 8654   if (!ShuffleVectorInst::isExtractSubvectorMask(M1, NumElements, M1Start) ||
 8655       !ShuffleVectorInst::isExtractSubvectorMask(M2, NumElements, M2Start) ||
 8784     LoadInst *LI, ArrayRef<ShuffleVectorInst *> Shuffles,
 8841   DenseMap<ShuffleVectorInst *, SmallVector<Value *, 4>> SubVecs;
 8857       ShuffleVectorInst *SVI = Shuffles[i];
 8875   for (ShuffleVectorInst *SVI : Shuffles) {
 8912                                                   ShuffleVectorInst *SVI,

lib/Target/AArch64/AArch64ISelLowering.h

  363                             ArrayRef<ShuffleVectorInst *> Shuffles,
  366   bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,

lib/Target/AArch64/AArch64InstructionSelector.cpp

 3663   ShuffleVectorInst::getShuffleMask(ShuffleMask, Mask);

lib/Target/AArch64/AArch64PromoteConstant.cpp

  261   if (isa<const ShuffleVectorInst>(Instr) && OpIdx == 2)

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

  491             ShuffleVectorInst *Shuffle = new ShuffleVectorInst(Arg, Arg, Mask);
  491             ShuffleVectorInst *Shuffle = new ShuffleVectorInst(Arg, Arg, Mask);

lib/Target/ARM/ARMISelLowering.cpp

 7592       ShuffleVectorInst::isIdentityMask(M) ||
14787   if (!isa<ShuffleVectorInst>(I->getOperand(Op)))
16739     LoadInst *LI, ArrayRef<ShuffleVectorInst *> Shuffles,
16798   DenseMap<ShuffleVectorInst *, SmallVector<Value *, 4>> SubVecs;
16817       ShuffleVectorInst *SV = Shuffles[i];
16836   for (ShuffleVectorInst *SVI : Shuffles) {
16873                                               ShuffleVectorInst *SVI,

lib/Target/ARM/ARMISelLowering.h

  554                               ArrayRef<ShuffleVectorInst *> Shuffles,
  557     bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,

lib/Target/X86/X86ISelLowering.h

 1240                               ArrayRef<ShuffleVectorInst *> Shuffles,
 1246     bool lowerInterleavedStore(StoreInst *SI, ShuffleVectorInst *SVI,

lib/Target/X86/X86InterleavedAccess.cpp

   55   ArrayRef<ShuffleVectorInst *> Shuffles;
  110                                      ArrayRef<ShuffleVectorInst *> Shuffs,
  180   if (auto *SVI = dyn_cast<ShuffleVectorInst>(VecInst)) {
  180   if (auto *SVI = dyn_cast<ShuffleVectorInst>(VecInst)) {
  187           cast<ShuffleVectorInst>(Builder.CreateShuffleVector(
  807     LoadInst *LI, ArrayRef<ShuffleVectorInst *> Shuffles,
  824                                               ShuffleVectorInst *SVI,
  839   ArrayRef<ShuffleVectorInst *> Shuffles = makeArrayRef(SVI);

lib/Transforms/InstCombine/InstCombineCasts.cpp

  639   auto *Shuf = dyn_cast<ShuffleVectorInst>(Trunc.getOperand(0));
  639   auto *Shuf = dyn_cast<ShuffleVectorInst>(Trunc.getOperand(0));
  646     return new ShuffleVectorInst(NarrowOp, NarrowUndef, Shuf->getMask());
 1874   return new ShuffleVectorInst(InVal, V2,
 2409   if (auto *Shuf = dyn_cast<ShuffleVectorInst>(Src)) {
 2409   if (auto *Shuf = dyn_cast<ShuffleVectorInst>(Src)) {
 2431         return new ShuffleVectorInst(LHS, RHS, Shuf->getOperand(2));

lib/Transforms/InstCombine/InstCombineCompares.cpp

 5372     return new ShuffleVectorInst(NewCmp, UndefValue::get(NewCmp->getType()), M);

lib/Transforms/InstCombine/InstCombineInternal.h

  444   Instruction *visitShuffleVectorInst(ShuffleVectorInst &SVI);

lib/Transforms/InstCombine/InstCombineSelect.cpp

 1830   return new ShuffleVectorInst(SI.getTrueValue(), SI.getFalseValue(),

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

 1250     ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);
 1250     ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  274     ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(UserInstr);
  274     ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(UserInstr);
  407     } else if (auto *SVI = dyn_cast<ShuffleVectorInst>(I)) {
  407     } else if (auto *SVI = dyn_cast<ShuffleVectorInst>(I)) {
  572   auto *WideVec = new ShuffleVectorInst(ExtVecOp, UndefValue::get(ExtVecType),
  572   auto *WideVec = new ShuffleVectorInst(ExtVecOp, UndefValue::get(ExtVecType),
  725 static bool isShuffleEquivalentToSelect(ShuffleVectorInst &Shuf) {
  811   return new ShuffleVectorInst(FirstIE, UndefVec, ConstantVector::get(Mask));
  818   auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0));
  818   auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0));
  845   return new ShuffleVectorInst(Op0, UndefValue::get(Op0->getType()), NewMask);
  852   auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0));
  852   auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0));
  894   return new ShuffleVectorInst(X, Shuf->getOperand(1), NewMask);
  935   if (auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0))) {
  935   if (auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0))) {
  979     return new ShuffleVectorInst(Shuf->getOperand(0),
 1019     return new ShuffleVectorInst(IEI->getOperand(0),
 1091         return new ShuffleVectorInst(LR.first, LR.second,
 1413 static bool isShuffleExtractingFromLHS(ShuffleVectorInst &SVI,
 1469 static Instruction *foldSelectShuffleWith1Binop(ShuffleVectorInst &Shuf) {
 1525 static Instruction *canonicalizeInsertSplat(ShuffleVectorInst &Shuf,
 1553   return new ShuffleVectorInst(NewIns, UndefVec, ConstantVector::get(NewMask));
 1557 static Instruction *foldSelectShuffle(ShuffleVectorInst &Shuf,
 1684 static Instruction *narrowVectorSelect(ShuffleVectorInst &Shuf,
 1705       !cast<ShuffleVectorInst>(Cond)->isIdentityWithPadding())
 1717 static Instruction *foldIdentityExtractShuffle(ShuffleVectorInst &Shuf) {
 1753   return new ShuffleVectorInst(X, Y, ConstantVector::get(NewMask));
 1757 static Instruction *foldShuffleWithInsert(ShuffleVectorInst &Shuf) {
 1814   ShuffleVectorInst::commuteShuffleMask(Mask, NumElts);
 1821 static Instruction *foldIdentityPaddedShuffles(ShuffleVectorInst &Shuf) {
 1825   auto *Shuffle0 = dyn_cast<ShuffleVectorInst>(Shuf.getOperand(0));
 1825   auto *Shuffle0 = dyn_cast<ShuffleVectorInst>(Shuf.getOperand(0));
 1826   auto *Shuffle1 = dyn_cast<ShuffleVectorInst>(Shuf.getOperand(1));
 1826   auto *Shuffle1 = dyn_cast<ShuffleVectorInst>(Shuf.getOperand(1));
 1884   return new ShuffleVectorInst(X, Y, ConstantVector::get(NewMask));
 1887 Instruction *InstCombiner::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
 2099   ShuffleVectorInst* LHSShuffle = dyn_cast<ShuffleVectorInst>(LHS);
 2099   ShuffleVectorInst* LHSShuffle = dyn_cast<ShuffleVectorInst>(LHS);
 2100   ShuffleVectorInst* RHSShuffle = dyn_cast<ShuffleVectorInst>(RHS);
 2100   ShuffleVectorInst* RHSShuffle = dyn_cast<ShuffleVectorInst>(RHS);
 2235     return new ShuffleVectorInst(newLHS, newRHS, ConstantVector::get(Elts));

lib/Transforms/InstCombine/InstructionCombining.cpp

 1419       cast<ShuffleVectorInst>(LHS)->isConcat() &&
 1420       cast<ShuffleVectorInst>(RHS)->isConcat()) {
 1432     return new ShuffleVectorInst(NewBO0, NewBO1, Mask);
 1445     return new ShuffleVectorInst(XY, UndefValue::get(XY->getType()), M);
 1465     auto *LShuf = cast<ShuffleVectorInst>(LHS);
 1465     auto *LShuf = cast<ShuffleVectorInst>(LHS);
 1466     auto *RShuf = cast<ShuffleVectorInst>(RHS);
 1466     auto *RShuf = cast<ShuffleVectorInst>(RHS);
 1503     ShuffleVectorInst::getShuffleMask(Mask, ShMask);

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  499       isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  452   void visitShuffleVectorInst(ShuffleVectorInst &I);
 1426 void DFSanVisitor::visitShuffleVectorInst(ShuffleVectorInst &I) {

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1874   void visitShuffleVectorInst(ShuffleVectorInst &I) {

lib/Transforms/Scalar/EarlyCSE.cpp

  115            isa<ShuffleVectorInst>(Inst) || isa<ExtractValueInst>(Inst) ||

lib/Transforms/Scalar/LICM.cpp

 1040           isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  457   if (isa<ShuffleVectorInst>(I))
  640       !isa<ShuffleVectorInst>(V)) {
  793            isa<ShuffleVectorInst>(BDV);
  836       } else if (auto *SV = dyn_cast<ShuffleVectorInst>(Current)) {
  836       } else if (auto *SV = dyn_cast<ShuffleVectorInst>(Current)) {
  905         auto *SV = cast<ShuffleVectorInst>(BDV);
  905         auto *SV = cast<ShuffleVectorInst>(BDV);
  986         auto *SV = cast<ShuffleVectorInst>(I);
  986         auto *SV = cast<ShuffleVectorInst>(I);
  989         return new ShuffleVectorInst(VecUndef, VecUndef, SV->getOperand(2),
 1102       auto *BaseSV = cast<ShuffleVectorInst>(State.getBaseValue());
 1102       auto *BaseSV = cast<ShuffleVectorInst>(State.getBaseValue());
 1103       auto *BdvSV = cast<ShuffleVectorInst>(BDV);
 1103       auto *BdvSV = cast<ShuffleVectorInst>(BDV);

lib/Transforms/Scalar/Scalarizer.cpp

  193   bool visitShuffleVectorInst(ShuffleVectorInst &SVI);
  717 bool ScalarizerVisitor::visitShuffleVectorInst(ShuffleVectorInst &SVI) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 3171            isa<ShuffleVectorInst>(I) || isa<GetElementPtrInst>(I);
 3357       } else if (auto *SI = dyn_cast<ShuffleVectorInst>(I)) {
 3357       } else if (auto *SI = dyn_cast<ShuffleVectorInst>(I)) {

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3658           if (auto *SV = dyn_cast<ShuffleVectorInst>(V)) {
 3658           if (auto *SV = dyn_cast<ShuffleVectorInst>(V)) {

tools/clang/lib/CodeGen/Address.h

  108 template <class U> inline U cast(CodeGen::Address addr) {

tools/clang/lib/CodeGen/CGExprScalar.cpp

 1757 static llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx,
 1834             llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
 1834             llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
 1840             LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
 1866       llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
 1866       llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
 1875             Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0,
 1886           V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);

tools/llvm-stress/llvm-stress.cpp

  514     Value *V = new ShuffleVectorInst(Val0, Val1, Mask, "Shuff",

unittests/IR/InstructionsTest.cpp

  799   ShuffleVectorInst::commuteShuffleMask(Indices, 4);
  889   ShuffleVectorInst *Id1 = new ShuffleVectorInst(V0, V1,
  889   ShuffleVectorInst *Id1 = new ShuffleVectorInst(V0, V1,
  898   ShuffleVectorInst *Id2 = new ShuffleVectorInst(V0, V1,
  898   ShuffleVectorInst *Id2 = new ShuffleVectorInst(V0, V1,
  907   ShuffleVectorInst *Id3 = new ShuffleVectorInst(V0, V1,
  907   ShuffleVectorInst *Id3 = new ShuffleVectorInst(V0, V1,
  916   ShuffleVectorInst *Id4 = new ShuffleVectorInst(V0, V1,
  916   ShuffleVectorInst *Id4 = new ShuffleVectorInst(V0, V1,
  925   ShuffleVectorInst *Id5 = new ShuffleVectorInst(V0, V1,
  925   ShuffleVectorInst *Id5 = new ShuffleVectorInst(V0, V1,
  934   ShuffleVectorInst *Id6 = new ShuffleVectorInst(V0, V1,
  934   ShuffleVectorInst *Id6 = new ShuffleVectorInst(V0, V1,
  943   ShuffleVectorInst *Id7 = new ShuffleVectorInst(V0, V1,
  943   ShuffleVectorInst *Id7 = new ShuffleVectorInst(V0, V1,
  952   ShuffleVectorInst *Id8 = new ShuffleVectorInst(V0, V1,
  952   ShuffleVectorInst *Id8 = new ShuffleVectorInst(V0, V1,
  961   ShuffleVectorInst *Id9 = new ShuffleVectorInst(V0, V1,
  961   ShuffleVectorInst *Id9 = new ShuffleVectorInst(V0, V1,
  970   ShuffleVectorInst *Id10 = new ShuffleVectorInst(V0, V1,
  970   ShuffleVectorInst *Id10 = new ShuffleVectorInst(V0, V1,
  979   ShuffleVectorInst *Id11 = new ShuffleVectorInst(V0, V1,
  979   ShuffleVectorInst *Id11 = new ShuffleVectorInst(V0, V1,
  989   ShuffleVectorInst *Id12 = new ShuffleVectorInst(V0, ConstantVector::get({CU, CU, CU, CU}),
  989   ShuffleVectorInst *Id12 = new ShuffleVectorInst(V0, ConstantVector::get({CU, CU, CU, CU}),

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };