Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Attributor.h --- Module-wide attribute deduction ---------*- 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

//

//===----------------------------------------------------------------------===//

//

// Attributor: An inter procedural (abstract) "attribute" deduction framework.

//

// The Attributor framework is an inter procedural abstract analysis (fixpoint

// iteration analysis). The goal is to allow easy deduction of new attributes as

// well as information exchange between abstract attributes in-flight.

//

// The Attributor class is the driver and the link between the various abstract

// attributes. The Attributor will iterate until a fixpoint state is reached by

// all abstract attributes in-flight, or until it will enforce a pessimistic fix

// point because an iteration limit is reached.

//

// Abstract attributes, derived from the AbstractAttribute class, actually

// describe properties of the code. They can correspond to actual LLVM-IR

// attributes, or they can be more general, ultimately unrelated to LLVM-IR

// attributes. The latter is useful when an abstract attributes provides

// information to other abstract attributes in-flight but we might not want to

// manifest the information. The Attributor allows to query in-flight abstract

// attributes through the `Attributor::getAAFor` method (see the method

// description for an example). If the method is used by an abstract attribute

// P, and it results in an abstract attribute Q, the Attributor will

// automatically capture a potential dependence from Q to P. This dependence

// will cause P to be reevaluated whenever Q changes in the future.

//

// The Attributor will only reevaluate abstract attributes that might have

// changed since the last iteration. That means that the Attribute will not

// revisit all instructions/blocks/functions in the module but only query

// an update from a subset of the abstract attributes.

//

// The update method `AbstractAttribute::updateImpl` is implemented by the

// specific "abstract attribute" subclasses. The method is invoked whenever the

// currently assumed state (see the AbstractState class) might not be valid

// anymore. This can, for example, happen if the state was dependent on another

// abstract attribute that changed. In every invocation, the update method has

// to adjust the internal state of an abstract attribute to a point that is

// justifiable by the underlying IR and the current state of abstract attributes

// in-flight. Since the IR is given and assumed to be valid, the information

// derived from it can be assumed to hold. However, information derived from

// other abstract attributes is conditional on various things. If the justifying

// state changed, the `updateImpl` has to revisit the situation and potentially

// find another justification or limit the optimistic assumes made.

//

// Change is the key in this framework. Until a state of no-change, thus a

// fixpoint, is reached, the Attributor will query the abstract attributes

// in-flight to re-evaluate their state. If the (current) state is too

// optimistic, hence it cannot be justified anymore through other abstract

// attributes or the state of the IR, the state of the abstract attribute will

// have to change. Generally, we assume abstract attribute state to be a finite

// height lattice and the update function to be monotone. However, these

// conditions are not enforced because the iteration limit will guarantee

// termination. If an optimistic fixpoint is reached, or a pessimistic fix

// point is enforced after a timeout, the abstract attributes are tasked to

// manifest their result in the IR for passes to come.

//

// Attribute manifestation is not mandatory. If desired, there is support to

// generate a single or multiple LLVM-IR attributes already in the helper struct

// IRAttribute. In the simplest case, a subclass inherits from IRAttribute with

// a proper Attribute::AttrKind as template parameter. The Attributor

// manifestation framework will then create and place a new attribute if it is

// allowed to do so (based on the abstract state). Other use cases can be

// achieved by overloading AbstractAttribute or IRAttribute methods.

//

//

// The "mechanics" of adding a new "abstract attribute":

// - Define a class (transitively) inheriting from AbstractAttribute and one

//   (which could be the same) that (transitively) inherits from AbstractState.

//   For the latter, consider the already available BooleanState and

//   {Inc,Dec,Bit}IntegerState if they fit your needs, e.g., you require only a

//   number tracking or bit-encoding.

// - Implement all pure methods. Also use overloading if the attribute is not

//   conforming with the "default" behavior: A (set of) LLVM-IR attribute(s) for

//   an argument, call site argument, function return value, or function. See

//   the class and method descriptions for more information on the two

//   "Abstract" classes and their respective methods.

// - Register opportunities for the new abstract attribute in the

