[opaque pointer types] [NFC] gep_type_{begin,end} now take source element type and address space.

[dblaikie]

Looks good - thanks!

include/llvm/Analysis/TargetTransformInfoImpl.h

unsigned getGEPCost(Type *PointeeType, const Value *Ptr,
     }
     bool HasBaseReg = (BaseGV == nullptr);
     int64_t BaseOffset = 0;
     int64_t Scale = 0;
 
     // Assumes the address space is 0 when Ptr is nullptr.
     unsigned AS =
         (Ptr == nullptr ? 0 : Ptr->getType()->getPointerAddressSpace());
-    auto GTI = gep_type_begin(PointerType::get(PointeeType, AS), Operands);
+    auto GTI = gep_type_begin(PointeeType, AS, Operands);
     for (auto I = Operands.begin(); I != Operands.end(); ++I, ++GTI) {
       // We assume that the cost of Scalar GEP with constant index and the
       // cost of Vector GEP with splat constant index are the same.
       const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
       if (!ConstIdx)
         if (auto Splat = getSplatValue(*I))
           ConstIdx = dyn_cast<ConstantInt>(Splat);
       if (isa<SequentialType>(*GTI)) {

include/llvm/IR/GetElementPtrTypeIterator.h

typedef std::iterator<std::forward_iterator_tag,
                           Type *, ptrdiff_t> super;
 
     ItTy OpIt;
     PointerIntPair<Type *, 1> CurTy;
     unsigned AddrSpace;
     generic_gep_type_iterator() {}
   public:
 
-    static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
-      generic_gep_type_iterator I;
-      I.CurTy.setPointer(Ty);
-      I.OpIt = It;
-      return I;
-    }
     static generic_gep_type_iterator begin(Type *Ty, unsigned AddrSpace,
                                            ItTy It) {
       generic_gep_type_iterator I;
       I.CurTy.setPointer(Ty);
       I.CurTy.setInt(true);
       I.AddrSpace = AddrSpace;
       I.OpIt = It;
       return I;
return gep_type_iterator::begin(
         GEP.op_begin() + 1);
   }
   inline gep_type_iterator gep_type_end(const User &GEP) {
     return gep_type_iterator::end(GEP.op_end());
   }
 
   template<typename T>
   inline generic_gep_type_iterator<const T *>
-  gep_type_begin(Type *Op0, ArrayRef<T> A) {
-    return generic_gep_type_iterator<const T *>::begin(Op0, A.begin());
+  gep_type_begin(Type *Op0, unsigned AS, ArrayRef<T> A) {
+    return generic_gep_type_iterator<const T *>::begin(Op0, AS, A.begin());
   }
 
   template<typename T>
   inline generic_gep_type_iterator<const T *>
-  gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
+  gep_type_end(Type * /*Op0*/, unsigned /*AS*/, ArrayRef<T> A) {
     return generic_gep_type_iterator<const T *>::end(A.end());
   }
 } // end namespace llvm
 
 #endif

lib/IR/DataLayout.cpp

 }
 
 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
                                       ArrayRef<Value *> Indices) const {
   Type *Ty = ptrTy;
   assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
   uint64_t Result = 0;
 
+  // We can use 0 as the address space as we don't need
+  // to get pointer types back from gep_type_iterator.
+  unsigned AS = 0;
   generic_gep_type_iterator<Value* const*>
-    TI = gep_type_begin(ptrTy, Indices);
+    TI = gep_type_begin(ptrTy->getPointerElementType(), AS, Indices);
   for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
        ++CurIDX, ++TI) {
     if (StructType *STy = dyn_cast<StructType>(*TI)) {
       assert(Indices[CurIDX]->getType() ==
              Type::getInt32Ty(ptrTy->getContext()) &&
              "Illegal struct idx");
       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();