EIC code displayed by LXR master/​include/​llvm/​IR/​GetElementPtrTypeIterator.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:44:00

 //===- GetElementPtrTypeIterator.h ------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements an iterator for walking through the types indexed by
 // getelementptr instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_GETELEMENTPTRTYPEITERATOR_H
 #define LLVM_IR_GETELEMENTPTRTYPEITERATOR_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/User.h"
 #include "llvm/Support/Casting.h"
 #include <cstddef>
 #include <cstdint>
 #include <iterator>
 
 namespace llvm {
 
 template <typename ItTy = User::const_op_iterator>
 class generic_gep_type_iterator {
 
   ItTy OpIt;
   // We use two different mechanisms to store the type a GEP index applies to.
   // In some cases, we need to know the outer aggregate type the index is
   // applied within, e.g. a struct. In such cases, we store the aggregate type
   // in the iterator, and derive the element type on the fly.
   //
   // However, this is not always possible, because for the outermost index there
   // is no containing type. In such cases, or if the containing type is not
   // relevant, e.g. for arrays, the element type is stored as Type* in CurTy.
   //
   // If CurTy contains a Type* value, this does not imply anything about the
   // type itself, because it is the element type and not the outer type.
   // In particular, Type* can be a struct type.
   //
   // Consider this example:
   //
   //    %my.struct = type { i32, [ 4 x float ] }
   //    [...]
   //    %gep = getelementptr %my.struct, ptr %ptr, i32 10, i32 1, 32 3
   //
   // Iterating over the indices of this GEP, CurTy will contain the following
   // values:
   //    * i32 10: The outer index always operates on the GEP value type.
   //              CurTy contains a Type*       pointing at `%my.struct`.
   //    * i32 1:  This index is within a struct.
   //              CurTy contains a StructType* pointing at `%my.struct`.
   //    * i32 3:  This index is within an array. We reuse the "flat" indexing
   //              for arrays which is also used in the top level GEP index.
   //              CurTy contains a Type*       pointing at `float`.
   //
   // Vectors are handled separately because the layout of vectors is different
   // for overaligned elements: Vectors are always bit-packed, whereas arrays
   // respect ABI alignment of the elements.
   PointerUnion<StructType *, VectorType *, Type *> CurTy;
 
   generic_gep_type_iterator() = default;
 
 public:
   using iterator_category = std::forward_iterator_tag;
   using value_type = Type *;
   using difference_type = std::ptrdiff_t;
   using pointer = value_type *;
   using reference = value_type &;
 
   static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
     generic_gep_type_iterator I;
     I.CurTy = Ty;
     I.OpIt = It;
     return I;
   }
 
   static generic_gep_type_iterator end(ItTy It) {
     generic_gep_type_iterator I;
     I.OpIt = It;
     return I;
   }
 
   bool operator==(const generic_gep_type_iterator &x) const {
     return OpIt == x.OpIt;
   }
 
   bool operator!=(const generic_gep_type_iterator &x) const {
     return !operator==(x);
   }
 
   // FIXME: Make this the iterator's operator*() after the 4.0 release.
   // operator*() had a different meaning in earlier releases, so we're
   // temporarily not giving this iterator an operator*() to avoid a subtle
   // semantics break.
   Type *getIndexedType() const {
     if (auto *T = dyn_cast_if_present<Type *>(CurTy))
       return T;
     if (auto *VT = dyn_cast_if_present<VectorType *>(CurTy))
       return VT->getElementType();
     return cast<StructType *>(CurTy)->getTypeAtIndex(getOperand());
   }
 
   Value *getOperand() const { return const_cast<Value *>(&**OpIt); }
 
   generic_gep_type_iterator &operator++() { // Preincrement
     Type *Ty = getIndexedType();
     if (auto *ATy = dyn_cast<ArrayType>(Ty))
       CurTy = ATy->getElementType();
     else if (auto *VTy = dyn_cast<VectorType>(Ty))
       CurTy = VTy;
     else
       CurTy = dyn_cast<StructType>(Ty);
     ++OpIt;
     return *this;
   }
 
   generic_gep_type_iterator operator++(int) { // Postincrement
     generic_gep_type_iterator tmp = *this;
     ++*this;
     return tmp;
   }
 
   // All of the below API is for querying properties of the "outer type", i.e.
   // the type that contains the indexed type. Most of the time this is just
   // the type that was visited immediately prior to the indexed type, but for
   // the first element this is an unbounded array of the GEP's source element
   // type, for which there is no clearly corresponding IR type (we've
   // historically used a pointer type as the outer type in this case, but
   // pointers will soon lose their element type).
   //
   // FIXME: Most current users of this class are just interested in byte
   // offsets (a few need to know whether the outer type is a struct because
   // they are trying to replace a constant with a variable, which is only
   // legal for arrays, e.g. canReplaceOperandWithVariable in SimplifyCFG.cpp);
   // we should provide a more minimal API here that exposes not much more than
   // that.
 
   bool isStruct() const { return isa<StructType *>(CurTy); }
   bool isVector() const { return isa<VectorType *>(CurTy); }
   bool isSequential() const { return !isStruct(); }
 
   // For sequential GEP indices (all except those into structs), the index value
   // can be translated into a byte offset by multiplying with an element stride.
   // This function returns this stride, which both depends on the element type,
   // and the containing aggregate type, as vectors always tightly bit-pack their
   // elements.
   TypeSize getSequentialElementStride(const DataLayout &DL) const {
     assert(isSequential());
     Type *ElemTy = getIndexedType();
     if (isVector()) {
       assert(DL.typeSizeEqualsStoreSize(ElemTy) && "Not byte-addressable");
       return DL.getTypeStoreSize(ElemTy);
     }
     return DL.getTypeAllocSize(ElemTy);
   }
 
   StructType *getStructType() const { return cast<StructType *>(CurTy); }
 
   StructType *getStructTypeOrNull() const {
     return dyn_cast_if_present<StructType *>(CurTy);
   }
 };
 
   using gep_type_iterator = generic_gep_type_iterator<>;
 
   inline gep_type_iterator gep_type_begin(const User *GEP) {
     auto *GEPOp = cast<GEPOperator>(GEP);
     return gep_type_iterator::begin(
         GEPOp->getSourceElementType(),
         GEP->op_begin() + 1);
   }
 
   inline gep_type_iterator gep_type_end(const User *GEP) {
     return gep_type_iterator::end(GEP->op_end());
   }
 
   inline gep_type_iterator gep_type_begin(const User &GEP) {
     auto &GEPOp = cast<GEPOperator>(GEP);
     return gep_type_iterator::begin(
         GEPOp.getSourceElementType(),
         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());
   }
 
   template<typename T>
   inline generic_gep_type_iterator<const T *>
   gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
     return generic_gep_type_iterator<const T *>::end(A.end());
   }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_GETELEMENTPTRTYPEITERATOR_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team