LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GetElementPtrTypeIterator.h
Go to the documentation of this file.
1 //===- llvm/Support/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_SUPPORT_GETELEMENTPTRTYPEITERATOR_H
16 #define LLVM_SUPPORT_GETELEMENTPTRTYPEITERATOR_H
17 
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/User.h"
20 
21 namespace llvm {
22  template<typename ItTy = User::const_op_iterator>
24  : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
25  typedef std::iterator<std::forward_iterator_tag,
26  Type *, ptrdiff_t> super;
27 
28  ItTy OpIt;
29  Type *CurTy;
31  public:
32 
33  static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
35  I.CurTy = Ty;
36  I.OpIt = It;
37  return I;
38  }
39  static generic_gep_type_iterator end(ItTy It) {
41  I.CurTy = 0;
42  I.OpIt = It;
43  return I;
44  }
45 
46  bool operator==(const generic_gep_type_iterator& x) const {
47  return OpIt == x.OpIt;
48  }
49  bool operator!=(const generic_gep_type_iterator& x) const {
50  return !operator==(x);
51  }
52 
53  Type *operator*() const {
54  return CurTy;
55  }
56 
57  Type *getIndexedType() const {
58  CompositeType *CT = cast<CompositeType>(CurTy);
59  return CT->getTypeAtIndex(getOperand());
60  }
61 
62  // This is a non-standard operator->. It allows you to call methods on the
63  // current type directly.
64  Type *operator->() const { return operator*(); }
65 
66  Value *getOperand() const { return *OpIt; }
67 
69  if (CompositeType *CT = dyn_cast<CompositeType>(CurTy)) {
70  CurTy = CT->getTypeAtIndex(getOperand());
71  } else {
72  CurTy = 0;
73  }
74  ++OpIt;
75  return *this;
76  }
77 
78  generic_gep_type_iterator operator++(int) { // Postincrement
79  generic_gep_type_iterator tmp = *this; ++*this; return tmp;
80  }
81  };
82 
84 
85  inline gep_type_iterator gep_type_begin(const User *GEP) {
87  (GEP->getOperand(0)->getType()->getScalarType(), GEP->op_begin()+1);
88  }
89  inline gep_type_iterator gep_type_end(const User *GEP) {
90  return gep_type_iterator::end(GEP->op_end());
91  }
92  inline gep_type_iterator gep_type_begin(const User &GEP) {
94  (GEP.getOperand(0)->getType()->getScalarType(), GEP.op_begin()+1);
95  }
96  inline gep_type_iterator gep_type_end(const User &GEP) {
97  return gep_type_iterator::end(GEP.op_end());
98  }
99 
100  template<typename T>
101  inline generic_gep_type_iterator<const T *>
104  }
105 
106  template<typename T>
107  inline generic_gep_type_iterator<const T *>
110  }
111 } // end namespace llvm
112 
113 #endif
generic_gep_type_iterator gep_type_iterator
iterator end() const
Definition: ArrayRef.h:98
gep_type_iterator gep_type_end(const User *GEP)
op_iterator op_begin()
Definition: User.h:116
bool operator==(const generic_gep_type_iterator &x) const
generic_gep_type_iterator & operator++()
static generic_gep_type_iterator end(ItTy It)
op_iterator op_end()
Definition: User.h:118
Type * getTypeAtIndex(const Value *V)
Definition: Type.cpp:627
iterator begin() const
Definition: ArrayRef.h:97
Value * getOperand(unsigned i) const
Definition: User.h:88
static generic_gep_type_iterator begin(Type *Ty, ItTy It)
Type * getType() const
Definition: Value.h:111
generic_gep_type_iterator operator++(int)
#define I(x, y, z)
Definition: MD5.cpp:54
const Type * getScalarType() const
Definition: Type.cpp:51
LLVM Value Representation.
Definition: Value.h:66
bool operator!=(const generic_gep_type_iterator &x) const
gep_type_iterator gep_type_begin(const User *GEP)