//   `Attributor::identifyDefaultAbstractAttributes` method if it should be

//   counted as a 'default' attribute.

// - Add sufficient tests.

// - Add a Statistics object for bookkeeping. If it is a simple (set of)

//   attribute(s) manifested through the Attributor manifestation framework, see

//   the bookkeeping function in Attributor.cpp.

// - If instructions with a certain opcode are interesting to the attribute, add

//   that opcode to the switch in `Attributor::identifyAbstractAttributes`. This

//   will make it possible to query all those instructions through the

//   `InformationCache::getOpcodeInstMapForFunction` interface and eliminate the

//   need to traverse the IR repeatedly.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H

#define LLVM_TRANSFORMS_IPO_ATTRIBUTOR_H

#include "llvm/ADT/DenseSet.h"

#include "llvm/ADT/GraphTraits.h"

#include "llvm/ADT/MapVector.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SetOperations.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/Triple.h"

#include "llvm/ADT/iterator.h"

#include "llvm/Analysis/AssumeBundleQueries.h"

#include "llvm/Analysis/CFG.h"

#include "llvm/Analysis/CGSCCPassManager.h"

#include "llvm/Analysis/LazyCallGraph.h"

#include "llvm/Analysis/LoopInfo.h"

#include "llvm/Analysis/MemoryLocation.h"

#include "llvm/Analysis/MustExecute.h"

#include "llvm/Analysis/OptimizationRemarkEmitter.h"

#include "llvm/Analysis/PostDominators.h"

#include "llvm/Analysis/TargetLibraryInfo.h"

#include "llvm/IR/AbstractCallSite.h"

#include "llvm/IR/ConstantRange.h"

#include "llvm/IR/Constants.h"

#include "llvm/IR/InstIterator.h"

#include "llvm/IR/Instruction.h"

#include "llvm/IR/PassManager.h"

#include "llvm/IR/Value.h"

#include "llvm/Support/Alignment.h"

#include "llvm/Support/Allocator.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/DOTGraphTraits.h"

#include "llvm/Support/TimeProfiler.h"

#include "llvm/Transforms/Utils/CallGraphUpdater.h"

#include <limits>

#include <map>

#include <optional>

namespace llvm {

class DataLayout;

class LLVMContext;

class Pass;

template <typename Fn> class function_ref;

struct AADepGraphNode;

struct AADepGraph;

struct Attributor;

struct AbstractAttribute;

struct InformationCache;

struct AAIsDead;

struct AttributorCallGraph;

struct IRPosition;

class AAResults;

class Function;

/// Abstract Attribute helper functions.

namespace AA {

using InstExclusionSetTy = SmallPtrSet<Instruction *, 4>;

enum class GPUAddressSpace : unsigned {

  Generic = 0,

  Global = 1,

  Shared = 3,

  Constant = 4,

  Local = 5,

};

/// Flags to distinguish intra-procedural queries from *potentially*

/// inter-procedural queries. Not that information can be valid for both and

/// therefore both bits might be set.

enum ValueScope : uint8_t {

  Intraprocedural = 1,

  Interprocedural = 2,

  AnyScope = Intraprocedural | Interprocedural,

};

struct ValueAndContext : public std::pair<Value *, const Instruction *> {

  using Base = std::pair<Value *, const Instruction *>;

  ValueAndContext(const Base &B) : Base(B) {}

  ValueAndContext(Value &V, const Instruction *CtxI) : Base(&V, CtxI) {}

  ValueAndContext(Value &V, const Instruction &CtxI) : Base(&V, &CtxI) {}

  Value *getValue() const { return this->first; }

  const Instruction *getCtxI() const { return this->second; }

};

/// Return true if \p I is a `nosync` instruction. Use generic reasoning and

/// potentially the corresponding AANoSync.

bool isNoSyncInst(Attributor &A, const Instruction &I,

                  const AbstractAttribute &QueryingAA);

/// Return true if \p V is dynamically unique, that is, there are no two

/// "instances" of \p V at runtime with different values.

/// Note: If \p ForAnalysisOnly is set we only check that the Attributor will

/// never use \p V to represent two "instances" not that \p V could not

/// technically represent them.

bool isDynamicallyUnique(Attributor &A, const AbstractAttribute &QueryingAA,

                         const Value &V, bool ForAnalysisOnly = true);

/// Return true if \p V is a valid value in \p Scope, that is a constant or an

/// instruction/argument of \p Scope.

bool isValidInScope(const Value &V, const Function *Scope);

/// Return true if the value of \p VAC is a valid at the position of \p VAC,

/// that is a constant, an argument of the same function, or an instruction in

/// that function that dominates the position.

bool isValidAtPosition(const ValueAndContext &VAC, InformationCache &InfoCache);

/// Try to convert \p V to type \p Ty without introducing new instructions. If

/// this is not possible return `nullptr`. Note: this function basically knows

/// how to cast various constants.

Value *getWithType(Value &V, Type &Ty);

/// Return the combination of \p A and \p B such that the result is a possible

/// value of both. \p B is potentially casted to match the type \p Ty or the

/// type of \p A if \p Ty is null.

///

/// Examples:

///        X + none  => X

/// not_none + undef => not_none

///          V1 + V2 => nullptr

std::optional<Value *>

combineOptionalValuesInAAValueLatice(const std::optional<Value *> &A,

                                     const std::optional<Value *> &B, Type *Ty);

/// Helper to represent an access offset and size, with logic to deal with

/// uncertainty and check for overlapping accesses.

struct RangeTy {

  int64_t Offset = Unassigned;

  int64_t Size = Unassigned;

  RangeTy(int64_t Offset, int64_t Size) : Offset(Offset), Size(Size) {}

  RangeTy() = default;

  static RangeTy getUnknown() { return RangeTy{Unknown, Unknown}; }

  /// Return true if offset or size are unknown.

  bool offsetOrSizeAreUnknown() const {

    return Offset == RangeTy::Unknown || Size == RangeTy::Unknown;

  }

  /// Return true if offset and size are unknown, thus this is the default

  /// unknown object.

  bool offsetAndSizeAreUnknown() const {

    return Offset == RangeTy::Unknown && Size == RangeTy::Unknown;

  }

  /// Return true if the offset and size are unassigned.

  bool isUnassigned() const {

    assert((Offset == RangeTy::Unassigned) == (Size == RangeTy::Unassigned) &&

           "Inconsistent state!");

    return Offset == RangeTy::Unassigned;

  }

  /// Return true if this offset and size pair might describe an address that

  /// overlaps with \p Range.

  bool mayOverlap(const RangeTy &Range) const {

    // Any unknown value and we are giving up -> overlap.

    if (offsetOrSizeAreUnknown() || Range.offsetOrSizeAreUnknown())

      return true;

    // Check if one offset point is in the other interval [offset,

    // offset+size].

    return Range.Offset + Range.Size > Offset && Range.Offset < Offset + Size;

  }

  RangeTy &operator&=(const RangeTy &R) {

    if (Offset == Unassigned)

      Offset = R.Offset;

    else if (R.Offset != Unassigned && R.Offset != Offset)

      Offset = Unknown;

    if (Size == Unassigned)

      Size = R.Size;

    else if (Size == Unknown || R.Size == Unknown)

      Size = Unknown;

    else if (R.Size != Unassigned)

      Size = std::max(Size, R.Size);

    return *this;

  }

  /// Comparison for sorting ranges by offset.

  ///

  /// Returns true if the offset \p L is less than that of \p R.

  inline static bool OffsetLessThan(const RangeTy &L, const RangeTy &R) {

    return L.Offset < R.Offset;

  }

  /// Constants used to represent special offsets or sizes.

  /// - We cannot assume that Offsets and Size are non-negative.

  /// - The constants should not clash with DenseMapInfo, such as EmptyKey

  ///   (INT64_MAX) and TombstoneKey (INT64_MIN).

  /// We use values "in the middle" of the 64 bit range to represent these

  /// special cases.

  static constexpr int64_t Unassigned = std::numeric_limits<int32_t>::min();

