include/llvm/IR/GetElementPtrTypeIterator.h

   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/ADT/ArrayRef.h"
  19 #include "llvm/ADT/PointerUnion.h"
  20 #include "llvm/IR/DerivedTypes.h"
  21 #include "llvm/IR/Operator.h"
  22 #include "llvm/IR/User.h"
  23 #include "llvm/Support/Casting.h"
  24 #include <cassert>
  25 #include <cstddef>
  26 #include <cstdint>
  27 #include <iterator>
  28
  29 namespace llvm {
  30
  31   template<typename ItTy = User::const_op_iterator>
  32   class generic_gep_type_iterator
  33     : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
  34     using super = std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t>;
  35
  36     ItTy OpIt;
  37     PointerUnion<StructType *, Type *> CurTy;
  38     enum : uint64_t { Unbounded = -1ull };
  39     uint64_t NumElements = Unbounded;
  40
  41     generic_gep_type_iterator() = default;
  42
  43   public:
  44     static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
  45       generic_gep_type_iterator I;
  46       I.CurTy = Ty;
  47       I.OpIt = It;
  48       return I;
  49     }
  50
  51     static generic_gep_type_iterator end(ItTy It) {
  52       generic_gep_type_iterator I;
  53       I.OpIt = It;
  54       return I;
  55     }
  56
  57     bool operator==(const generic_gep_type_iterator& x) const {
  58       return OpIt == x.OpIt;
  59     }
  60
  61     bool operator!=(const generic_gep_type_iterator& x) const {
  62       return !operator==(x);
  63     }
  64
  65     // FIXME: Make this the iterator's operator*() after the 4.0 release.
  66     // operator*() had a different meaning in earlier releases, so we're
  67     // temporarily not giving this iterator an operator*() to avoid a subtle
  68     // semantics break.
  69     Type *getIndexedType() const {
  70       if (auto *T = CurTy.dyn_cast<Type *>())
  71         return T;
  72       return CurTy.get<StructType *>()->getTypeAtIndex(getOperand());
  73     }
  74
  75     Value *getOperand() const { return const_cast<Value *>(&**OpIt); }
  76
  77     generic_gep_type_iterator& operator++() {   // Preincrement
  78       Type *Ty = getIndexedType();
  79       if (auto *STy = dyn_cast<SequentialType>(Ty)) {
  80         CurTy = STy->getElementType();
  81         NumElements = STy->getNumElements();
  82       } else
  83         CurTy = dyn_cast<StructType>(Ty);
  84       ++OpIt;
  85       return *this;
  86     }
  87
  88     generic_gep_type_iterator operator++(int) { // Postincrement
  89       generic_gep_type_iterator tmp = *this; ++*this; return tmp;
  90     }
  91
  92     // All of the below API is for querying properties of the "outer type", i.e.
  93     // the type that contains the indexed type. Most of the time this is just
  94     // the type that was visited immediately prior to the indexed type, but for
  95     // the first element this is an unbounded array of the GEP's source element
  96     // type, for which there is no clearly corresponding IR type (we've
  97     // historically used a pointer type as the outer type in this case, but
  98     // pointers will soon lose their element type).
  99     //
 100     // FIXME: Most current users of this class are just interested in byte
 101     // offsets (a few need to know whether the outer type is a struct because
 102     // they are trying to replace a constant with a variable, which is only
 103     // legal for arrays, e.g. canReplaceOperandWithVariable in SimplifyCFG.cpp);
 104     // we should provide a more minimal API here that exposes not much more than
 105     // that.
 106
 107     bool isStruct() const { return CurTy.is<StructType *>(); }
 108     bool isSequential() const { return CurTy.is<Type *>(); }
 109
 110     StructType *getStructType() const { return CurTy.get<StructType *>(); }
 111
 112     StructType *getStructTypeOrNull() const {
 113       return CurTy.dyn_cast<StructType *>();
 114     }
 115
 116     bool isBoundedSequential() const {
 117       return isSequential() && NumElements != Unbounded;
 118     }
 119
 120     uint64_t getSequentialNumElements() const {
 121       assert(isBoundedSequential());
 122       return NumElements;
 123     }
 124   };
 125
 126   using gep_type_iterator = generic_gep_type_iterator<>;
 127
 128   inline gep_type_iterator gep_type_begin(const User *GEP) {
 129     auto *GEPOp = cast<GEPOperator>(GEP);
 130     return gep_type_iterator::begin(
 131         GEPOp->getSourceElementType(),
 132         GEP->op_begin() + 1);
 133   }
 134
 135   inline gep_type_iterator gep_type_end(const User *GEP) {
 136     return gep_type_iterator::end(GEP->op_end());
 137   }
 138
 139   inline gep_type_iterator gep_type_begin(const User &GEP) {
 140     auto &GEPOp = cast<GEPOperator>(GEP);
 141     return gep_type_iterator::begin(
 142         GEPOp.getSourceElementType(),
 143         GEP.op_begin() + 1);
 144   }
 145
 146   inline gep_type_iterator gep_type_end(const User &GEP) {
 147     return gep_type_iterator::end(GEP.op_end());
 148   }
 149
 150   template<typename T>
 151   inline generic_gep_type_iterator<const T *>
 152   gep_type_begin(Type *Op0, ArrayRef<T> A) {
 153     return generic_gep_type_iterator<const T *>::begin(Op0, A.begin());
 154   }
 155
 156   template<typename T>
 157   inline generic_gep_type_iterator<const T *>
 158   gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
 159     return generic_gep_type_iterator<const T *>::end(A.end());
 160   }
 161
 162 } // end namespace llvm
 163
 164 #endif // LLVM_IR_GETELEMENTPTRTYPEITERATOR_H