Home | History | Annotate | Download | only in IR
      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 
     21 namespace 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