  static constexpr int64_t Unknown = std::numeric_limits<int32_t>::max();

};

inline raw_ostream &operator<<(raw_ostream &OS, const RangeTy &R) {

  OS << "[" << R.Offset << ", " << R.Size << "]";

  return OS;

}

inline bool operator==(const RangeTy &A, const RangeTy &B) {

  return A.Offset == B.Offset && A.Size == B.Size;

}

inline bool operator!=(const RangeTy &A, const RangeTy &B) { return !(A == B); }

/// Return the initial value of \p Obj with type \p Ty if that is a constant.

Constant *getInitialValueForObj(Value &Obj, Type &Ty,

                                const TargetLibraryInfo *TLI,

                                const DataLayout &DL,

                                RangeTy *RangePtr = nullptr);

/// Collect all potential values \p LI could read into \p PotentialValues. That

/// is, the only values read by \p LI are assumed to be known and all are in

/// \p PotentialValues. \p PotentialValueOrigins will contain all the

/// instructions that might have put a potential value into \p PotentialValues.

/// Dependences onto \p QueryingAA are properly tracked, \p

/// UsedAssumedInformation will inform the caller if assumed information was

/// used.

///

/// \returns True if the assumed potential copies are all in \p PotentialValues,

///          false if something went wrong and the copies could not be

///          determined.

bool getPotentiallyLoadedValues(

    Attributor &A, LoadInst &LI, SmallSetVector<Value *, 4> &PotentialValues,

    SmallSetVector<Instruction *, 4> &PotentialValueOrigins,

    const AbstractAttribute &QueryingAA, bool &UsedAssumedInformation,

    bool OnlyExact = false);

/// Collect all potential values of the one stored by \p SI into

/// \p PotentialCopies. That is, the only copies that were made via the

/// store are assumed to be known and all are in \p PotentialCopies. Dependences

/// onto \p QueryingAA are properly tracked, \p UsedAssumedInformation will

/// inform the caller if assumed information was used.

///

/// \returns True if the assumed potential copies are all in \p PotentialCopies,

///          false if something went wrong and the copies could not be

///          determined.

bool getPotentialCopiesOfStoredValue(

    Attributor &A, StoreInst &SI, SmallSetVector<Value *, 4> &PotentialCopies,

    const AbstractAttribute &QueryingAA, bool &UsedAssumedInformation,

    bool OnlyExact = false);

/// Return true if \p IRP is readonly. This will query respective AAs that

/// deduce the information and introduce dependences for \p QueryingAA.

bool isAssumedReadOnly(Attributor &A, const IRPosition &IRP,

                       const AbstractAttribute &QueryingAA, bool &IsKnown);

/// Return true if \p IRP is readnone. This will query respective AAs that

/// deduce the information and introduce dependences for \p QueryingAA.

bool isAssumedReadNone(Attributor &A, const IRPosition &IRP,

                       const AbstractAttribute &QueryingAA, bool &IsKnown);

/// Return true if \p ToI is potentially reachable from \p FromI without running

/// into any instruction in \p ExclusionSet The two instructions do not need to

/// be in the same function. \p GoBackwardsCB can be provided to convey domain

/// knowledge about the "lifespan" the user is interested in. By default, the

/// callers of \p FromI are checked as well to determine if \p ToI can be

/// reached. If the query is not interested in callers beyond a certain point,

/// e.g., a GPU kernel entry or the function containing an alloca, the

/// \p GoBackwardsCB should return false.

bool isPotentiallyReachable(

    Attributor &A, const Instruction &FromI, const Instruction &ToI,

    const AbstractAttribute &QueryingAA,

    const AA::InstExclusionSetTy *ExclusionSet = nullptr,

    std::function<bool(const Function &F)> GoBackwardsCB = nullptr);

/// Same as above but it is sufficient to reach any instruction in \p ToFn.

bool isPotentiallyReachable(

    Attributor &A, const Instruction &FromI, const Function &ToFn,

    const AbstractAttribute &QueryingAA,

    const AA::InstExclusionSetTy *ExclusionSet = nullptr,

    std::function<bool(const Function &F)> GoBackwardsCB = nullptr);

/// Return true if \p Obj is assumed to be a thread local object.

bool isAssumedThreadLocalObject(Attributor &A, Value &Obj,

                                const AbstractAttribute &QueryingAA);

/// Return true if \p I is potentially affected by a barrier.

bool isPotentiallyAffectedByBarrier(Attributor &A, const Instruction &I,

                                    const AbstractAttribute &QueryingAA);

bool isPotentiallyAffectedByBarrier(Attributor &A, ArrayRef<const Value *> Ptrs,

                                    const AbstractAttribute &QueryingAA,

                                    const Instruction *CtxI);

} // namespace AA

template <>

struct DenseMapInfo<AA::ValueAndContext>

    : public DenseMapInfo<AA::ValueAndContext::Base> {

  using Base = DenseMapInfo<AA::ValueAndContext::Base>;

  static inline AA::ValueAndContext getEmptyKey() {

    return Base::getEmptyKey();

  }

  static inline AA::ValueAndContext getTombstoneKey() {

    return Base::getTombstoneKey();

  }

  static unsigned getHashValue(const AA::ValueAndContext &VAC) {

    return Base::getHashValue(VAC);

  }

  static bool isEqual(const AA::ValueAndContext &LHS,

                      const AA::ValueAndContext &RHS) {

    return Base::isEqual(LHS, RHS);

  }

};

template <>

struct DenseMapInfo<AA::ValueScope> : public DenseMapInfo<unsigned char> {

  using Base = DenseMapInfo<unsigned char>;

  static inline AA::ValueScope getEmptyKey() {

    return AA::ValueScope(Base::getEmptyKey());

  }

  static inline AA::ValueScope getTombstoneKey() {

    return AA::ValueScope(Base::getTombstoneKey());

  }

  static unsigned getHashValue(const AA::ValueScope &S) {

    return Base::getHashValue(S);

  }

  static bool isEqual(const AA::ValueScope &LHS, const AA::ValueScope &RHS) {

    return Base::isEqual(LHS, RHS);

  }

};

template <>

struct DenseMapInfo<const AA::InstExclusionSetTy *>

    : public DenseMapInfo<void *> {

  using super = DenseMapInfo<void *>;

  static inline const AA::InstExclusionSetTy *getEmptyKey() {

    return static_cast<const AA::InstExclusionSetTy *>(super::getEmptyKey());

  }

  static inline const AA::InstExclusionSetTy *getTombstoneKey() {

    return static_cast<const AA::InstExclusionSetTy *>(

        super::getTombstoneKey());

  }

  static unsigned getHashValue(const AA::InstExclusionSetTy *BES) {

    unsigned H = 0;

    if (BES)

      for (const auto *II : *BES)

        H += DenseMapInfo<const Instruction *>::getHashValue(II);

    return H;

  }

  static bool isEqual(const AA::InstExclusionSetTy *LHS,

                      const AA::InstExclusionSetTy *RHS) {

    if (LHS == RHS)

      return true;

    if (LHS == getEmptyKey() || RHS == getEmptyKey() ||

        LHS == getTombstoneKey() || RHS == getTombstoneKey())

      return false;

    if (!LHS || !RHS)

      return ((LHS && LHS->empty()) || (RHS && RHS->empty()));

    if (LHS->size() != RHS->size())

      return false;

    return llvm::set_is_subset(*LHS, *RHS);

  }

};

/// The value passed to the line option that defines the maximal initialization

/// chain length.

extern unsigned MaxInitializationChainLength;

///{

enum class ChangeStatus {

  CHANGED,

  UNCHANGED,

};

ChangeStatus operator|(ChangeStatus l, ChangeStatus r);

ChangeStatus &operator|=(ChangeStatus &l, ChangeStatus r);

ChangeStatus operator&(ChangeStatus l, ChangeStatus r);

ChangeStatus &operator&=(ChangeStatus &l, ChangeStatus r);

enum class DepClassTy {

  REQUIRED, ///< The target cannot be valid if the source is not.

  OPTIONAL, ///< The target may be valid if the source is not.

  NONE,     ///< Do not track a dependence between source and target.

};

///}

/// The data structure for the nodes of a dependency graph

struct AADepGraphNode {

public:

  virtual ~AADepGraphNode() = default;

  using DepTy = PointerIntPair<AADepGraphNode *, 1>;

protected:

  /// Set of dependency graph nodes which should be updated if this one

  /// is updated. The bit encodes if it is optional.

  TinyPtrVector<DepTy> Deps;

  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }

  static AbstractAttribute *DepGetValAA(DepTy &DT) {

    return cast<AbstractAttribute>(DT.getPointer());

  }

  operator AbstractAttribute *() { return cast<AbstractAttribute>(this); }

public:

  using iterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;

  using aaiterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetValAA)>;

  aaiterator begin() { return aaiterator(Deps.begin(), &DepGetValAA); }

  aaiterator end() { return aaiterator(Deps.end(), &DepGetValAA); }

  iterator child_begin() { return iterator(Deps.begin(), &DepGetVal); }

  iterator child_end() { return iterator(Deps.end(), &DepGetVal); }

  virtual void print(raw_ostream &OS) const { OS << "AADepNode Impl\n"; }

  TinyPtrVector<DepTy> &getDeps() { return Deps; }

  friend struct Attributor;

  friend struct AADepGraph;

};

/// The data structure for the dependency graph

///

/// Note that in this graph if there is an edge from A to B (A -> B),

/// then it means that B depends on A, and when the state of A is

/// updated, node B should also be updated

struct AADepGraph {

  AADepGraph() = default;

  ~AADepGraph() = default;

  using DepTy = AADepGraphNode::DepTy;

  static AADepGraphNode *DepGetVal(DepTy &DT) { return DT.getPointer(); }

  using iterator =

      mapped_iterator<TinyPtrVector<DepTy>::iterator, decltype(&DepGetVal)>;

  /// There is no root node for the dependency graph. But the SCCIterator

  /// requires a single entry point, so we maintain a fake("synthetic") root

  /// node that depends on every node.

  AADepGraphNode SyntheticRoot;

  AADepGraphNode *GetEntryNode() { return &SyntheticRoot; }

  iterator begin() { return SyntheticRoot.child_begin(); }

  iterator end() { return SyntheticRoot.child_end(); }

  void viewGraph();

  /// Dump graph to file

  void dumpGraph();

  /// Print dependency graph

  void print();

};

/// Helper to describe and deal with positions in the LLVM-IR.

///

/// A position in the IR is described by an anchor value and an "offset" that

/// could be the argument number, for call sites and arguments, or an indicator

/// of the "position kind". The kinds, specified in the Kind enum below, include

/// the locations in the attribute list, i.a., function scope and return value,

/// as well as a distinction between call sites and functions. Finally, there

/// are floating values that do not have a corresponding attribute list

/// position.

struct IRPosition {

  // NOTE: In the future this definition can be changed to support recursive

  // functions.

  using CallBaseContext = CallBase;

  /// The positions we distinguish in the IR.

  enum Kind : char {

    IRP_INVALID,  ///< An invalid position.

    IRP_FLOAT,    ///< A position that is not associated with a spot suitable

                  ///< for attributes. This could be any value or instruction.

    IRP_RETURNED, ///< An attribute for the function return value.

    IRP_CALL_SITE_RETURNED, ///< An attribute for a call site return value.

    IRP_FUNCTION,           ///< An attribute for a function (scope).

    IRP_CALL_SITE,          ///< An attribute for a call site (function scope).

    IRP_ARGUMENT,           ///< An attribute for a function argument.

    IRP_CALL_SITE_ARGUMENT, ///< An attribute for a call site argument.

  };

  /// Default constructor available to create invalid positions implicitly. All

  /// other positions need to be created explicitly through the appropriate

  /// static member function.

  IRPosition() : Enc(nullptr, ENC_VALUE) { verify(); }

  /// Create a position describing the value of \p V.

  static const IRPosition value(const Value &V,

                                const CallBaseContext *CBContext = nullptr) {

    if (auto *Arg = dyn_cast<Argument>(&V))

      return IRPosition::argument(*Arg, CBContext);

    if (auto *CB = dyn_cast<CallBase>(&V))

      return IRPosition::callsite_returned(*CB);

    return IRPosition(const_cast<Value &>(V), IRP_FLOAT, CBContext);

  }

  /// Create a position describing the instruction \p I. This is different from

  /// the value version because call sites are treated as intrusctions rather

  /// than their return value in this function.

  static const IRPosition inst(const Instruction &I,

                               const CallBaseContext *CBContext = nullptr) {

    return IRPosition(const_cast<Instruction &>(I), IRP_FLOAT, CBContext);

  }

  /// Create a position describing the function scope of \p F.

  /// \p CBContext is used for call base specific analysis.

  static const IRPosition function(const Function &F,

                                   const CallBaseContext *CBContext = nullptr) {

    return IRPosition(const_cast<Function &>(F), IRP_FUNCTION, CBContext);

  }

  /// Create a position describing the returned value of \p F.

  /// \p CBContext is used for call base specific analysis.

  static const IRPosition returned(const Function &F,

                                   const CallBaseContext *CBContext = nullptr) {

    return IRPosition(const_cast<Function &>(F), IRP_RETURNED, CBContext);

  }

  /// Create a position describing the argument \p Arg.

  /// \p CBContext is used for call base specific analysis.

  static const IRPosition argument(const Argument &Arg,

                                   const CallBaseContext *CBContext = nullptr) {

    return IRPosition(const_cast<Argument &>(Arg), IRP_ARGUMENT, CBContext);

  }

  /// Create a position describing the function scope of \p CB.

  static const IRPosition callsite_function(const CallBase &CB) {

    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE);

  }

  /// Create a position describing the returned value of \p CB.

  static const IRPosition callsite_returned(const CallBase &CB) {

    return IRPosition(const_cast<CallBase &>(CB), IRP_CALL_SITE_RETURNED);

  }

  /// Create a position describing the argument of \p CB at position \p ArgNo.

  static const IRPosition callsite_argument(const CallBase &CB,

                                            unsigned ArgNo) {

    return IRPosition(const_cast<Use &>(CB.getArgOperandUse(ArgNo)),

                      IRP_CALL_SITE_ARGUMENT);

  }

  /// Create a position describing the argument of \p ACS at position \p ArgNo.

  static const IRPosition callsite_argument(AbstractCallSite ACS,

                                            unsigned ArgNo) {

    if (ACS.getNumArgOperands() <= ArgNo)

      return IRPosition();

    int CSArgNo = ACS.getCallArgOperandNo(ArgNo);

    if (CSArgNo >= 0)

      return IRPosition::callsite_argument(

          cast<CallBase>(*ACS.getInstruction()), CSArgNo);

    return IRPosition();

  }

  /// Create a position with function scope matching the "context" of \p IRP.

  /// If \p IRP is a call site (see isAnyCallSitePosition()) then the result

  /// will be a call site position, otherwise the function position of the

  /// associated function.

  static const IRPosition

  function_scope(const IRPosition &IRP,

                 const CallBaseContext *CBContext = nullptr) {

    if (IRP.isAnyCallSitePosition()) {

      return IRPosition::callsite_function(

          cast<CallBase>(IRP.getAnchorValue()));

    }

    assert(IRP.getAssociatedFunction());

    return IRPosition::function(*IRP.getAssociatedFunction(), CBContext);

  }

  bool operator==(const IRPosition &RHS) const {

    return Enc == RHS.Enc && RHS.CBContext == CBContext;

  }

  bool operator!=(const IRPosition &RHS) const { return !(*this == RHS); }

  /// Return the value this abstract attribute is anchored with.

  ///

  /// The anchor value might not be the associated value if the latter is not

  /// sufficient to determine where arguments will be manifested. This is, so

  /// far, only the case for call site arguments as the value is not sufficient

  /// to pinpoint them. Instead, we can use the call site as an anchor.

  Value &getAnchorValue() const {

    switch (getEncodingBits()) {

    case ENC_VALUE:

    case ENC_RETURNED_VALUE:

    case ENC_FLOATING_FUNCTION:

      return *getAsValuePtr();

    case ENC_CALL_SITE_ARGUMENT_USE:

      return *(getAsUsePtr()->getUser());

    default:

      llvm_unreachable("Unkown encoding!");

    };

  }

  /// Return the associated function, if any.

  Function *getAssociatedFunction() const {

    if (auto *CB = dyn_cast<CallBase>(&getAnchorValue())) {

      // We reuse the logic that associates callback calles to arguments of a

      // call site here to identify the callback callee as the associated

      // function.

      if (Argument *Arg = getAssociatedArgument())

        return Arg->getParent();

      return CB->getCalledFunction();

    }

    return getAnchorScope();

  }

  /// Return the associated argument, if any.

  Argument *getAssociatedArgument() const;

  /// Return true if the position refers to a function interface, that is the

  /// function scope, the function return, or an argument.

  bool isFnInterfaceKind() const {

    switch (getPositionKind()) {

    case IRPosition::IRP_FUNCTION:

    case IRPosition::IRP_RETURNED:

    case IRPosition::IRP_ARGUMENT:

      return true;

    default:

      return false;

    }

  }

  /// Return the Function surrounding the anchor value.

  Function *getAnchorScope() const {

    Value &V = getAnchorValue();

    if (isa<Function>(V))

      return &cast<Function>(V);

    if (isa<Argument>(V))

      return cast<Argument>(V).getParent();

    if (isa<Instruction>(V))

      return cast<Instruction>(V).getFunction();

    return nullptr;

  }

  /// Return the context instruction, if any.

  Instruction *getCtxI() const {

    Value &V = getAnchorValue();

    if (auto *I = dyn_cast<Instruction>(&V))

      return I;

    if (auto *Arg = dyn_cast<Argument>(&V))

      if (!Arg->getParent()->isDeclaration())

        return &Arg->getParent()->getEntryBlock().front();

    if (auto *F = dyn_cast<Function>(&V))

      if (!F->isDeclaration())

        return &(F->getEntryBlock().front());

    return nullptr;

  }

  /// Return the value this abstract attribute is associated with.

  Value &getAssociatedValue() const {

    if (getCallSiteArgNo() < 0 || isa<Argument>(&getAnchorValue()))

      return getAnchorValue();

    assert(isa<CallBase>(&getAnchorValue()) && "Expected a call base!");

    return *cast<CallBase>(&getAnchorValue())

                ->getArgOperand(getCallSiteArgNo());

  }

  /// Return the type this abstract attribute is associated with.

  Type *getAssociatedType() const {

    if (getPositionKind() == IRPosition::IRP_RETURNED)

      return getAssociatedFunction()->getReturnType();

    return getAssociatedValue().getType();

  }

  /// Return the callee argument number of the associated value if it is an

  /// argument or call site argument, otherwise a negative value. In contrast to

  /// `getCallSiteArgNo` this method will always return the "argument number"

  /// from the perspective of the callee. This may not the same as the call site

  /// if this is a callback call.

  int getCalleeArgNo() const {

    return getArgNo(/* CallbackCalleeArgIfApplicable */ true);

  }

  /// Return the call site argument number of the associated value if it is an

  /// argument or call site argument, otherwise a negative value. In contrast to

  /// `getCalleArgNo` this method will always return the "operand number" from

  /// the perspective of the call site. This may not the same as the callee

  /// perspective if this is a callback call.

  int getCallSiteArgNo() const {

    return getArgNo(/* CallbackCalleeArgIfApplicable */ false);

  }

  /// Return the index in the attribute list for this position.

  unsigned getAttrIdx() const {

    switch (getPositionKind()) {

    case IRPosition::IRP_INVALID:

    case IRPosition::IRP_FLOAT:

      break;

    case IRPosition::IRP_FUNCTION:

    case IRPosition::IRP_CALL_SITE:

      return AttributeList::FunctionIndex;