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/User.h"
20
21namespace llvm {
22  template<typename ItTy = User::const_op_iterator>
23  class generic_gep_type_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;
30    generic_gep_type_iterator() {}
31  public:
32
33    static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
34      generic_gep_type_iterator I;
35      I.CurTy = Ty;
36      I.OpIt = It;
37      return I;
38    }
39    static generic_gep_type_iterator end(ItTy It) {
40      generic_gep_type_iterator I;
41      I.CurTy = nullptr;
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
68    generic_gep_type_iterator& operator++() {   // Preincrement
69      if (CompositeType *CT = dyn_cast<CompositeType>(CurTy)) {
70        CurTy = CT->getTypeAtIndex(getOperand());
71      } else {
72        CurTy = nullptr;
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
83  typedef generic_gep_type_iterator<> gep_type_iterator;
84
85  inline gep_type_iterator gep_type_begin(const User *GEP) {
86    return gep_type_iterator::begin
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) {
93    return gep_type_iterator::begin
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 *>
102  gep_type_begin(Type *Op0, ArrayRef<T> A) {
103    return generic_gep_type_iterator<const T *>::begin(Op0, A.begin());
104  }
105
106  template<typename T>
107  inline generic_gep_type_iterator<const T *>
108  gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
109    return generic_gep_type_iterator<const T *>::end(A.end());
110  }
111} // end namespace llvm
112
113#endif
114