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

Declarations

include/llvm/Analysis/BasicAliasAnalysis.h

   40 class GEPOperator;

include/llvm/Analysis/MemoryBuiltins.h

   39 class GEPOperator;

include/llvm/Analysis/ScalarEvolution.h

   61 class GEPOperator;

include/llvm/Analysis/ValueTracking.h

   34 class GEPOperator;

lib/Transforms/InstCombine/InstCombineInternal.h

   58 class GEPOperator;

References

include/llvm/Analysis/BasicAliasAnalysis.h

  175   static bool isGEPBaseAtNegativeOffset(const GEPOperator *GEPOp,
  198   AliasResult aliasGEP(const GEPOperator *V1, LocationSize V1Size,

include/llvm/Analysis/MemoryBuiltins.h

  266   SizeOffsetType visitGEPOperator(GEPOperator &GEP);
  335   SizeOffsetEvalType visitGEPOperator(GEPOperator &GEP);

include/llvm/Analysis/ScalarEvolution.h

  572   const SCEV *getGEPExpr(GEPOperator *GEP,
 1482   const SCEV *createNodeForGEP(GEPOperator *GEP);

include/llvm/Analysis/TargetTransformInfoImpl.h

  857     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
  857     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {

include/llvm/Analysis/Utils/Local.h

   30   GEPOperator *GEPOp = cast<GEPOperator>(GEP);
   30   GEPOperator *GEPOp = cast<GEPOperator>(GEP);

include/llvm/Analysis/ValueTracking.h

  264   bool isGEPBasedOnPointerToString(const GEPOperator *GEP,

include/llvm/IR/GetElementPtrTypeIterator.h

  128     auto *GEPOp = cast<GEPOperator>(GEP);
  139     auto &GEPOp = cast<GEPOperator>(GEP);

include/llvm/Support/Casting.h

   57   static inline bool doit(const From &Val) {
   58     return To::classof(&Val);
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  104   static inline bool doit(const From *Val) {
  106     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,
  165   using ret_type = To &;       // Normal case, return Ty&
  168   using ret_type = const To &; // Normal case, return Ty&
  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;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  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;

include/llvm/Transforms/Utils/FunctionComparator.h

  345   int cmpGEPs(const GEPOperator *GEPL, const GEPOperator *GEPR) const;
  345   int cmpGEPs(const GEPOperator *GEPL, const GEPOperator *GEPR) const;
  348     return cmpGEPs(cast<GEPOperator>(GEPL), cast<GEPOperator>(GEPR));
  348     return cmpGEPs(cast<GEPOperator>(GEPL), cast<GEPOperator>(GEPR));

lib/Analysis/BasicAliasAnalysis.cpp

  492     const GEPOperator *GEPOp = dyn_cast<GEPOperator>(Op);
  492     const GEPOperator *GEPOp = dyn_cast<GEPOperator>(Op);
 1083 static AliasResult aliasSameBasePointerGEPs(const GEPOperator *GEP1,
 1085                                             const GEPOperator *GEP2,
 1271 bool BasicAAResult::isGEPBaseAtNegativeOffset(const GEPOperator *GEPOp,
 1311     const GEPOperator *GEP1, LocationSize V1Size, const AAMDNodes &V1AAInfo,
 1340   if (const GEPOperator *GEP2 = dyn_cast<GEPOperator>(V2)) {
 1340   if (const GEPOperator *GEP2 = dyn_cast<GEPOperator>(V2)) {
 1651         if (GEPOperator *PV1GEP = dyn_cast<GEPOperator>(PV1)) {
 1651         if (GEPOperator *PV1GEP = dyn_cast<GEPOperator>(PV1)) {
 1678         if (GEPOperator *PV1GEP = dyn_cast<GEPOperator>(PV1)) {
 1678         if (GEPOperator *PV1GEP = dyn_cast<GEPOperator>(PV1)) {
 1836   if (!isa<GEPOperator>(V1) && isa<GEPOperator>(V2)) {
 1836   if (!isa<GEPOperator>(V1) && isa<GEPOperator>(V2)) {
 1842   if (const GEPOperator *GV1 = dyn_cast<GEPOperator>(V1)) {
 1842   if (const GEPOperator *GV1 = dyn_cast<GEPOperator>(V1)) {

lib/Analysis/CFLGraph.h

  316     void visitGEP(GEPOperator &GEPOp) {
  328       auto *GEPOp = cast<GEPOperator>(&Inst);
  328       auto *GEPOp = cast<GEPOperator>(&Inst);
  512         auto GEPOp = cast<GEPOperator>(CE);

lib/Analysis/ConstantFolding.cpp

  307   auto *GEP = dyn_cast<GEPOperator>(CE);
  307   auto *GEP = dyn_cast<GEPOperator>(CE);
  819 Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP,
  823   const GEPOperator *InnermostGEP = GEP;
  875   while (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
  875   while (auto *GEP = dyn_cast<GEPOperator>(Ptr)) {
 1030   if (auto *GEP = dyn_cast<GEPOperator>(InstOrCE)) {

lib/Analysis/InlineCost.cpp

  209   bool accumulateGEPOffset(GEPOperator &GEP, APInt &Offset);
  388 bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) {
  573   if (!accumulateGEPOffset(cast<GEPOperator>(I), BaseAndOffset.second))
 1663     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
 1663     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {

lib/Analysis/InstructionSimplify.cpp

 3432     if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) {
 3432     if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) {

lib/Analysis/Loads.cpp

   83   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
   83   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {

lib/Analysis/MemoryBuiltins.cpp

  589     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V))
  589     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V))
  607       return visitGEPOperator(cast<GEPOperator>(*CE));
  747 SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator &GEP) {
  893   } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
  893   } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
  970 ObjectSizeOffsetEvaluator::visitGEPOperator(GEPOperator &GEP) {

lib/Analysis/ScalarEvolution.cpp

 3486 ScalarEvolution::getGEPExpr(GEPOperator *GEP,
 5086         } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(BEValueV)) {
 5086         } else if (GEPOperator *GEP = dyn_cast<GEPOperator>(BEValueV)) {
 5427 const SCEV *ScalarEvolution::createNodeForGEP(GEPOperator *GEP) {
 6483     return createNodeForGEP(cast<GEPOperator>(U));

lib/Analysis/ValueTracking.cpp

 1841 static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth,
 2094     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V))
 2094     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V))
 3453 bool llvm::isGEPBasedOnPointerToString(const GEPOperator *GEP,
 3484   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
 3484   if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
 3719     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
 3719     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
 5715 getOffsetFromIndex(const GEPOperator *GEP, unsigned Idx, const DataLayout &DL) {
 5755   const GEPOperator *GEP1 = dyn_cast<GEPOperator>(Ptr1);
 5755   const GEPOperator *GEP1 = dyn_cast<GEPOperator>(Ptr1);
 5756   const GEPOperator *GEP2 = dyn_cast<GEPOperator>(Ptr2);
 5756   const GEPOperator *GEP2 = dyn_cast<GEPOperator>(Ptr2);
 5770     const GEPOperator *GEP_T = GEP;
 5783       GEP_T = dyn_cast<GEPOperator>(Op0);

lib/Bitcode/Writer/BitcodeWriter.cpp

 2459         const auto *GO = cast<GEPOperator>(C);
 2459         const auto *GO = cast<GEPOperator>(C);

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2206     cast<GEPOperator>(CE)->accumulateConstantOffset(getDataLayout(), OffsetAI);

lib/CodeGen/CodeGenPrepare.cpp

 4169           if (!cast<GEPOperator>(AddrInst)->isInBounds())
 4204     if (!cast<GEPOperator>(AddrInst)->isInBounds())

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3868         if (int64_t(Offset) >= 0 && cast<GEPOperator>(I).isInBounds())
 3897         if (Offs.isNonNegative() && cast<GEPOperator>(I).isInBounds())
 3939   if (PtrMemTy != PtrTy && !cast<GEPOperator>(I).isInBounds())

lib/ExecutionEngine/ExecutionEngine.cpp

  650       cast<GEPOperator>(CE)->accumulateConstantOffset(DL, Offset);

lib/IR/AsmWriter.cpp

 1283   } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
 1283   } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
 1516     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
 1516     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {

lib/IR/ConstantFold.cpp

  550                !cast<GEPOperator>(CE)->getInRangeIndex().hasValue() &&
  647         GEPOperator *GEPO = cast<GEPOperator>(CE);
  647         GEPOperator *GEPO = cast<GEPOperator>(CE);
 1658       GEPOperator *CE1GEP = cast<GEPOperator>(CE1);
 1658       GEPOperator *CE1GEP = cast<GEPOperator>(CE1);
 1724               GEPOperator *CE2GEP = cast<GEPOperator>(CE2);
 1724               GEPOperator *CE2GEP = cast<GEPOperator>(CE2);
 2290         Optional<unsigned> IRIndex = cast<GEPOperator>(CE)->getInRangeIndex();
 2295             cast<GEPOperator>(CE)->getSourceElementType(), CE->getOperand(0),
 2296             NewIndices, InBounds && cast<GEPOperator>(CE)->isInBounds(),

lib/IR/Constants.cpp

 1277     auto *GEPO = cast<GEPOperator>(this);
 2055   unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
 3019     const auto *GO = cast<GEPOperator>(this);
 3019     const auto *GO = cast<GEPOperator>(this);

lib/IR/Instructions.cpp

 1687   cast<GEPOperator>(this)->setIsInBounds(B);
 1691   return cast<GEPOperator>(this)->isInBounds();
 1697   return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset);

lib/IR/Value.cpp

  476     if (auto *GEP = dyn_cast<GEPOperator>(V)) {
  565     if (auto *GEP = dyn_cast<GEPOperator>(V)) {

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

 2033     cast<GEPOperator>(CE)->accumulateConstantOffset(DL, OffsetAI);

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

  286     return cast<GEPOperator>(C)->isInBounds()
  288                      cast<GEPOperator>(C)->getSourceElementType(),
  292                      cast<GEPOperator>(C)->getSourceElementType(),

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  266     if (!cast<GEPOperator>(U)->isInBounds())

lib/Target/XCore/XCoreLowerThreadLocal.cpp

   85           cast<GEPOperator>(CE)->getSourceElementType(), CEOps[0],

lib/Transforms/IPO/GlobalSplit.cpp

   59     auto *GEP = dyn_cast<GEPOperator>(U);
   59     auto *GEP = dyn_cast<GEPOperator>(U);
  116     auto *GEP = cast<GEPOperator>(U);
  116     auto *GEP = cast<GEPOperator>(U);

lib/Transforms/IPO/LowerTypeTests.cpp

  705   if (auto GEP = dyn_cast<GEPOperator>(V)) {

lib/Transforms/InstCombine/InstCombineAddSub.cpp

 1594   GEPOperator *GEP1 = nullptr, *GEP2 = nullptr;
 1598   if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
 1598   if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
 1603     } else if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
 1603     } else if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
 1614   if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
 1614   if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
 1619     } else if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
 1619     } else if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {

lib/Transforms/InstCombine/InstCombineCompares.cpp

  562       if (auto *GEP = dyn_cast<GEPOperator>(V)) {
  562       if (auto *GEP = dyn_cast<GEPOperator>(V)) {
  684     if (auto *GEP = dyn_cast<GEPOperator>(Val)) {
  684     if (auto *GEP = dyn_cast<GEPOperator>(Val)) {
  769     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
  769     if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
  804 static Instruction *transformToIndexedCompare(GEPOperator *GEPLHS, Value *RHS,
  844 Instruction *InstCombiner::foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,
  906   } else if (GEPOperator *GEPRHS = dyn_cast<GEPOperator>(RHS)) {
  906   } else if (GEPOperator *GEPRHS = dyn_cast<GEPOperator>(RHS)) {
 5487   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op0))
 5487   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op0))
 5490   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1))
 5490   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1))

lib/Transforms/InstCombine/InstCombineInternal.h

  901   Instruction *foldGEPICmp(GEPOperator *GEPLHS, Value *RHS,

lib/Transforms/InstCombine/InstructionCombining.cpp

 1150 static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
 1150 static bool shouldMergeGEPs(GEPOperator &GEP, GEPOperator &Src) {
 1780         NewPN->addIncoming(cast<GEPOperator>(I)->getOperand(DI),
 1796   if (auto *Src = dyn_cast<GEPOperator>(PtrOp)) {
 1796   if (auto *Src = dyn_cast<GEPOperator>(PtrOp)) {
 1797     if (!shouldMergeGEPs(*cast<GEPOperator>(&GEP), *Src))
 1853     if (auto *SrcGEP = dyn_cast<GEPOperator>(Src->getOperand(0)))
 1853     if (auto *SrcGEP = dyn_cast<GEPOperator>(Src->getOperand(0)))

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  701       else if (isa<GEPOperator>(Arg) &&
  702                cast<GEPOperator>(Arg)->hasAllZeroIndices())
  703         Arg = cast<GEPOperator>(Arg)->getPointerOperand();

lib/Transforms/Scalar/ConstantHoisting.cpp

  407   auto *GEPO = cast<GEPOperator>(ConstExpr);
  407   auto *GEPO = cast<GEPOperator>(ConstExpr);

lib/Transforms/Scalar/IndVarSimplify.cpp

  196   if (auto *GEP = dyn_cast<GEPOperator>(FromVal)) {
  196   if (auto *GEP = dyn_cast<GEPOperator>(FromVal)) {
  199   if (auto *GEP = dyn_cast<GEPOperator>(ToVal)) {
  199   if (auto *GEP = dyn_cast<GEPOperator>(ToVal)) {

lib/Transforms/Scalar/NaryReassociate.cpp

  386   const SCEV *CandidateExpr = SE->getGEPExpr(cast<GEPOperator>(GEP),

lib/Transforms/Scalar/SROA.cpp

 1608     while (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) {
 1608     while (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) {

lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

  537     const SCEV *BaseExpr = SE->getGEPExpr(cast<GEPOperator>(GEP), IndexExprs);

lib/Transforms/Utils/Evaluator.cpp

  145         cast<GEPOperator>(CE)->isInBounds()) {
  441                                          cast<GEPOperator>(GEP)->isInBounds());

lib/Transforms/Utils/FunctionComparator.cpp

  662 int FunctionComparator::cmpGEPs(const GEPOperator *GEPL,
  663                                 const GEPOperator *GEPR) const {

lib/Transforms/Utils/LoopRotationUtils.cpp

  543       if (!cast<GEPOperator>(I)->hasAllConstantIndices())

lib/Transforms/Utils/SimplifyLibCalls.cpp

  661   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Src)) {
  661   if (GEPOperator *GEP = dyn_cast<GEPOperator>(Src)) {

lib/Transforms/Utils/ValueMapper.cpp

  470     if (auto *GEPO = dyn_cast<GEPOperator>(C))
  470     if (auto *GEPO = dyn_cast<GEPOperator>(C))

tools/clang/lib/CodeGen/Address.h

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

tools/clang/lib/CodeGen/CGExprScalar.cpp

 4577   auto *GEP = cast<llvm::GEPOperator>(GEPVal);
 4577   auto *GEP = cast<llvm::GEPOperator>(GEPVal);

tools/lldb/source/Expression/IRInterpreter.cpp

  286               cast<GEPOperator>(constant_expr)->getSourceElementType();

tools/polly/lib/Analysis/ScopBuilder.cpp

 1430     auto *DescriptorGEP =
 1431         dyn_cast<GEPOperator>(MallocStore->getPointerOperand());

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };