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

File indexing completed on 2026-05-10 08:43:16

 //===- PtrUseVisitor.h - InstVisitors over a pointers uses ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
 /// This file provides a collection of visitors which walk the (instruction)
 /// uses of a pointer. These visitors all provide the same essential behavior
 /// as an InstVisitor with similar template-based flexibility and
 /// implementation strategies.
 ///
 /// These can be used, for example, to quickly analyze the uses of an alloca,
 /// global variable, or function argument.
 ///
 /// FIXME: Provide a variant which doesn't track offsets and is cheaper.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_PTRUSEVISITOR_H
 #define LLVM_ANALYSIS_PTRUSEVISITOR_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include <cassert>
 #include <type_traits>
 
 namespace llvm {
 class DataLayout;
 
 namespace detail {
 
 /// Implementation of non-dependent functionality for \c PtrUseVisitor.
 ///
 /// See \c PtrUseVisitor for the public interface and detailed comments about
 /// usage. This class is just a helper base class which is not templated and
 /// contains all common code to be shared between different instantiations of
 /// PtrUseVisitor.
 class PtrUseVisitorBase {
 public:
   /// This class provides information about the result of a visit.
   ///
   /// After walking all the users (recursively) of a pointer, the basic
   /// infrastructure records some commonly useful information such as escape
   /// analysis and whether the visit completed or aborted early.
   class PtrInfo {
   public:
     /// Reset the pointer info, clearing all state.
     void reset() {
       AbortedInfo = nullptr;
       EscapedInfo = nullptr;
     }
 
     /// Did we abort the visit early?
     bool isAborted() const { return AbortedInfo != nullptr; }
 
     /// Is the pointer escaped at some point?
     bool isEscaped() const { return EscapedInfo != nullptr; }
 
     /// Is the pointer escaped into a read-only nocapture call at some point?
     bool isEscapedReadOnly() const { return EscapedReadOnly != nullptr; }
 
     /// Get the instruction causing the visit to abort.
     /// \returns a pointer to the instruction causing the abort if one is
     /// available; otherwise returns null.
     Instruction *getAbortingInst() const { return AbortedInfo; }
 
     /// Get the instruction causing the pointer to escape.
     /// \returns a pointer to the instruction which escapes the pointer if one
     /// is available; otherwise returns null.
     Instruction *getEscapingInst() const { return EscapedInfo; }
 
     /// Get the instruction causing the pointer to escape which is a read-only
     /// nocapture call.
     Instruction *getEscapedReadOnlyInst() const { return EscapedReadOnly; }
 
     /// Mark the visit as aborted. Intended for use in a void return.
     /// \param I The instruction which caused the visit to abort, if available.
     void setAborted(Instruction *I) {
       assert(I && "Expected a valid pointer in setAborted");
       AbortedInfo = I;
     }
 
     /// Mark the pointer as escaped. Intended for use in a void return.
     /// \param I The instruction which escapes the pointer, if available.
     void setEscaped(Instruction *I) {
       assert(I && "Expected a valid pointer in setEscaped");
       EscapedInfo = I;
     }
 
     /// Mark the pointer as escaped into a readonly-nocapture call.
     void setEscapedReadOnly(Instruction *I) {
       assert(I && "Expected a valid pointer in setEscapedReadOnly");
       EscapedReadOnly = I;
     }
 
     /// Mark the pointer as escaped, and the visit as aborted. Intended
     /// for use in a void return.
     /// \param I The instruction which both escapes the pointer and aborts the
     /// visit, if available.
     void setEscapedAndAborted(Instruction *I) {
       setEscaped(I);
       setAborted(I);
     }
 
   private:
     Instruction *AbortedInfo = nullptr;
     Instruction *EscapedInfo = nullptr;
     Instruction *EscapedReadOnly = nullptr;
   };
 
 protected:
   const DataLayout &DL;
 
   /// \name Visitation infrastructure
   /// @{
 
   /// The info collected about the pointer being visited thus far.
   PtrInfo PI;
 
   /// A struct of the data needed to visit a particular use.
   ///
   /// This is used to maintain a worklist fo to-visit uses. This is used to
   /// make the visit be iterative rather than recursive.
   struct UseToVisit {
     using UseAndIsOffsetKnownPair = PointerIntPair<Use *, 1, bool>;
 
     UseAndIsOffsetKnownPair UseAndIsOffsetKnown;
     APInt Offset;
   };
 
   /// The worklist of to-visit uses.
   SmallVector<UseToVisit, 8> Worklist;
 
   /// A set of visited uses to break cycles in unreachable code.
   SmallPtrSet<Use *, 8> VisitedUses;
 
   /// @}
 
   /// \name Per-visit state
   /// This state is reset for each instruction visited.
   /// @{
 
   /// The use currently being visited.
   Use *U;
 
   /// True if we have a known constant offset for the use currently
   /// being visited.
   bool IsOffsetKnown;
 
   /// The constant offset of the use if that is known.
   APInt Offset;
 
   /// @}
 
   /// Note that the constructor is protected because this class must be a base
   /// class, we can't create instances directly of this class.
   PtrUseVisitorBase(const DataLayout &DL) : DL(DL) {}
 
   /// Enqueue the users of this instruction in the visit worklist.
   ///
   /// This will visit the users with the same offset of the current visit
   /// (including an unknown offset if that is the current state).
   void enqueueUsers(Value &I);
 
   /// Walk the operands of a GEP and adjust the offset as appropriate.
   ///
   /// This routine does the heavy lifting of the pointer walk by computing
   /// offsets and looking through GEPs.
   bool adjustOffsetForGEP(GetElementPtrInst &GEPI);
 };
 
 } // end namespace detail
 
 /// A base class for visitors over the uses of a pointer value.
 ///
 /// Once constructed, a user can call \c visit on a pointer value, and this
 /// will walk its uses and visit each instruction using an InstVisitor. It also
 /// provides visit methods which will recurse through any pointer-to-pointer
 /// transformations such as GEPs and bitcasts.
 ///
 /// During the visit, the current Use* being visited is available to the
 /// subclass, as well as the current offset from the original base pointer if
 /// known.
 ///
 /// The recursive visit of uses is accomplished with a worklist, so the only
 /// ordering guarantee is that an instruction is visited before any uses of it
 /// are visited. Note that this does *not* mean before any of its users are
 /// visited! This is because users can be visited multiple times due to
 /// multiple, different uses of pointers derived from the same base.
 ///
 /// A particular Use will only be visited once, but a User may be visited
 /// multiple times, once per Use. This visits may notably have different
 /// offsets.
 ///
 /// All visit methods on the underlying InstVisitor return a boolean. This
 /// return short-circuits the visit, stopping it immediately.
 ///
 /// FIXME: Generalize this for all values rather than just instructions.
 template <typename DerivedT>
 class PtrUseVisitor : protected InstVisitor<DerivedT>,
                       public detail::PtrUseVisitorBase {
   friend class InstVisitor<DerivedT>;
 
   using Base = InstVisitor<DerivedT>;
 
 public:
   PtrUseVisitor(const DataLayout &DL) : PtrUseVisitorBase(DL) {
     static_assert(std::is_base_of<PtrUseVisitor, DerivedT>::value,
                   "Must pass the derived type to this template!");
   }
 
   /// Recursively visit the uses of the given pointer.
   /// \returns An info struct about the pointer. See \c PtrInfo for details.
   /// We may also need to process Argument pointers, so the input uses is
   /// a common Value type.
   PtrInfo visitPtr(Value &I) {
     // This must be a pointer type. Get an integer type suitable to hold
     // offsets on this pointer.
     // FIXME: Support a vector of pointers.
     assert(I.getType()->isPointerTy());
     assert(isa<Instruction>(I) || isa<Argument>(I));
     IntegerType *IntIdxTy = cast<IntegerType>(DL.getIndexType(I.getType()));
     IsOffsetKnown = true;
     Offset = APInt(IntIdxTy->getBitWidth(), 0);
     PI.reset();
 
     // Enqueue the uses of this pointer.
     enqueueUsers(I);
 
     // Visit all the uses off the worklist until it is empty.
     while (!Worklist.empty()) {
       UseToVisit ToVisit = Worklist.pop_back_val();
       U = ToVisit.UseAndIsOffsetKnown.getPointer();
       IsOffsetKnown = ToVisit.UseAndIsOffsetKnown.getInt();
       if (IsOffsetKnown)
         Offset = std::move(ToVisit.Offset);
 
       Instruction *I = cast<Instruction>(U->getUser());
       static_cast<DerivedT*>(this)->visit(I);
       if (PI.isAborted())
         break;
     }
     return PI;
   }
 
 protected:
   void visitStoreInst(StoreInst &SI) {
     if (SI.getValueOperand() == U->get())
       PI.setEscaped(&SI);
   }
 
   void visitBitCastInst(BitCastInst &BC) {
     enqueueUsers(BC);
   }
 
   void visitAddrSpaceCastInst(AddrSpaceCastInst &ASC) {
     enqueueUsers(ASC);
   }
 
   void visitPtrToIntInst(PtrToIntInst &I) {
     PI.setEscaped(&I);
   }
 
   void visitGetElementPtrInst(GetElementPtrInst &GEPI) {
     if (GEPI.use_empty())
       return;
 
     // If we can't walk the GEP, clear the offset.
     if (!adjustOffsetForGEP(GEPI)) {
       IsOffsetKnown = false;
       Offset = APInt();
     }
 
     // Enqueue the users now that the offset has been adjusted.
     enqueueUsers(GEPI);
   }
 
   // No-op intrinsics which we know don't escape the pointer to logic in
   // some other function.
   void visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) {}
   void visitMemIntrinsic(MemIntrinsic &I) {}
   void visitIntrinsicInst(IntrinsicInst &II) {
     switch (II.getIntrinsicID()) {
     default:
       return Base::visitIntrinsicInst(II);
 
     // We escape pointers used by a fake_use to prevent SROA from transforming
     // them.
     case Intrinsic::fake_use:
       PI.setEscaped(&II);
       return;
 
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
       return; // No-op intrinsics.
     }
   }
 
   // Generically, arguments to calls and invokes escape the pointer to some
   // other function. Mark that.
   void visitCallBase(CallBase &CB) {
     PI.setEscaped(&CB);
     Base::visitCallBase(CB);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_PTRUSEVISITOR_H

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