//===- 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 { … }; } // 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 { … }; } // end namespace llvm #endif // LLVM_ANALYSIS_PTRUSEVISITOR_H