1 //===- GetElementPtrTypeIterator.h ------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements an iterator for walking through the types indexed by 11 // getelementptr instructions. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_IR_GETELEMENTPTRTYPEITERATOR_H 16 #define LLVM_IR_GETELEMENTPTRTYPEITERATOR_H 17 18 #include "llvm/IR/DerivedTypes.h" 19 #include "llvm/IR/Operator.h" 20 #include "llvm/IR/User.h" 21 #include "llvm/ADT/PointerIntPair.h" 22 23 namespace llvm { 24 template<typename ItTy = User::const_op_iterator> 25 class generic_gep_type_iterator 26 : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> { 27 typedef std::iterator<std::forward_iterator_tag, 28 Type *, ptrdiff_t> super; 29 30 ItTy OpIt; 31 PointerIntPair<Type *, 1> CurTy; 32 unsigned AddrSpace; generic_gep_type_iterator()33 generic_gep_type_iterator() {} 34 public: 35 begin(Type * Ty,unsigned AddrSpace,ItTy It)36 static generic_gep_type_iterator begin(Type *Ty, unsigned AddrSpace, 37 ItTy It) { 38 generic_gep_type_iterator I; 39 I.CurTy.setPointer(Ty); 40 I.CurTy.setInt(true); 41 I.AddrSpace = AddrSpace; 42 I.OpIt = It; 43 return I; 44 } end(ItTy It)45 static generic_gep_type_iterator end(ItTy It) { 46 generic_gep_type_iterator I; 47 I.OpIt = It; 48 return I; 49 } 50 51 bool operator==(const generic_gep_type_iterator& x) const { 52 return OpIt == x.OpIt; 53 } 54 bool operator!=(const generic_gep_type_iterator& x) const { 55 return !operator==(x); 56 } 57 58 Type *operator*() const { 59 if (CurTy.getInt()) 60 return CurTy.getPointer()->getPointerTo(AddrSpace); 61 return CurTy.getPointer(); 62 } 63 getIndexedType()64 Type *getIndexedType() const { 65 if (CurTy.getInt()) 66 return CurTy.getPointer(); 67 CompositeType *CT = cast<CompositeType>(CurTy.getPointer()); 68 return CT->getTypeAtIndex(getOperand()); 69 } 70 71 // This is a non-standard operator->. It allows you to call methods on the 72 // current type directly. 73 Type *operator->() const { return operator*(); } 74 getOperand()75 Value *getOperand() const { return const_cast<Value *>(&**OpIt); } 76 77 generic_gep_type_iterator& operator++() { // Preincrement 78 if (CurTy.getInt()) { 79 CurTy.setInt(false); 80 } else if (CompositeType *CT = 81 dyn_cast<CompositeType>(CurTy.getPointer())) { 82 CurTy.setPointer(CT->getTypeAtIndex(getOperand())); 83 } else { 84 CurTy.setPointer(nullptr); 85 } 86 ++OpIt; 87 return *this; 88 } 89 90 generic_gep_type_iterator operator++(int) { // Postincrement 91 generic_gep_type_iterator tmp = *this; ++*this; return tmp; 92 } 93 }; 94 95 typedef generic_gep_type_iterator<> gep_type_iterator; 96 gep_type_begin(const User * GEP)97 inline gep_type_iterator gep_type_begin(const User *GEP) { 98 auto *GEPOp = cast<GEPOperator>(GEP); 99 return gep_type_iterator::begin( 100 GEPOp->getSourceElementType(), 101 cast<PointerType>(GEPOp->getPointerOperandType()->getScalarType()) 102 ->getAddressSpace(), 103 GEP->op_begin() + 1); 104 } gep_type_end(const User * GEP)105 inline gep_type_iterator gep_type_end(const User *GEP) { 106 return gep_type_iterator::end(GEP->op_end()); 107 } gep_type_begin(const User & GEP)108 inline gep_type_iterator gep_type_begin(const User &GEP) { 109 auto &GEPOp = cast<GEPOperator>(GEP); 110 return gep_type_iterator::begin( 111 GEPOp.getSourceElementType(), 112 cast<PointerType>(GEPOp.getPointerOperandType()->getScalarType()) 113 ->getAddressSpace(), 114 GEP.op_begin() + 1); 115 } gep_type_end(const User & GEP)116 inline gep_type_iterator gep_type_end(const User &GEP) { 117 return gep_type_iterator::end(GEP.op_end()); 118 } 119 120 template<typename T> 121 inline generic_gep_type_iterator<const T *> gep_type_begin(Type * Op0,unsigned AS,ArrayRef<T> A)122 gep_type_begin(Type *Op0, unsigned AS, ArrayRef<T> A) { 123 return generic_gep_type_iterator<const T *>::begin(Op0, AS, A.begin()); 124 } 125 126 template<typename T> 127 inline generic_gep_type_iterator<const T *> gep_type_end(Type *,unsigned,ArrayRef<T> A)128 gep_type_end(Type * /*Op0*/, unsigned /*AS*/, ArrayRef<T> A) { 129 return generic_gep_type_iterator<const T *>::end(A.end()); 130 } 131 } // end namespace llvm 132 133 #endif 134