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

Declarations

include/llvm/Analysis/MemoryBuiltins.h

   37 class ExtractElementInst;

include/llvm/IR/Instruction.def

  214 HANDLE_OTHER_INST(61, ExtractElement, ExtractElementInst)// extract from vector

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/Analysis/MemoryBuiltins.h

  264   SizeOffsetType visitExtractElementInst(ExtractElementInst &I);
  333   SizeOffsetEvalType visitExtractElementInst(ExtractElementInst &I);

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
 2336     return Insert(ExtractElementInst::Create(Vec, Idx), Name);

include/llvm/IR/InstVisitor.h

  193   RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}

include/llvm/IR/Instructions.h

 1860   ExtractElementInst *cloneImpl() const;
 1863   static ExtractElementInst *Create(Value *Vec, Value *Idx,
 1866     return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertBefore);
 1869   static ExtractElementInst *Create(Value *Vec, Value *Idx,
 1872     return new(2) ExtractElementInst(Vec, Idx, NameStr, InsertAtEnd);
 1902   public FixedNumOperandTraits<ExtractElementInst, 2> {

include/llvm/IR/NoFolder.h

  319     return ExtractElementInst::Create(Vec, Idx);

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);
   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/CFLGraph.h

  469     void visitExtractElementInst(ExtractElementInst &Inst) {
  471       auto *Val = &Inst;

lib/Analysis/CodeMetrics.cpp

  157     if (isa<ExtractElementInst>(I) || I.getType()->isVectorTy())

lib/Analysis/InlineCost.cpp

 1579     if (isa<ExtractElementInst>(I) || I->getType()->isVectorTy())

lib/Analysis/InstructionSimplify.cpp

 5359     auto *EEI = cast<ExtractElementInst>(I);
 5359     auto *EEI = cast<ExtractElementInst>(I);

lib/Analysis/Lint.cpp

  119     void visitExtractElementInst(ExtractElementInst &I);
  626 void Lint::visitExtractElementInst(ExtractElementInst &I) {

lib/Analysis/MemoryBuiltins.cpp

  737 ObjectSizeOffsetVisitor::visitExtractElementInst(ExtractElementInst&) {
  960 ObjectSizeOffsetEvaluator::visitExtractElementInst(ExtractElementInst&) {

lib/Analysis/TargetTransformInfo.cpp

 1000 static ReductionKind matchPairwiseReduction(const ExtractElementInst *ReduxRoot,
 1065 matchVectorSplittingReduction(const ExtractElementInst *ReduxRoot,
 1230     const ExtractElementInst * EEI = cast<ExtractElementInst>(I);
 1230     const ExtractElementInst * EEI = cast<ExtractElementInst>(I);

lib/AsmParser/LLParser.cpp

 3636       if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
 6610   if (!ExtractElementInst::isValidOperands(Op0, Op1))
 6613   Inst = ExtractElementInst::Create(Op0, Op1);

lib/Bitcode/Reader/BitcodeReader.cpp

 4134       I = ExtractElementInst::Create(Vec, Idx);

lib/CodeGen/CodeGenPrepare.cpp

 7060     return optimizeExtractElementInst(cast<ExtractElementInst>(I));

lib/CodeGen/InterleavedAccessPass.cpp

  118   bool tryReplaceExtracts(ArrayRef<ExtractElementInst *> Extracts,
  286   SmallVector<ExtractElementInst *, 4> Extracts;
  293     auto *Extract = dyn_cast<ExtractElementInst>(*UI);
  293     auto *Extract = dyn_cast<ExtractElementInst>(*UI);
  354     ArrayRef<ExtractElementInst *> Extracts,
  363   DenseMap<ExtractElementInst *, std::pair<Value *, int>> ReplacementMap;
  365   for (auto *Extract : Extracts) {
  406     auto *Extract = Replacement.first;

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3085       } else if (isa<ExtractElementInst>(U)) {

lib/ExecutionEngine/Interpreter/Execution.cpp

 1799 void Interpreter::visitExtractElementInst(ExtractElementInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  163   void visitExtractElementInst(ExtractElementInst &I);

lib/FuzzMutate/Operations.cpp

  280     return ExtractElementInst::Create(Srcs[0], Srcs[1], "E", Inst);

lib/IR/Constants.cpp

 3010     return ExtractElementInst::Create(Ops[0], Ops[1]);

lib/IR/Instructions.cpp

 1709                 OperandTraits<ExtractElementInst>::op_begin(this),
 1723                 OperandTraits<ExtractElementInst>::op_begin(this),
 4240 ExtractElementInst *ExtractElementInst::cloneImpl() const {
 4241   return ExtractElementInst::Create(getOperand(0), getOperand(1));

lib/IR/Verifier.cpp

  456   void visitExtractElementInst(ExtractElementInst &EI);
 3252 void Verifier::visitExtractElementInst(ExtractElementInst &EI) {

lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp

  194     if (auto E = dyn_cast<ExtractElementInst>(V)) {

lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

  699   if (const ExtractElementInst *EE = dyn_cast<ExtractElementInst>(U)) {
  699   if (const ExtractElementInst *EE = dyn_cast<ExtractElementInst>(U)) {

lib/Target/SystemZ/SystemZISelLowering.cpp

  886       if (isa<ExtractElementInst>(DataOp))

lib/Transforms/InstCombine/InstCombineCasts.cpp

  490   return ExtractElementInst::Create(VecInput, IC.Builder.getInt32(Elt));
 2038   auto *ExtElt = dyn_cast<ExtractElementInst>(BitCast.getOperand(0));
 2038   auto *ExtElt = dyn_cast<ExtractElementInst>(BitCast.getOperand(0));
 2052   return ExtractElementInst::Create(NewBC, ExtElt->getIndexOperand());

lib/Transforms/InstCombine/InstCombineInternal.h

  443   Instruction *visitExtractElementInst(ExtractElementInst &EI);
  597   Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 1079     auto *E = dyn_cast<ExtractElementInst>(IV->getInsertedValueOperand());
 1079     auto *E = dyn_cast<ExtractElementInst>(IV->getInsertedValueOperand());

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

   84 Instruction *InstCombiner::scalarizePHI(ExtractElementInst &EI, PHINode *PN) {
   92     if (ExtractElementInst *EU = dyn_cast<ExtractElementInst>(U)) {
   92     if (ExtractElementInst *EU = dyn_cast<ExtractElementInst>(U)) {
  131           ExtractElementInst::Create(B0->getOperand(opId), Elt,
  140       Instruction *newEI = ExtractElementInst::Create(PHIInVal, Elt, "");
  162 static Instruction *foldBitcastExtElt(ExtractElementInst &Ext,
  265     ExtractElementInst *EEI = cast<ExtractElementInst>(UserInstr);
  265     ExtractElementInst *EEI = cast<ExtractElementInst>(UserInstr);
  319 Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
  425         return ExtractElementInst::Create(Src,
  487     } else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
  487     } else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
  523                                    ExtractElementInst *ExtElt,
  587     ExtractElementInst *OldExt = dyn_cast<ExtractElementInst>(U);
  587     ExtractElementInst *OldExt = dyn_cast<ExtractElementInst>(U);
  590     auto *NewExt = ExtractElementInst::Create(WideVec, OldExt->getOperand(1));
  590     auto *NewExt = ExtractElementInst::Create(WideVec, OldExt->getOperand(1));
  630     if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
  630     if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  498       isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  450   void visitExtractElementInst(ExtractElementInst &I);
 1418 void DFSanVisitor::visitExtractElementInst(ExtractElementInst &I) {

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1858   void visitExtractElementInst(ExtractElementInst &I) {

lib/Transforms/Scalar/EarlyCSE.cpp

  114            isa<ExtractElementInst>(Inst) || isa<InsertElementInst>(Inst) ||

lib/Transforms/Scalar/LICM.cpp

 1039           isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  595   if (isa<ExtractElementInst>(I))
  639       !isa<ExtractElementInst>(V) && !isa<InsertElementInst>(V) &&
  792            isa<ExtractElementInst>(BDV) || isa<InsertElementInst>(BDV) ||
  831       } else if (auto *EE = dyn_cast<ExtractElementInst>(Current)) {
  831       } else if (auto *EE = dyn_cast<ExtractElementInst>(Current)) {
  892       } else if (auto *EE = dyn_cast<ExtractElementInst>(BDV)) {
  892       } else if (auto *EE = dyn_cast<ExtractElementInst>(BDV)) {
  940     if (State.isBase() && isa<ExtractElementInst>(I) &&
  942       auto *EE = cast<ExtractElementInst>(I);
  942       auto *EE = cast<ExtractElementInst>(I);
  946       auto *BaseInst = ExtractElementInst::Create(
  946       auto *BaseInst = ExtractElementInst::Create(
  974       } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {
  974       } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {
  977         return ExtractElementInst::Create(Undef, EE->getIndexOperand(), Name,
 1086     } else if (auto *BaseEE =
 1087                    dyn_cast<ExtractElementInst>(State.getBaseValue())) {
 1088       Value *InVal = cast<ExtractElementInst>(BDV)->getVectorOperand();

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  788             const ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(U);
  788             const ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(U);
  834             const ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(U);
  834             const ExtractElementInst *EEI = dyn_cast<ExtractElementInst>(U);

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

  721           isa<ExtractElementInst>(I)) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 3170     return isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
 3375       } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {
 3375       } else if (auto *EE = dyn_cast<ExtractElementInst>(I)) {

lib/Transforms/Vectorize/SLPVectorizer.cpp

  266   auto *EI0 = cast<ExtractElementInst>(VL[0]);
  266   auto *EI0 = cast<ExtractElementInst>(VL[0]);
  273     auto *EI = cast<ExtractElementInst>(VL[I]);
  273     auto *EI = cast<ExtractElementInst>(VL[I]);
 2950                 cast<ExtractElementInst>(V)->getIndexOperand());
 2975                 cast<ExtractElementInst>(VL[I])->getIndexOperand());
 2989                 cast<ExtractElementInst>(V)->getIndexOperand());
 4452       if (!isa<InsertElementInst>(In) && !isa<ExtractElementInst>(In))
 6186           if (!isa<ExtractElementInst>(RHS) ||
 6190           if (!isa<ExtractElementInst>(LHS) ||
 6194           if (!isa<ExtractElementInst>(LHS) || !isa<ExtractElementInst>(RHS))
 6194           if (!isa<ExtractElementInst>(LHS) || !isa<ExtractElementInst>(RHS))
 6848                     [](Value *V) { return isa<ExtractElementInst>(V); }) &&

tools/clang/lib/CodeGen/Address.h

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

tools/clang/lib/CodeGen/CGExprScalar.cpp

 1818         llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
 1818         llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);

tools/llvm-stress/llvm-stress.cpp

  484     Value *V = ExtractElementInst::Create(Val0,

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };