/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/llvm/lib/Transforms/IPO/AttributorAttributes.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
Warning:	line 1315, column 15 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name AttributorAttributes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I lib/Transforms/IPO -I /build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/llvm/lib/Transforms/IPO -I include -I /build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-03-01-235733-118493-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220301100735+026fe5ffc352/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
1//===- AttributorAttributes.cpp - Attributes for Attributor deduction -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// See the Attributor.h file comment and the class descriptions in that file for
10// more information.
11//
12//===----------------------------------------------------------------------===//

14#include "llvm/Transforms/IPO/Attributor.h"

16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/MapVector.h"
18#include "llvm/ADT/SCCIterator.h"
19#include "llvm/ADT/STLExtras.h"
20#include "llvm/ADT/SetOperations.h"
21#include "llvm/ADT/SmallPtrSet.h"
22#include "llvm/ADT/Statistic.h"
23#include "llvm/Analysis/AliasAnalysis.h"
24#include "llvm/Analysis/AssumeBundleQueries.h"
25#include "llvm/Analysis/AssumptionCache.h"
26#include "llvm/Analysis/CaptureTracking.h"
27#include "llvm/Analysis/InstructionSimplify.h"
28#include "llvm/Analysis/LazyValueInfo.h"
29#include "llvm/Analysis/MemoryBuiltins.h"
30#include "llvm/Analysis/OptimizationRemarkEmitter.h"
31#include "llvm/Analysis/ScalarEvolution.h"
32#include "llvm/Analysis/TargetTransformInfo.h"
33#include "llvm/Analysis/ValueTracking.h"
34#include "llvm/IR/Assumptions.h"
35#include "llvm/IR/Constants.h"
36#include "llvm/IR/DataLayout.h"
37#include "llvm/IR/IRBuilder.h"
38#include "llvm/IR/Instruction.h"
39#include "llvm/IR/Instructions.h"
40#include "llvm/IR/IntrinsicInst.h"
41#include "llvm/IR/Value.h"
42#include "llvm/IR/NoFolder.h"
43#include "llvm/Support/Alignment.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/CommandLine.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/FileSystem.h"
48#include "llvm/Support/MathExtras.h"
49#include "llvm/Support/raw_ostream.h"
50#include "llvm/Transforms/IPO/ArgumentPromotion.h"
51#include "llvm/Transforms/Utils/Local.h"
52#include <cassert>

54using namespace llvm;

56#define DEBUG_TYPE"attributor" "attributor"

58static cl::opt<bool> ManifestInternal(
  "attributor-manifest-internal", cl::Hidden,
  cl::desc("Manifest Attributor internal string attributes."),
  cl::init(false));

63static cl::opt<int> MaxHeapToStackSize("max-heap-to-stack-size", cl::init(128),
                                     cl::Hidden);

66template <>
67unsigned llvm::PotentialConstantIntValuesState::MaxPotentialValues = 0;

69static cl::opt<unsigned, true> MaxPotentialValues(
  "attributor-max-potential-values", cl::Hidden,
  cl::desc("Maximum number of potential values to be "
           "tracked for each position."),
  cl::location(llvm::PotentialConstantIntValuesState::MaxPotentialValues),
  cl::init(7));

76static cl::opt<unsigned>
  MaxInterferingWrites("attributor-max-interfering-writes", cl::Hidden,
                       cl::desc("Maximum number of interfering writes to "
                                "check before assuming all might interfere."),
                       cl::init(6));

82STATISTIC(NumAAs, "Number of abstract attributes created")static llvm::Statistic NumAAs = {"attributor", "NumAAs", "Number of abstract attributes created"
};

84// Some helper macros to deal with statistics tracking.
85//
86// Usage:
87// For simple IR attribute tracking overload trackStatistics in the abstract
88// attribute and choose the right STATS_DECLTRACK_********* macro,
89// e.g.,:
90//  void trackStatistics() const override {
91//    STATS_DECLTRACK_ARG_ATTR(returned)
92//  }
93// If there is a single "increment" side one can use the macro
94// STATS_DECLTRACK with a custom message. If there are multiple increment
95// sides, STATS_DECL and STATS_TRACK can also be used separately.
96//
97#define BUILD_STAT_MSG_IR_ATTR(TYPE, NAME)("Number of " "TYPE" " marked '" "NAME" "'")                                     \
("Number of " #TYPE " marked '" #NAME "'")
99#define BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME NumIR##TYPE##_##NAME
100#define STATS_DECL_(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG}; STATISTIC(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG};
101#define STATS_DECL(NAME, TYPE, MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};;                                            \
STATS_DECL_(BUILD_STAT_NAME(NAME, TYPE), MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};;
103#define STATS_TRACK(NAME, TYPE)++(NumIRTYPE_NAME); ++(BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME);
104#define STATS_DECLTRACK(NAME, TYPE, MSG){ static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};; ++(NumIRTYPE_NAME); }                                       \
{                                                                            \
  STATS_DECL(NAME, TYPE, MSG)static llvm::Statistic NumIRTYPE_NAME = {"attributor", "NumIRTYPE_NAME"
, MSG};;                                                \
  STATS_TRACK(NAME, TYPE)++(NumIRTYPE_NAME);                                                    \
}
109#define STATS_DECLTRACK_ARG_ATTR(NAME){ static llvm::Statistic NumIRArguments_NAME = {"attributor",
 "NumIRArguments_NAME", ("Number of " "arguments" " marked '"
 "NAME" "'")};; ++(NumIRArguments_NAME); }                                         \
STATS_DECLTRACK(NAME, Arguments, BUILD_STAT_MSG_IR_ATTR(arguments, NAME)){ static llvm::Statistic NumIRArguments_NAME = {"attributor",
 "NumIRArguments_NAME", ("Number of " "arguments" " marked '"
 "NAME" "'")};; ++(NumIRArguments_NAME); }
111#define STATS_DECLTRACK_CSARG_ATTR(NAME){ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
 " marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }                                       \
STATS_DECLTRACK(NAME, CSArguments,                                           \{ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
 " marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }
                BUILD_STAT_MSG_IR_ATTR(call site arguments, NAME)){ static llvm::Statistic NumIRCSArguments_NAME = {"attributor"
, "NumIRCSArguments_NAME", ("Number of " "call site arguments"
 " marked '" "NAME" "'")};; ++(NumIRCSArguments_NAME); }
114#define STATS_DECLTRACK_FN_ATTR(NAME){ static llvm::Statistic NumIRFunction_NAME = {"attributor", "NumIRFunction_NAME"
, ("Number of " "functions" " marked '" "NAME" "'")};; ++(NumIRFunction_NAME
); }                                          \
STATS_DECLTRACK(NAME, Function, BUILD_STAT_MSG_IR_ATTR(functions, NAME)){ static llvm::Statistic NumIRFunction_NAME = {"attributor", "NumIRFunction_NAME"
, ("Number of " "functions" " marked '" "NAME" "'")};; ++(NumIRFunction_NAME
); }
116#define STATS_DECLTRACK_CS_ATTR(NAME){ static llvm::Statistic NumIRCS_NAME = {"attributor", "NumIRCS_NAME"
, ("Number of " "call site" " marked '" "NAME" "'")};; ++(NumIRCS_NAME
); }                                          \
STATS_DECLTRACK(NAME, CS, BUILD_STAT_MSG_IR_ATTR(call site, NAME)){ static llvm::Statistic NumIRCS_NAME = {"attributor", "NumIRCS_NAME"
, ("Number of " "call site" " marked '" "NAME" "'")};; ++(NumIRCS_NAME
); }
118#define STATS_DECLTRACK_FNRET_ATTR(NAME){ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
 " marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }                                       \
STATS_DECLTRACK(NAME, FunctionReturn,                                        \{ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
 " marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }
                BUILD_STAT_MSG_IR_ATTR(function returns, NAME)){ static llvm::Statistic NumIRFunctionReturn_NAME = {"attributor"
, "NumIRFunctionReturn_NAME", ("Number of " "function returns"
 " marked '" "NAME" "'")};; ++(NumIRFunctionReturn_NAME); }
121#define STATS_DECLTRACK_CSRET_ATTR(NAME){ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }                                       \
STATS_DECLTRACK(NAME, CSReturn,                                              \{ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }
                BUILD_STAT_MSG_IR_ATTR(call site returns, NAME)){ static llvm::Statistic NumIRCSReturn_NAME = {"attributor", "NumIRCSReturn_NAME"
, ("Number of " "call site returns" " marked '" "NAME" "'")};
; ++(NumIRCSReturn_NAME); }
124#define STATS_DECLTRACK_FLOATING_ATTR(NAME){ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" "NAME" "'")};; ++
(NumIRFloating_NAME); }                                    \
STATS_DECLTRACK(NAME, Floating,                                              \{ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" #NAME "'")};; ++
(NumIRFloating_NAME); }
                ("Number of floating values known to be '" #NAME "'")){ static llvm::Statistic NumIRFloating_NAME = {"attributor", "NumIRFloating_NAME"
, ("Number of floating values known to be '" #NAME "'")};; ++
(NumIRFloating_NAME); }

128// Specialization of the operator<< for abstract attributes subclasses. This
129// disambiguates situations where multiple operators are applicable.
130namespace llvm {
131#define PIPE_OPERATOR(CLASS)                                                   \
raw_ostream &operator<<(raw_ostream &OS, const CLASS &AA) {                  \
  return OS << static_cast<const AbstractAttribute &>(AA);                   \
}

136PIPE_OPERATOR(AAIsDead)
137PIPE_OPERATOR(AANoUnwind)
138PIPE_OPERATOR(AANoSync)
139PIPE_OPERATOR(AANoRecurse)
140PIPE_OPERATOR(AAWillReturn)
141PIPE_OPERATOR(AANoReturn)
142PIPE_OPERATOR(AAReturnedValues)
143PIPE_OPERATOR(AANonNull)
144PIPE_OPERATOR(AANoAlias)
145PIPE_OPERATOR(AADereferenceable)
146PIPE_OPERATOR(AAAlign)
147PIPE_OPERATOR(AANoCapture)
148PIPE_OPERATOR(AAValueSimplify)
149PIPE_OPERATOR(AANoFree)
150PIPE_OPERATOR(AAHeapToStack)
151PIPE_OPERATOR(AAReachability)
152PIPE_OPERATOR(AAMemoryBehavior)
153PIPE_OPERATOR(AAMemoryLocation)
154PIPE_OPERATOR(AAValueConstantRange)
155PIPE_OPERATOR(AAPrivatizablePtr)
156PIPE_OPERATOR(AAUndefinedBehavior)
157PIPE_OPERATOR(AAPotentialValues)
158PIPE_OPERATOR(AANoUndef)
159PIPE_OPERATOR(AACallEdges)
160PIPE_OPERATOR(AAFunctionReachability)
161PIPE_OPERATOR(AAPointerInfo)
162PIPE_OPERATOR(AAAssumptionInfo)

164#undef PIPE_OPERATOR

166template <>
167ChangeStatus clampStateAndIndicateChange<DerefState>(DerefState &S,
                                                   const DerefState &R) {
ChangeStatus CS0 =
    clampStateAndIndicateChange(S.DerefBytesState, R.DerefBytesState);
ChangeStatus CS1 = clampStateAndIndicateChange(S.GlobalState, R.GlobalState);
return CS0 | CS1;
173}

175} // namespace llvm

177/// Get pointer operand of memory accessing instruction. If \p I is
178/// not a memory accessing instruction, return nullptr. If \p AllowVolatile,
179/// is set to false and the instruction is volatile, return nullptr.
180static const Value *getPointerOperand(const Instruction *I,
                                    bool AllowVolatile) {
if (!AllowVolatile && I->isVolatile())
  return nullptr;

if (auto *LI = dyn_cast<LoadInst>(I)) {
  return LI->getPointerOperand();
}

if (auto *SI = dyn_cast<StoreInst>(I)) {
  return SI->getPointerOperand();
}

if (auto *CXI = dyn_cast<AtomicCmpXchgInst>(I)) {
  return CXI->getPointerOperand();
}

if (auto *RMWI = dyn_cast<AtomicRMWInst>(I)) {
  return RMWI->getPointerOperand();
}

return nullptr;
202}

204/// Helper function to create a pointer of type \p ResTy, based on \p Ptr, and
205/// advanced by \p Offset bytes. To aid later analysis the method tries to build
206/// getelement pointer instructions that traverse the natural type of \p Ptr if
207/// possible. If that fails, the remaining offset is adjusted byte-wise, hence
208/// through a cast to i8*.
209///
210/// TODO: This could probably live somewhere more prominantly if it doesn't
211///       already exist.
212static Value *constructPointer(Type *ResTy, Type *PtrElemTy, Value *Ptr,
                             int64_t Offset, IRBuilder<NoFolder> &IRB,
                             const DataLayout &DL) {
assert(Offset >= 0 && "Negative offset not supported yet!")(static_cast <bool> (Offset >= 0 && "Negative offset not supported yet!"
) ? void (0) : __assert_fail ("Offset >= 0 && \"Negative offset not supported yet!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 215, __extension__
 __PRETTY_FUNCTION__));
LLVM_DEBUG(dbgs() << "Construct pointer: " << *Ptr << " + " << Offsetdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Construct pointer: " <<
 *Ptr << " + " << Offset << "-bytes as " <<
 *ResTy << "\n"; } } while (false)
                  << "-bytes as " << *ResTy << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Construct pointer: " <<
 *Ptr << " + " << Offset << "-bytes as " <<
 *ResTy << "\n"; } } while (false);

if (Offset) {
  Type *Ty = PtrElemTy;
  APInt IntOffset(DL.getIndexTypeSizeInBits(Ptr->getType()), Offset);
  SmallVector<APInt> IntIndices = DL.getGEPIndicesForOffset(Ty, IntOffset);

  SmallVector<Value *, 4> ValIndices;
  std::string GEPName = Ptr->getName().str();
  for (const APInt &Index : IntIndices) {
    ValIndices.push_back(IRB.getInt(Index));
    GEPName += "." + std::to_string(Index.getZExtValue());
  }

  // Create a GEP for the indices collected above.
  Ptr = IRB.CreateGEP(PtrElemTy, Ptr, ValIndices, GEPName);

  // If an offset is left we use byte-wise adjustment.
  if (IntOffset != 0) {
    Ptr = IRB.CreateBitCast(Ptr, IRB.getInt8PtrTy());
    Ptr = IRB.CreateGEP(IRB.getInt8Ty(), Ptr, IRB.getInt(IntOffset),
                        GEPName + ".b" + Twine(IntOffset.getZExtValue()));
  }
}

// Ensure the result has the requested type.
Ptr = IRB.CreatePointerBitCastOrAddrSpaceCast(Ptr, ResTy,
                                              Ptr->getName() + ".cast");

LLVM_DEBUG(dbgs() << "Constructed pointer: " << *Ptr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Constructed pointer: " <<
 *Ptr << "\n"; } } while (false);
return Ptr;
248}

250/// Recursively visit all values that might become \p IRP at some point. This
251/// will be done by looking through cast instructions, selects, phis, and calls
252/// with the "returned" attribute. Once we cannot look through the value any
253/// further, the callback \p VisitValueCB is invoked and passed the current
254/// value, the \p State, and a flag to indicate if we stripped anything.
255/// Stripped means that we unpacked the value associated with \p IRP at least
256/// once. Note that the value used for the callback may still be the value
257/// associated with \p IRP (due to PHIs). To limit how much effort is invested,
258/// we will never visit more values than specified by \p MaxValues.
259/// If \p Intraprocedural is set to true only values valid in the scope of
260/// \p CtxI will be visited and simplification into other scopes is prevented.
261template <typename StateTy>
262static bool genericValueTraversal(
  Attributor &A, IRPosition IRP, const AbstractAttribute &QueryingAA,
  StateTy &State,
  function_ref<bool(Value &, const Instruction *, StateTy &, bool)>
      VisitValueCB,
  const Instruction *CtxI, bool &UsedAssumedInformation,
  bool UseValueSimplify = true, int MaxValues = 16,
  function_ref<Value *(Value *)> StripCB = nullptr,
  bool Intraprocedural = false) {

struct LivenessInfo {
  const AAIsDead *LivenessAA = nullptr;
  bool AnyDead = false;
};
SmallMapVector<const Function *, LivenessInfo, 4> LivenessAAs;
auto GetLivenessInfo = [&](const Function &F) -> LivenessInfo & {
  LivenessInfo &LI = LivenessAAs[&F];
  if (!LI.LivenessAA)
    LI.LivenessAA = &A.getAAFor<AAIsDead>(QueryingAA, IRPosition::function(F),
                                          DepClassTy::NONE);
  return LI;
};

Value *InitialV = &IRP.getAssociatedValue();
using Item = std::pair<Value *, const Instruction *>;
SmallSet<Item, 16> Visited;
SmallVector<Item, 16> Worklist;
Worklist.push_back({InitialV, CtxI});

int Iteration = 0;
do {
  Item I = Worklist.pop_back_val();
  Value *V = I.first;
  CtxI = I.second;
  if (StripCB)
    V = StripCB(V);

  // Check if we should process the current value. To prevent endless
  // recursion keep a record of the values we followed!
  if (!Visited.insert(I).second)
    continue;

  // Make sure we limit the compile time for complex expressions.
  if (Iteration++ >= MaxValues) {
    LLVM_DEBUG(dbgs() << "Generic value traversal reached iteration limit: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Generic value traversal reached iteration limit: "
 << Iteration << "!\n"; } } while (false)
                      << Iteration << "!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Generic value traversal reached iteration limit: "
 << Iteration << "!\n"; } } while (false);
    return false;
  }

  // Explicitly look through calls with a "returned" attribute if we do
  // not have a pointer as stripPointerCasts only works on them.
  Value *NewV = nullptr;
  if (V->getType()->isPointerTy()) {
    NewV = V->stripPointerCasts();
  } else {
    auto *CB = dyn_cast<CallBase>(V);
    if (CB && CB->getCalledFunction()) {
      for (Argument &Arg : CB->getCalledFunction()->args())
        if (Arg.hasReturnedAttr()) {
          NewV = CB->getArgOperand(Arg.getArgNo());
          break;
        }
    }
  }
  if (NewV && NewV != V) {
    Worklist.push_back({NewV, CtxI});
    continue;
  }

  // Look through select instructions, visit assumed potential values.
  if (auto *SI = dyn_cast<SelectInst>(V)) {
    Optional<Constant *> C = A.getAssumedConstant(
        *SI->getCondition(), QueryingAA, UsedAssumedInformation);
    bool NoValueYet = !C.hasValue();
    if (NoValueYet || isa_and_nonnull<UndefValue>(*C))
      continue;
    if (auto *CI = dyn_cast_or_null<ConstantInt>(*C)) {
      if (CI->isZero())
        Worklist.push_back({SI->getFalseValue(), CtxI});
      else
        Worklist.push_back({SI->getTrueValue(), CtxI});
      continue;
    }
    // We could not simplify the condition, assume both values.(
    Worklist.push_back({SI->getTrueValue(), CtxI});
    Worklist.push_back({SI->getFalseValue(), CtxI});
    continue;
  }

  // Look through phi nodes, visit all live operands.
  if (auto *PHI = dyn_cast<PHINode>(V)) {
    LivenessInfo &LI = GetLivenessInfo(*PHI->getFunction());
    for (unsigned u = 0, e = PHI->getNumIncomingValues(); u < e; u++) {
      BasicBlock *IncomingBB = PHI->getIncomingBlock(u);
      if (LI.LivenessAA->isEdgeDead(IncomingBB, PHI->getParent())) {
        LI.AnyDead = true;
        UsedAssumedInformation |= !LI.LivenessAA->isAtFixpoint();
        continue;
      }
      Worklist.push_back(
          {PHI->getIncomingValue(u), IncomingBB->getTerminator()});
    }
    continue;
  }

  if (auto *Arg = dyn_cast<Argument>(V)) {
    if (!Intraprocedural && !Arg->hasPassPointeeByValueCopyAttr()) {
      SmallVector<Item> CallSiteValues;
      bool UsedAssumedInformation = false;
      if (A.checkForAllCallSites(
              [&](AbstractCallSite ACS) {
                // Callbacks might not have a corresponding call site operand,
                // stick with the argument in that case.
                Value *CSOp = ACS.getCallArgOperand(*Arg);
                if (!CSOp)
                  return false;
                CallSiteValues.push_back({CSOp, ACS.getInstruction()});
                return true;
              },
              *Arg->getParent(), true, &QueryingAA, UsedAssumedInformation)) {
        Worklist.append(CallSiteValues);
        continue;
      }
    }
  }

  if (UseValueSimplify && !isa<Constant>(V)) {
    Optional<Value *> SimpleV =
        A.getAssumedSimplified(*V, QueryingAA, UsedAssumedInformation);
    if (!SimpleV.hasValue())
      continue;
    Value *NewV = SimpleV.getValue();
    if (NewV && NewV != V) {
      if (!Intraprocedural || !CtxI ||
          AA::isValidInScope(*NewV, CtxI->getFunction())) {
        Worklist.push_back({NewV, CtxI});
        continue;
      }
    }
  }

  // Once a leaf is reached we inform the user through the callback.
  if (!VisitValueCB(*V, CtxI, State, Iteration > 1)) {
    LLVM_DEBUG(dbgs() << "Generic value traversal visit callback failed for: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Generic value traversal visit callback failed for: "
 << *V << "!\n"; } } while (false)
                      << *V << "!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Generic value traversal visit callback failed for: "
 << *V << "!\n"; } } while (false);
    return false;
  }
} while (!Worklist.empty());

// If we actually used liveness information so we have to record a dependence.
for (auto &It : LivenessAAs)
  if (It.second.AnyDead)
    A.recordDependence(*It.second.LivenessAA, QueryingAA,
                       DepClassTy::OPTIONAL);

// All values have been visited.
return true;
419}

421bool AA::getAssumedUnderlyingObjects(Attributor &A, const Value &Ptr,
                                   SmallVectorImpl<Value *> &Objects,
                                   const AbstractAttribute &QueryingAA,
                                   const Instruction *CtxI,
                                   bool &UsedAssumedInformation,
                                   bool Intraprocedural) {
auto StripCB = [&](Value *V) { return getUnderlyingObject(V); };
SmallPtrSet<Value *, 8> SeenObjects;
auto VisitValueCB = [&SeenObjects](Value &Val, const Instruction *,
                                   SmallVectorImpl<Value *> &Objects,
                                   bool) -> bool {
  if (SeenObjects.insert(&Val).second)
    Objects.push_back(&Val);
  return true;
};
if (!genericValueTraversal<decltype(Objects)>(
        A, IRPosition::value(Ptr), QueryingAA, Objects, VisitValueCB, CtxI,
        UsedAssumedInformation, true, 32, StripCB, Intraprocedural))
  return false;
return true;
441}

443const Value *stripAndAccumulateMinimalOffsets(
  Attributor &A, const AbstractAttribute &QueryingAA, const Value *Val,
  const DataLayout &DL, APInt &Offset, bool AllowNonInbounds,
  bool UseAssumed = false) {

auto AttributorAnalysis = [&](Value &V, APInt &ROffset) -> bool {
  const IRPosition &Pos = IRPosition::value(V);
  // Only track dependence if we are going to use the assumed info.
  const AAValueConstantRange &ValueConstantRangeAA =
      A.getAAFor<AAValueConstantRange>(QueryingAA, Pos,
                                       UseAssumed ? DepClassTy::OPTIONAL
                                                  : DepClassTy::NONE);
  ConstantRange Range = UseAssumed ? ValueConstantRangeAA.getAssumed()
                                   : ValueConstantRangeAA.getKnown();
  // We can only use the lower part of the range because the upper part can
  // be higher than what the value can really be.
  ROffset = Range.getSignedMin();
  return true;
};

return Val->stripAndAccumulateConstantOffsets(DL, Offset, AllowNonInbounds,
                                              /* AllowInvariant */ false,
                                              AttributorAnalysis);
466}

468static const Value *
469getMinimalBaseOfPointer(Attributor &A, const AbstractAttribute &QueryingAA,
                      const Value *Ptr, int64_t &BytesOffset,
                      const DataLayout &DL, bool AllowNonInbounds = false) {
APInt OffsetAPInt(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
const Value *Base = stripAndAccumulateMinimalOffsets(
    A, QueryingAA, Ptr, DL, OffsetAPInt, AllowNonInbounds);

BytesOffset = OffsetAPInt.getSExtValue();
return Base;
478}

480/// Clamp the information known for all returned values of a function
481/// (identified by \p QueryingAA) into \p S.
482template <typename AAType, typename StateType = typename AAType::StateType>
483static void clampReturnedValueStates(
  Attributor &A, const AAType &QueryingAA, StateType &S,
  const IRPosition::CallBaseContext *CBContext = nullptr) {
LLVM_DEBUG(dbgs() << "[Attributor] Clamp return value states for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Clamp return value states for "
 << QueryingAA << " into " << S << "\n"
; } } while (false)
                  << QueryingAA << " into " << S << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Clamp return value states for "
 << QueryingAA << " into " << S << "\n"
; } } while (false);

assert((QueryingAA.getIRPosition().getPositionKind() ==(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__))
            IRPosition::IRP_RETURNED ||(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__))
        QueryingAA.getIRPosition().getPositionKind() ==(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__))
            IRPosition::IRP_CALL_SITE_RETURNED) &&(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__))
       "Can only clamp returned value states for a function returned or call "(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__))
       "site returned position!")(static_cast <bool> ((QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().
getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) &&
 "Can only clamp returned value states for a function returned or call "
 "site returned position!") ? void (0) : __assert_fail ("(QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_RETURNED || QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED) && \"Can only clamp returned value states for a function returned or call \" \"site returned position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 494, __extension__
 __PRETTY_FUNCTION__));

// Use an optional state as there might not be any return values and we want
// to join (IntegerState::operator&) the state of all there are.
Optional<StateType> T;

// Callback for each possibly returned value.
auto CheckReturnValue = [&](Value &RV) -> bool {
  const IRPosition &RVPos = IRPosition::value(RV, CBContext);
  const AAType &AA =
      A.getAAFor<AAType>(QueryingAA, RVPos, DepClassTy::REQUIRED);
  LLVM_DEBUG(dbgs() << "[Attributor] RV: " << RV << " AA: " << AA.getAsStr()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] RV: " <<
 RV << " AA: " << AA.getAsStr() << " @ " <<
 RVPos << "\n"; } } while (false)
                    << " @ " << RVPos << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] RV: " <<
 RV << " AA: " << AA.getAsStr() << " @ " <<
 RVPos << "\n"; } } while (false);
  const StateType &AAS = AA.getState();
  if (T.hasValue())
    *T &= AAS;
  else
    T = AAS;
  LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " RV State: " << Tdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] AA State: " <<
 AAS << " RV State: " << T << "\n"; } } while
 (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] AA State: " <<
 AAS << " RV State: " << T << "\n"; } } while
 (false);
  return T->isValidState();
};

if (!A.checkForAllReturnedValues(CheckReturnValue, QueryingAA))
  S.indicatePessimisticFixpoint();
else if (T.hasValue())
  S ^= *T;
521}

523namespace {
524/// Helper class for generic deduction: return value -> returned position.
525template <typename AAType, typename BaseType,
        typename StateType = typename BaseType::StateType,
        bool PropagateCallBaseContext = false>
528struct AAReturnedFromReturnedValues : public BaseType {
AAReturnedFromReturnedValues(const IRPosition &IRP, Attributor &A)
    : BaseType(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  StateType S(StateType::getBestState(this->getState()));
  clampReturnedValueStates<AAType, StateType>(
      A, *this, S,
      PropagateCallBaseContext ? this->getCallBaseContext() : nullptr);
  // TODO: If we know we visited all returned values, thus no are assumed
  // dead, we can take the known information from the state T.
  return clampStateAndIndicateChange<StateType>(this->getState(), S);
}
542};

544/// Clamp the information known at all call sites for a given argument
545/// (identified by \p QueryingAA) into \p S.
546template <typename AAType, typename StateType = typename AAType::StateType>
547static void clampCallSiteArgumentStates(Attributor &A, const AAType &QueryingAA,
                                      StateType &S) {
LLVM_DEBUG(dbgs() << "[Attributor] Clamp call site argument states for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Clamp call site argument states for "
 << QueryingAA << " into " << S << "\n"
; } } while (false)
                  << QueryingAA << " into " << S << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Clamp call site argument states for "
 << QueryingAA << " into " << S << "\n"
; } } while (false);

assert(QueryingAA.getIRPosition().getPositionKind() ==(static_cast <bool> (QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? void (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 554, __extension__
 __PRETTY_FUNCTION__))
           IRPosition::IRP_ARGUMENT &&(static_cast <bool> (QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? void (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 554, __extension__
 __PRETTY_FUNCTION__))
       "Can only clamp call site argument states for an argument position!")(static_cast <bool> (QueryingAA.getIRPosition().getPositionKind
() == IRPosition::IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? void (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 554, __extension__
 __PRETTY_FUNCTION__));

// Use an optional state as there might not be any return values and we want
// to join (IntegerState::operator&) the state of all there are.
Optional<StateType> T;

// The argument number which is also the call site argument number.
unsigned ArgNo = QueryingAA.getIRPosition().getCallSiteArgNo();

auto CallSiteCheck = [&](AbstractCallSite ACS) {
  const IRPosition &ACSArgPos = IRPosition::callsite_argument(ACS, ArgNo);
  // Check if a coresponding argument was found or if it is on not associated
  // (which can happen for callback calls).
  if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
    return false;

  const AAType &AA =
      A.getAAFor<AAType>(QueryingAA, ACSArgPos, DepClassTy::REQUIRED);
  LLVM_DEBUG(dbgs() << "[Attributor] ACS: " << *ACS.getInstruction()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] ACS: " <<
 *ACS.getInstruction() << " AA: " << AA.getAsStr(
) << " @" << ACSArgPos << "\n"; } } while (
false)
                    << " AA: " << AA.getAsStr() << " @" << ACSArgPos << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] ACS: " <<
 *ACS.getInstruction() << " AA: " << AA.getAsStr(
) << " @" << ACSArgPos << "\n"; } } while (
false);
  const StateType &AAS = AA.getState();
  if (T.hasValue())
    *T &= AAS;
  else
    T = AAS;
  LLVM_DEBUG(dbgs() << "[Attributor] AA State: " << AAS << " CSA State: " << Tdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] AA State: " <<
 AAS << " CSA State: " << T << "\n"; } } while
 (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] AA State: " <<
 AAS << " CSA State: " << T << "\n"; } } while
 (false);
  return T->isValidState();
};

bool UsedAssumedInformation = false;
if (!A.checkForAllCallSites(CallSiteCheck, QueryingAA, true,
                            UsedAssumedInformation))
  S.indicatePessimisticFixpoint();
else if (T.hasValue())
  S ^= *T;
590}

592/// This function is the bridge between argument position and the call base
593/// context.
594template <typename AAType, typename BaseType,
        typename StateType = typename AAType::StateType>
596bool getArgumentStateFromCallBaseContext(Attributor &A,
                                       BaseType &QueryingAttribute,
                                       IRPosition &Pos, StateType &State) {
assert((Pos.getPositionKind() == IRPosition::IRP_ARGUMENT) &&(static_cast <bool> ((Pos.getPositionKind() == IRPosition
::IRP_ARGUMENT) && "Expected an 'argument' position !"
) ? void (0) : __assert_fail ("(Pos.getPositionKind() == IRPosition::IRP_ARGUMENT) && \"Expected an 'argument' position !\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 600, __extension__
 __PRETTY_FUNCTION__))
       "Expected an 'argument' position !")(static_cast <bool> ((Pos.getPositionKind() == IRPosition
::IRP_ARGUMENT) && "Expected an 'argument' position !"
) ? void (0) : __assert_fail ("(Pos.getPositionKind() == IRPosition::IRP_ARGUMENT) && \"Expected an 'argument' position !\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 600, __extension__
 __PRETTY_FUNCTION__));
const CallBase *CBContext = Pos.getCallBaseContext();
if (!CBContext)
  return false;

int ArgNo = Pos.getCallSiteArgNo();
assert(ArgNo >= 0 && "Invalid Arg No!")(static_cast <bool> (ArgNo >= 0 && "Invalid Arg No!"
) ? void (0) : __assert_fail ("ArgNo >= 0 && \"Invalid Arg No!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 606, __extension__
 __PRETTY_FUNCTION__));

const auto &AA = A.getAAFor<AAType>(
    QueryingAttribute, IRPosition::callsite_argument(*CBContext, ArgNo),
    DepClassTy::REQUIRED);
const StateType &CBArgumentState =
    static_cast<const StateType &>(AA.getState());

LLVM_DEBUG(dbgs() << "[Attributor] Briding Call site context to argument"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Briding Call site context to argument"
 << "Position:" << Pos << "CB Arg state:" <<
 CBArgumentState << "\n"; } } while (false)
                  << "Position:" << Pos << "CB Arg state:" << CBArgumentStatedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Briding Call site context to argument"
 << "Position:" << Pos << "CB Arg state:" <<
 CBArgumentState << "\n"; } } while (false)
                  << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Briding Call site context to argument"
 << "Position:" << Pos << "CB Arg state:" <<
 CBArgumentState << "\n"; } } while (false);

// NOTE: If we want to do call site grouping it should happen here.
State ^= CBArgumentState;
return true;
621}

623/// Helper class for generic deduction: call site argument -> argument position.
624template <typename AAType, typename BaseType,
        typename StateType = typename AAType::StateType,
        bool BridgeCallBaseContext = false>
627struct AAArgumentFromCallSiteArguments : public BaseType {
AAArgumentFromCallSiteArguments(const IRPosition &IRP, Attributor &A)
    : BaseType(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  StateType S = StateType::getBestState(this->getState());

  if (BridgeCallBaseContext) {
    bool Success =
        getArgumentStateFromCallBaseContext<AAType, BaseType, StateType>(
            A, *this, this->getIRPosition(), S);
    if (Success)
      return clampStateAndIndicateChange<StateType>(this->getState(), S);
  }
  clampCallSiteArgumentStates<AAType, StateType>(A, *this, S);

  // TODO: If we know we visited all incoming values, thus no are assumed
  // dead, we can take the known information from the state T.
  return clampStateAndIndicateChange<StateType>(this->getState(), S);
}
648};

650/// Helper class for generic replication: function returned -> cs returned.
651template <typename AAType, typename BaseType,
        typename StateType = typename BaseType::StateType,
        bool IntroduceCallBaseContext = false>
654struct AACallSiteReturnedFromReturned : public BaseType {
AACallSiteReturnedFromReturned(const IRPosition &IRP, Attributor &A)
    : BaseType(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  assert(this->getIRPosition().getPositionKind() ==(static_cast <bool> (this->getIRPosition().getPositionKind
() == IRPosition::IRP_CALL_SITE_RETURNED && "Can only wrap function returned positions for call site returned "
 "positions!") ? void (0) : __assert_fail ("this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 663, __extension__
 __PRETTY_FUNCTION__))
             IRPosition::IRP_CALL_SITE_RETURNED &&(static_cast <bool> (this->getIRPosition().getPositionKind
() == IRPosition::IRP_CALL_SITE_RETURNED && "Can only wrap function returned positions for call site returned "
 "positions!") ? void (0) : __assert_fail ("this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 663, __extension__
 __PRETTY_FUNCTION__))
         "Can only wrap function returned positions for call site returned "(static_cast <bool> (this->getIRPosition().getPositionKind
() == IRPosition::IRP_CALL_SITE_RETURNED && "Can only wrap function returned positions for call site returned "
 "positions!") ? void (0) : __assert_fail ("this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 663, __extension__
 __PRETTY_FUNCTION__))
         "positions!")(static_cast <bool> (this->getIRPosition().getPositionKind
() == IRPosition::IRP_CALL_SITE_RETURNED && "Can only wrap function returned positions for call site returned "
 "positions!") ? void (0) : __assert_fail ("this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 663, __extension__
 __PRETTY_FUNCTION__));
  auto &S = this->getState();

  const Function *AssociatedFunction =
      this->getIRPosition().getAssociatedFunction();
  if (!AssociatedFunction)
    return S.indicatePessimisticFixpoint();

  CallBase &CBContext = cast<CallBase>(this->getAnchorValue());
  if (IntroduceCallBaseContext)
    LLVM_DEBUG(dbgs() << "[Attributor] Introducing call base context:"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Introducing call base context:"
 << CBContext << "\n"; } } while (false)
                      << CBContext << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Introducing call base context:"
 << CBContext << "\n"; } } while (false);

  IRPosition FnPos = IRPosition::returned(
      *AssociatedFunction, IntroduceCallBaseContext ? &CBContext : nullptr);
  const AAType &AA = A.getAAFor<AAType>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(S, AA.getState());
}
681};
682} // namespace

684/// Helper function to accumulate uses.
685template <class AAType, typename StateType = typename AAType::StateType>
686static void followUsesInContext(AAType &AA, Attributor &A,
                              MustBeExecutedContextExplorer &Explorer,
                              const Instruction *CtxI,
                              SetVector<const Use *> &Uses,
                              StateType &State) {
auto EIt = Explorer.begin(CtxI), EEnd = Explorer.end(CtxI);
for (unsigned u = 0; u < Uses.size(); ++u) {
  const Use *U = Uses[u];
  if (const Instruction *UserI = dyn_cast<Instruction>(U->getUser())) {
    bool Found = Explorer.findInContextOf(UserI, EIt, EEnd);
    if (Found && AA.followUseInMBEC(A, U, UserI, State))
      for (const Use &Us : UserI->uses())
        Uses.insert(&Us);
  }
}
701}

703/// Use the must-be-executed-context around \p I to add information into \p S.
704/// The AAType class is required to have `followUseInMBEC` method with the
705/// following signature and behaviour:
706///
707/// bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I)
708/// U - Underlying use.
709/// I - The user of the \p U.
710/// Returns true if the value should be tracked transitively.
711///
712template <class AAType, typename StateType = typename AAType::StateType>
713static void followUsesInMBEC(AAType &AA, Attributor &A, StateType &S,
                           Instruction &CtxI) {

// Container for (transitive) uses of the associated value.
SetVector<const Use *> Uses;
for (const Use &U : AA.getIRPosition().getAssociatedValue().uses())
  Uses.insert(&U);

MustBeExecutedContextExplorer &Explorer =
    A.getInfoCache().getMustBeExecutedContextExplorer();

followUsesInContext<AAType>(AA, A, Explorer, &CtxI, Uses, S);

if (S.isAtFixpoint())
  return;

SmallVector<const BranchInst *, 4> BrInsts;
auto Pred = [&](const Instruction *I) {
  if (const BranchInst *Br = dyn_cast<BranchInst>(I))
    if (Br->isConditional())
      BrInsts.push_back(Br);
  return true;
};

// Here, accumulate conditional branch instructions in the context. We
// explore the child paths and collect the known states. The disjunction of
// those states can be merged to its own state. Let ParentState_i be a state
// to indicate the known information for an i-th branch instruction in the
// context. ChildStates are created for its successors respectively.
//
// ParentS_1 = ChildS_{1, 1} /\ ChildS_{1, 2} /\ ... /\ ChildS_{1, n_1}
// ParentS_2 = ChildS_{2, 1} /\ ChildS_{2, 2} /\ ... /\ ChildS_{2, n_2}
//      ...
// ParentS_m = ChildS_{m, 1} /\ ChildS_{m, 2} /\ ... /\ ChildS_{m, n_m}
//
// Known State |= ParentS_1 \/ ParentS_2 \/... \/ ParentS_m
//
// FIXME: Currently, recursive branches are not handled. For example, we
// can't deduce that ptr must be dereferenced in below function.
//
// void f(int a, int c, int *ptr) {
//    if(a)
//      if (b) {
//        *ptr = 0;
//      } else {
//        *ptr = 1;
//      }
//    else {
//      if (b) {
//        *ptr = 0;
//      } else {
//        *ptr = 1;
//      }
//    }
// }

Explorer.checkForAllContext(&CtxI, Pred);
for (const BranchInst *Br : BrInsts) {
  StateType ParentState;

  // The known state of the parent state is a conjunction of children's
  // known states so it is initialized with a best state.
  ParentState.indicateOptimisticFixpoint();

  for (const BasicBlock *BB : Br->successors()) {
    StateType ChildState;

    size_t BeforeSize = Uses.size();
    followUsesInContext(AA, A, Explorer, &BB->front(), Uses, ChildState);

    // Erase uses which only appear in the child.
    for (auto It = Uses.begin() + BeforeSize; It != Uses.end();)
      It = Uses.erase(It);

    ParentState &= ChildState;
  }

  // Use only known state.
  S += ParentState;
}
793}

795/// ------------------------ PointerInfo ---------------------------------------

797namespace llvm {
798namespace AA {
799namespace PointerInfo {

801struct State;

803} // namespace PointerInfo
804} // namespace AA

806/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage.
807template <>
808struct DenseMapInfo<AAPointerInfo::Access> : DenseMapInfo<Instruction *> {
using Access = AAPointerInfo::Access;
static inline Access getEmptyKey();
static inline Access getTombstoneKey();
static unsigned getHashValue(const Access &A);
static bool isEqual(const Access &LHS, const Access &RHS);
814};

816/// Helper that allows OffsetAndSize as a key in a DenseMap.
817template <>
818struct DenseMapInfo<AAPointerInfo ::OffsetAndSize>
  : DenseMapInfo<std::pair<int64_t, int64_t>> {};

821/// Helper for AA::PointerInfo::Acccess DenseMap/Set usage ignoring everythign
822/// but the instruction
823struct AccessAsInstructionInfo : DenseMapInfo<Instruction *> {
using Base = DenseMapInfo<Instruction *>;
using Access = AAPointerInfo::Access;
static inline Access getEmptyKey();
static inline Access getTombstoneKey();
static unsigned getHashValue(const Access &A);
static bool isEqual(const Access &LHS, const Access &RHS);
830};

832} // namespace llvm

834/// Implementation of the DenseMapInfo.
835///
836///{
837inline llvm::AccessAsInstructionInfo::Access
838llvm::AccessAsInstructionInfo::getEmptyKey() {
return Access(Base::getEmptyKey(), nullptr, AAPointerInfo::AK_READ, nullptr);
840}
841inline llvm::AccessAsInstructionInfo::Access
842llvm::AccessAsInstructionInfo::getTombstoneKey() {
return Access(Base::getTombstoneKey(), nullptr, AAPointerInfo::AK_READ,
              nullptr);
845}
846unsigned llvm::AccessAsInstructionInfo::getHashValue(
  const llvm::AccessAsInstructionInfo::Access &A) {
return Base::getHashValue(A.getRemoteInst());
849}
850bool llvm::AccessAsInstructionInfo::isEqual(
  const llvm::AccessAsInstructionInfo::Access &LHS,
  const llvm::AccessAsInstructionInfo::Access &RHS) {
return LHS.getRemoteInst() == RHS.getRemoteInst();
854}
855inline llvm::DenseMapInfo<AAPointerInfo::Access>::Access
856llvm::DenseMapInfo<AAPointerInfo::Access>::getEmptyKey() {
return AAPointerInfo::Access(nullptr, nullptr, AAPointerInfo::AK_READ,
                             nullptr);
859}
860inline llvm::DenseMapInfo<AAPointerInfo::Access>::Access
861llvm::DenseMapInfo<AAPointerInfo::Access>::getTombstoneKey() {
return AAPointerInfo::Access(nullptr, nullptr, AAPointerInfo::AK_WRITE,
                             nullptr);
864}

866unsigned llvm::DenseMapInfo<AAPointerInfo::Access>::getHashValue(
  const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &A) {
return detail::combineHashValue(
           DenseMapInfo<Instruction *>::getHashValue(A.getRemoteInst()),
           (A.isWrittenValueYetUndetermined()
                ? ~0
                : DenseMapInfo<Value *>::getHashValue(A.getWrittenValue()))) +
       A.getKind();
874}

876bool llvm::DenseMapInfo<AAPointerInfo::Access>::isEqual(
  const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &LHS,
  const llvm::DenseMapInfo<AAPointerInfo::Access>::Access &RHS) {
return LHS == RHS;
880}
881///}

883/// A type to track pointer/struct usage and accesses for AAPointerInfo.
884struct AA::PointerInfo::State : public AbstractState {

/// Return the best possible representable state.
static State getBestState(const State &SIS) { return State(); }

/// Return the worst possible representable state.
static State getWorstState(const State &SIS) {
  State R;
  R.indicatePessimisticFixpoint();
  return R;
}

State() = default;
State(const State &SIS) : AccessBins(SIS.AccessBins) {}
State(State &&SIS) : AccessBins(std::move(SIS.AccessBins)) {}

const State &getAssumed() const { return *this; }

/// See AbstractState::isValidState().
bool isValidState() const override { return BS.isValidState(); }

/// See AbstractState::isAtFixpoint().
bool isAtFixpoint() const override { return BS.isAtFixpoint(); }

/// See AbstractState::indicateOptimisticFixpoint().
ChangeStatus indicateOptimisticFixpoint() override {
  BS.indicateOptimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}

/// See AbstractState::indicatePessimisticFixpoint().
ChangeStatus indicatePessimisticFixpoint() override {
  BS.indicatePessimisticFixpoint();
  return ChangeStatus::CHANGED;
}

State &operator=(const State &R) {
  if (this == &R)
    return *this;
  BS = R.BS;
  AccessBins = R.AccessBins;
  return *this;
}

State &operator=(State &&R) {
  if (this == &R)
    return *this;
  std::swap(BS, R.BS);
  std::swap(AccessBins, R.AccessBins);
  return *this;
}

bool operator==(const State &R) const {
  if (BS != R.BS)
    return false;
  if (AccessBins.size() != R.AccessBins.size())
    return false;
  auto It = begin(), RIt = R.begin(), E = end();
  while (It != E) {
    if (It->getFirst() != RIt->getFirst())
      return false;
    auto &Accs = It->getSecond();
    auto &RAccs = RIt->getSecond();
    if (Accs.size() != RAccs.size())
      return false;
    auto AccIt = Accs.begin(), RAccIt = RAccs.begin(), AccE = Accs.end();
    while (AccIt != AccE) {
      if (*AccIt != *RAccIt)
        return false;
      ++AccIt;
      ++RAccIt;
    }
    ++It;
    ++RIt;
  }
  return true;
}
bool operator!=(const State &R) const { return !(*this == R); }

/// We store accesses in a set with the instruction as key.
using Accesses = DenseSet<AAPointerInfo::Access, AccessAsInstructionInfo>;

/// We store all accesses in bins denoted by their offset and size.
using AccessBinsTy = DenseMap<AAPointerInfo::OffsetAndSize, Accesses>;

AccessBinsTy::const_iterator begin() const { return AccessBins.begin(); }
AccessBinsTy::const_iterator end() const { return AccessBins.end(); }

972protected:
/// The bins with all the accesses for the associated pointer.
DenseMap<AAPointerInfo::OffsetAndSize, Accesses> AccessBins;

/// Add a new access to the state at offset \p Offset and with size \p Size.
/// The access is associated with \p I, writes \p Content (if anything), and
/// is of kind \p Kind.
/// \Returns CHANGED, if the state changed, UNCHANGED otherwise.
ChangeStatus addAccess(int64_t Offset, int64_t Size, Instruction &I,
                       Optional<Value *> Content,
                       AAPointerInfo::AccessKind Kind, Type *Ty,
                       Instruction *RemoteI = nullptr,
                       Accesses *BinPtr = nullptr) {
  AAPointerInfo::OffsetAndSize Key{Offset, Size};
  Accesses &Bin = BinPtr ? *BinPtr : AccessBins[Key];
  AAPointerInfo::Access Acc(&I, RemoteI ? RemoteI : &I, Content, Kind, Ty);
  // Check if we have an access for this instruction in this bin, if not,
  // simply add it.
  auto It = Bin.find(Acc);
  if (It == Bin.end()) {
    Bin.insert(Acc);
    return ChangeStatus::CHANGED;
  }
  // If the existing access is the same as then new one, nothing changed.
  AAPointerInfo::Access Before = *It;
  // The new one will be combined with the existing one.
  *It &= Acc;
  return *It == Before ? ChangeStatus::UNCHANGED : ChangeStatus::CHANGED;
}

/// See AAPointerInfo::forallInterferingAccesses.
bool forallInterferingAccesses(
    AAPointerInfo::OffsetAndSize OAS,
    function_ref<bool(const AAPointerInfo::Access &, bool)> CB) const {
  if (!isValidState())
    return false;

  for (auto &It : AccessBins) {
    AAPointerInfo::OffsetAndSize ItOAS = It.getFirst();
    if (!OAS.mayOverlap(ItOAS))
      continue;
    bool IsExact = OAS == ItOAS && !OAS.offsetOrSizeAreUnknown();
    for (auto &Access : It.getSecond())
      if (!CB(Access, IsExact))
        return false;
  }
  return true;
}

/// See AAPointerInfo::forallInterferingAccesses.
bool forallInterferingAccesses(
    Instruction &I,
    function_ref<bool(const AAPointerInfo::Access &, bool)> CB) const {
  if (!isValidState())
    return false;

  // First find the offset and size of I.
  AAPointerInfo::OffsetAndSize OAS(-1, -1);
  for (auto &It : AccessBins) {
    for (auto &Access : It.getSecond()) {
      if (Access.getRemoteInst() == &I) {
        OAS = It.getFirst();
        break;
      }
    }
    if (OAS.getSize() != -1)
      break;
  }
  // No access for I was found, we are done.
  if (OAS.getSize() == -1)
    return true;

  // Now that we have an offset and size, find all overlapping ones and use
  // the callback on the accesses.
  return forallInterferingAccesses(OAS, CB);
}

1049private:
/// State to track fixpoint and validity.
BooleanState BS;
1052};

1054struct AAPointerInfoImpl
  : public StateWrapper<AA::PointerInfo::State, AAPointerInfo> {
using BaseTy = StateWrapper<AA::PointerInfo::State, AAPointerInfo>;
AAPointerInfoImpl(const IRPosition &IRP, Attributor &A) : BaseTy(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override { AAPointerInfo::initialize(A); }

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return std::string("PointerInfo ") +
         (isValidState() ? (std::string("#") +
                            std::to_string(AccessBins.size()) + " bins")
                         : "<invalid>");
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  return AAPointerInfo::manifest(A);
}

bool forallInterferingAccesses(
    OffsetAndSize OAS,
    function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
    const override {
  return State::forallInterferingAccesses(OAS, CB);
}
bool forallInterferingAccesses(
    LoadInst &LI, function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
    const override {
  return State::forallInterferingAccesses(LI, CB);
}
bool forallInterferingAccesses(
    StoreInst &SI, function_ref<bool(const AAPointerInfo::Access &, bool)> CB)
    const override {
  return State::forallInterferingAccesses(SI, CB);
}
bool forallInterferingWrites(
    Attributor &A, const AbstractAttribute &QueryingAA, LoadInst &LI,
    function_ref<bool(const Access &, bool)> UserCB) const override {
  SmallPtrSet<const Access *, 8> DominatingWrites;
  SmallVector<std::pair<const Access *, bool>, 8> InterferingWrites;

  Function &Scope = *LI.getFunction();
  const auto &NoSyncAA = A.getAAFor<AANoSync>(
      QueryingAA, IRPosition::function(Scope), DepClassTy::OPTIONAL);
  const auto *ExecDomainAA = A.lookupAAFor<AAExecutionDomain>(
      IRPosition::function(Scope), &QueryingAA, DepClassTy::OPTIONAL);
  const bool NoSync = NoSyncAA.isAssumedNoSync();

  // Helper to determine if we need to consider threading, which we cannot
  // right now. However, if the function is (assumed) nosync or the thread
  // executing all instructions is the main thread only we can ignore
  // threading.
  auto CanIgnoreThreading = [&](const Instruction &I) -> bool {
    if (NoSync)
      return true;
    if (ExecDomainAA && ExecDomainAA->isExecutedByInitialThreadOnly(I))
      return true;
    return false;
  };

  // Helper to determine if the access is executed by the same thread as the
  // load, for now it is sufficient to avoid any potential threading effects
  // as we cannot deal with them anyway.
  auto IsSameThreadAsLoad = [&](const Access &Acc) -> bool {
    return CanIgnoreThreading(*Acc.getLocalInst());
  };

  // TODO: Use inter-procedural reachability and dominance.
  const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
      QueryingAA, IRPosition::function(*LI.getFunction()),
      DepClassTy::OPTIONAL);

  const bool CanUseCFGResoning = CanIgnoreThreading(LI);
  InformationCache &InfoCache = A.getInfoCache();
  const DominatorTree *DT =
      NoRecurseAA.isKnownNoRecurse()
          ? InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(
                Scope)
          : nullptr;

  enum GPUAddressSpace : unsigned {
    Generic = 0,
    Global = 1,
    Shared = 3,
    Constant = 4,
    Local = 5,
  };

  // Helper to check if a value has "kernel lifetime", that is it will not
  // outlive a GPU kernel. This is true for shared, constant, and local
  // globals on AMD and NVIDIA GPUs.
  auto HasKernelLifetime = [&](Value *V, Module &M) {
    Triple T(M.getTargetTriple());
    if (!(T.isAMDGPU() || T.isNVPTX()))
      return false;
    switch (V->getType()->getPointerAddressSpace()) {
    case GPUAddressSpace::Shared:
    case GPUAddressSpace::Constant:
    case GPUAddressSpace::Local:
      return true;
    default:
      return false;
    };
  };

  // The IsLiveInCalleeCB will be used by the AA::isPotentiallyReachable query
  // to determine if we should look at reachability from the callee. For
  // certain pointers we know the lifetime and we do not have to step into the
  // callee to determine reachability as the pointer would be dead in the
  // callee. See the conditional initialization below.
  std::function<bool(const Function &)> IsLiveInCalleeCB;

  if (auto *AI = dyn_cast<AllocaInst>(&getAssociatedValue())) {
    // If the alloca containing function is not recursive the alloca
    // must be dead in the callee.
    const Function *AIFn = AI->getFunction();
    const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
        *this, IRPosition::function(*AIFn), DepClassTy::OPTIONAL);
    if (NoRecurseAA.isAssumedNoRecurse()) {
      IsLiveInCalleeCB = [AIFn](const Function &Fn) { return AIFn != &Fn; };
    }
  } else if (auto *GV = dyn_cast<GlobalValue>(&getAssociatedValue())) {
    // If the global has kernel lifetime we can stop if we reach a kernel
    // as it is "dead" in the (unknown) callees.
    if (HasKernelLifetime(GV, *GV->getParent()))
      IsLiveInCalleeCB = [](const Function &Fn) {
        return !Fn.hasFnAttribute("kernel");
      };
  }

  auto AccessCB = [&](const Access &Acc, bool Exact) {
    if (!Acc.isWrite())
      return true;

    // For now we only filter accesses based on CFG reasoning which does not
    // work yet if we have threading effects, or the access is complicated.
    if (CanUseCFGResoning) {
      if (!AA::isPotentiallyReachable(A, *Acc.getLocalInst(), LI, QueryingAA,
                                      IsLiveInCalleeCB))
        return true;
      if (DT && Exact &&
          (Acc.getLocalInst()->getFunction() == LI.getFunction()) &&
          IsSameThreadAsLoad(Acc)) {
        if (DT->dominates(Acc.getLocalInst(), &LI))
          DominatingWrites.insert(&Acc);
      }
    }

    InterferingWrites.push_back({&Acc, Exact});
    return true;
  };
  if (!State::forallInterferingAccesses(LI, AccessCB))
    return false;

  // If we cannot use CFG reasoning we only filter the non-write accesses
  // and are done here.
  if (!CanUseCFGResoning) {
    for (auto &It : InterferingWrites)
      if (!UserCB(*It.first, It.second))
        return false;
    return true;
  }

  // Helper to determine if we can skip a specific write access. This is in
  // the worst case quadratic as we are looking for another write that will
  // hide the effect of this one.
  auto CanSkipAccess = [&](const Access &Acc, bool Exact) {
    if (!IsSameThreadAsLoad(Acc))
      return false;
    if (!DominatingWrites.count(&Acc))
      return false;
    for (const Access *DomAcc : DominatingWrites) {
      assert(Acc.getLocalInst()->getFunction() ==(static_cast <bool> (Acc.getLocalInst()->getFunction
() == DomAcc->getLocalInst()->getFunction() && "Expected dominating writes to be in the same function!"
) ? void (0) : __assert_fail ("Acc.getLocalInst()->getFunction() == DomAcc->getLocalInst()->getFunction() && \"Expected dominating writes to be in the same function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1230, __extension__
 __PRETTY_FUNCTION__))
                 DomAcc->getLocalInst()->getFunction() &&(static_cast <bool> (Acc.getLocalInst()->getFunction
() == DomAcc->getLocalInst()->getFunction() && "Expected dominating writes to be in the same function!"
) ? void (0) : __assert_fail ("Acc.getLocalInst()->getFunction() == DomAcc->getLocalInst()->getFunction() && \"Expected dominating writes to be in the same function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1230, __extension__
 __PRETTY_FUNCTION__))
             "Expected dominating writes to be in the same function!")(static_cast <bool> (Acc.getLocalInst()->getFunction
() == DomAcc->getLocalInst()->getFunction() && "Expected dominating writes to be in the same function!"
) ? void (0) : __assert_fail ("Acc.getLocalInst()->getFunction() == DomAcc->getLocalInst()->getFunction() && \"Expected dominating writes to be in the same function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1230, __extension__
 __PRETTY_FUNCTION__));

      if (DomAcc != &Acc &&
          DT->dominates(Acc.getLocalInst(), DomAcc->getLocalInst())) {
        return true;
      }
    }
    return false;
  };

  // Run the user callback on all writes we cannot skip and return if that
  // succeeded for all or not.
  unsigned NumInterferingWrites = InterferingWrites.size();
  for (auto &It : InterferingWrites) {
    if (!DT || NumInterferingWrites > MaxInterferingWrites ||
        !CanSkipAccess(*It.first, It.second)) {
      if (!UserCB(*It.first, It.second))
        return false;
    }
  }
  return true;
}

ChangeStatus translateAndAddCalleeState(Attributor &A,
                                        const AAPointerInfo &CalleeAA,
                                        int64_t CallArgOffset, CallBase &CB) {
  using namespace AA::PointerInfo;
  if (!CalleeAA.getState().isValidState() || !isValidState())
    return indicatePessimisticFixpoint();

  const auto &CalleeImplAA = static_cast<const AAPointerInfoImpl &>(CalleeAA);
  bool IsByval = CalleeImplAA.getAssociatedArgument()->hasByValAttr();

  // Combine the accesses bin by bin.
  ChangeStatus Changed = ChangeStatus::UNCHANGED;
  for (auto &It : CalleeImplAA.getState()) {
    OffsetAndSize OAS = OffsetAndSize::getUnknown();
    if (CallArgOffset != OffsetAndSize::Unknown)
      OAS = OffsetAndSize(It.first.getOffset() + CallArgOffset,
                          It.first.getSize());
    Accesses &Bin = AccessBins[OAS];
    for (const AAPointerInfo::Access &RAcc : It.second) {
      if (IsByval && !RAcc.isRead())
        continue;
      bool UsedAssumedInformation = false;
      Optional<Value *> Content = A.translateArgumentToCallSiteContent(
          RAcc.getContent(), CB, *this, UsedAssumedInformation);
      AccessKind AK =
          AccessKind(RAcc.getKind() & (IsByval ? AccessKind::AK_READ
                                               : AccessKind::AK_READ_WRITE));
      Changed =
          Changed | addAccess(OAS.getOffset(), OAS.getSize(), CB, Content, AK,
                              RAcc.getType(), RAcc.getRemoteInst(), &Bin);
    }
  }
  return Changed;
}

/// Statistic tracking for all AAPointerInfo implementations.
/// See AbstractAttribute::trackStatistics().
void trackPointerInfoStatistics(const IRPosition &IRP) const {}
1291};

1293struct AAPointerInfoFloating : public AAPointerInfoImpl {
using AccessKind = AAPointerInfo::AccessKind;
AAPointerInfoFloating(const IRPosition &IRP, Attributor &A)
    : AAPointerInfoImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override { AAPointerInfoImpl::initialize(A); }

/// Deal with an access and signal if it was handled successfully.
bool handleAccess(Attributor &A, Instruction &I, Value &Ptr,
                  Optional<Value *> Content, AccessKind Kind, int64_t Offset,
                  ChangeStatus &Changed, Type *Ty,
                  int64_t Size = OffsetAndSize::Unknown) {
  using namespace AA::PointerInfo;
  // No need to find a size if one is given or the offset is unknown.
  if (Offset9.1
'Offset' is not equal to 'Unknown'
 != OffsetAndSize::Unknown && Size9.2
'Size' is equal to 'Unknown'
 == OffsetAndSize::Unknown &&
10
←
Taking false branch→
      Ty9.3
'Ty' is null
) {
    const DataLayout &DL = A.getDataLayout();
    TypeSize AccessSize = DL.getTypeStoreSize(Ty);
    if (!AccessSize.isScalable())
      Size = AccessSize.getFixedSize();
  }
  Changed = Changed | addAccess(Offset, Size, I, Content, Kind, Ty);
11
←
1st function call argument is an uninitialized value
  return true;
};

/// Helper struct, will support ranges eventually.
struct OffsetInfo {
  int64_t Offset = OffsetAndSize::Unknown;

  bool operator==(const OffsetInfo &OI) const { return Offset == OI.Offset; }
};

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  using namespace AA::PointerInfo;
  State S = getState();
  ChangeStatus Changed = ChangeStatus::UNCHANGED;
  Value &AssociatedValue = getAssociatedValue();

  const DataLayout &DL = A.getDataLayout();
  DenseMap<Value *, OffsetInfo> OffsetInfoMap;
  OffsetInfoMap[&AssociatedValue] = OffsetInfo{0};

  auto HandlePassthroughUser = [&](Value *Usr, OffsetInfo &PtrOI,
                                   bool &Follow) {
    OffsetInfo &UsrOI = OffsetInfoMap[Usr];
    UsrOI = PtrOI;
    Follow = true;
    return true;
  };

  const auto *TLI = getAnchorScope()
                        ? A.getInfoCache().getTargetLibraryInfoForFunction(
                              *getAnchorScope())
                        : nullptr;
  auto UsePred = [&](const Use &U, bool &Follow) -> bool {
    Value *CurPtr = U.get();
    User *Usr = U.getUser();
    LLVM_DEBUG(dbgs() << "[AAPointerInfo] Analyze " << *CurPtr << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Analyze " <<
 *CurPtr << " in " << *Usr << "\n"; } } while
 (false)
                      << *Usr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Analyze " <<
 *CurPtr << " in " << *Usr << "\n"; } } while
 (false);
    assert(OffsetInfoMap.count(CurPtr) &&(static_cast <bool> (OffsetInfoMap.count(CurPtr) &&
 "The current pointer offset should have been seeded!") ? void
 (0) : __assert_fail ("OffsetInfoMap.count(CurPtr) && \"The current pointer offset should have been seeded!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1355, __extension__
 __PRETTY_FUNCTION__))
           "The current pointer offset should have been seeded!")(static_cast <bool> (OffsetInfoMap.count(CurPtr) &&
 "The current pointer offset should have been seeded!") ? void
 (0) : __assert_fail ("OffsetInfoMap.count(CurPtr) && \"The current pointer offset should have been seeded!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1355, __extension__
 __PRETTY_FUNCTION__));

    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Usr)) {
      if (CE->isCast())
        return HandlePassthroughUser(Usr, OffsetInfoMap[CurPtr], Follow);
      if (CE->isCompare())
        return true;
      if (!isa<GEPOperator>(CE)) {
        LLVM_DEBUG(dbgs() << "[AAPointerInfo] Unhandled constant user " << *CEdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Unhandled constant user "
 << *CE << "\n"; } } while (false)
                          << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Unhandled constant user "
 << *CE << "\n"; } } while (false);
        return false;
      }
    }
    if (auto *GEP = dyn_cast<GEPOperator>(Usr)) {
      // Note the order here, the Usr access might change the map, CurPtr is
      // already in it though.
      OffsetInfo &UsrOI = OffsetInfoMap[Usr];
      OffsetInfo &PtrOI = OffsetInfoMap[CurPtr];
      UsrOI = PtrOI;

      // TODO: Use range information.
      if (PtrOI.Offset == OffsetAndSize::Unknown ||
          !GEP->hasAllConstantIndices()) {
        UsrOI.Offset = OffsetAndSize::Unknown;
        Follow = true;
        return true;
      }

      SmallVector<Value *, 8> Indices;
      for (Use &Idx : GEP->indices()) {
        if (auto *CIdx = dyn_cast<ConstantInt>(Idx)) {
          Indices.push_back(CIdx);
          continue;
        }

        LLVM_DEBUG(dbgs() << "[AAPointerInfo] Non constant GEP index " << *GEPdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Non constant GEP index "
 << *GEP << " : " << *Idx << "\n"; } }
 while (false)
                          << " : " << *Idx << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Non constant GEP index "
 << *GEP << " : " << *Idx << "\n"; } }
 while (false);
        return false;
      }
      UsrOI.Offset = PtrOI.Offset + DL.getIndexedOffsetInType(
                                        GEP->getSourceElementType(), Indices);
      Follow = true;
      return true;
    }
    if (isa<CastInst>(Usr) || isa<SelectInst>(Usr))
      return HandlePassthroughUser(Usr, OffsetInfoMap[CurPtr], Follow);

    // For PHIs we need to take care of the recurrence explicitly as the value
    // might change while we iterate through a loop. For now, we give up if
    // the PHI is not invariant.
    if (isa<PHINode>(Usr)) {
      // Note the order here, the Usr access might change the map, CurPtr is
      // already in it though.
      OffsetInfo &UsrOI = OffsetInfoMap[Usr];
      OffsetInfo &PtrOI = OffsetInfoMap[CurPtr];
      // Check if the PHI is invariant (so far).
      if (UsrOI == PtrOI)
        return true;

      // Check if the PHI operand has already an unknown offset as we can't
      // improve on that anymore.
      if (PtrOI.Offset == OffsetAndSize::Unknown) {
        UsrOI = PtrOI;
        Follow = true;
        return true;
      }

      // Check if the PHI operand is not dependent on the PHI itself.
      // TODO: This is not great as we look at the pointer type. However, it
      // is unclear where the Offset size comes from with typeless pointers.
      APInt Offset(
          DL.getIndexSizeInBits(CurPtr->getType()->getPointerAddressSpace()),
          0);
      if (&AssociatedValue == CurPtr->stripAndAccumulateConstantOffsets(
                                  DL, Offset, /* AllowNonInbounds */ true)) {
        if (Offset != PtrOI.Offset) {
          LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] PHI operand pointer offset mismatch "
 << *CurPtr << " in " << *Usr << "\n"
; } } while (false)
                     << "[AAPointerInfo] PHI operand pointer offset mismatch "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] PHI operand pointer offset mismatch "
 << *CurPtr << " in " << *Usr << "\n"
; } } while (false)
                     << *CurPtr << " in " << *Usr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] PHI operand pointer offset mismatch "
 << *CurPtr << " in " << *Usr << "\n"
; } } while (false);
          return false;
        }
        return HandlePassthroughUser(Usr, PtrOI, Follow);
      }

      // TODO: Approximate in case we know the direction of the recurrence.
      LLVM_DEBUG(dbgs() << "[AAPointerInfo] PHI operand is too complex "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] PHI operand is too complex "
 << *CurPtr << " in " << *Usr << "\n"
; } } while (false)
                        << *CurPtr << " in " << *Usr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] PHI operand is too complex "
 << *CurPtr << " in " << *Usr << "\n"
; } } while (false);
      UsrOI = PtrOI;
      UsrOI.Offset = OffsetAndSize::Unknown;
      Follow = true;
      return true;
    }

    if (auto *LoadI = dyn_cast<LoadInst>(Usr))
      return handleAccess(A, *LoadI, *CurPtr, /* Content */ nullptr,
                          AccessKind::AK_READ, OffsetInfoMap[CurPtr].Offset,
                          Changed, LoadI->getType());
    if (auto *StoreI = dyn_cast<StoreInst>(Usr)) {
      if (StoreI->getValueOperand() == CurPtr) {
        LLVM_DEBUG(dbgs() << "[AAPointerInfo] Escaping use in store "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Escaping use in store "
 << *StoreI << "\n"; } } while (false)
                          << *StoreI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Escaping use in store "
 << *StoreI << "\n"; } } while (false);
        return false;
      }
      bool UsedAssumedInformation = false;
      Optional<Value *> Content = A.getAssumedSimplified(
          *StoreI->getValueOperand(), *this, UsedAssumedInformation);
      return handleAccess(A, *StoreI, *CurPtr, Content, AccessKind::AK_WRITE,
                          OffsetInfoMap[CurPtr].Offset, Changed,
                          StoreI->getValueOperand()->getType());
    }
    if (auto *CB = dyn_cast<CallBase>(Usr)) {
      if (CB->isLifetimeStartOrEnd())
        return true;
      if (TLI && isFreeCall(CB, TLI))
        return true;
      if (CB->isArgOperand(&U)) {
        unsigned ArgNo = CB->getArgOperandNo(&U);
        const auto &CSArgPI = A.getAAFor<AAPointerInfo>(
            *this, IRPosition::callsite_argument(*CB, ArgNo),
            DepClassTy::REQUIRED);
        Changed = translateAndAddCalleeState(
                      A, CSArgPI, OffsetInfoMap[CurPtr].Offset, *CB) |
                  Changed;
        return true;
      }
      LLVM_DEBUG(dbgs() << "[AAPointerInfo] Call user not handled " << *CBdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Call user not handled "
 << *CB << "\n"; } } while (false)
                        << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Call user not handled "
 << *CB << "\n"; } } while (false);
      // TODO: Allow some call uses
      return false;
    }

    LLVM_DEBUG(dbgs() << "[AAPointerInfo] User not handled " << *Usr << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] User not handled "
 << *Usr << "\n"; } } while (false);
    return false;
  };
  auto EquivalentUseCB = [&](const Use &OldU, const Use &NewU) {
    if (OffsetInfoMap.count(NewU))
      return OffsetInfoMap[NewU] == OffsetInfoMap[OldU];
    OffsetInfoMap[NewU] = OffsetInfoMap[OldU];
    return true;
  };
  if (!A.checkForAllUses(UsePred, *this, AssociatedValue,
                         /* CheckBBLivenessOnly */ true, DepClassTy::OPTIONAL,
                         EquivalentUseCB))
    return indicatePessimisticFixpoint();

  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
    dbgs() << "Accesses by bin after update:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
    for (auto &It : AccessBins) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
      dbgs() << "[" << It.first.getOffset() << "-"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
             << It.first.getOffset() + It.first.getSize()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
             << "] : " << It.getSecond().size() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
      for (auto &Acc : It.getSecond()) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
        dbgs() << "     - " << Acc.getKind() << " - " << *Acc.getLocalInst()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
               << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
        if (Acc.getLocalInst() != Acc.getRemoteInst())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
          dbgs() << "     -->                         "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
                 << *Acc.getRemoteInst() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
        if (!Acc.isWrittenValueYetUndetermined())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
          dbgs() << "     - " << Acc.getWrittenValue() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
      }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
    }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "Accesses by bin after update:\n"
; for (auto &It : AccessBins) { dbgs() << "[" <<
 It.first.getOffset() << "-" << It.first.getOffset
() + It.first.getSize() << "] : " << It.getSecond
().size() << "\n"; for (auto &Acc : It.getSecond())
 { dbgs() << "     - " << Acc.getKind() << " - "
 << *Acc.getLocalInst() << "\n"; if (Acc.getLocalInst
() != Acc.getRemoteInst()) dbgs() << "     -->                         "
 << *Acc.getRemoteInst() << "\n"; if (!Acc.isWrittenValueYetUndetermined
()) dbgs() << "     - " << Acc.getWrittenValue() <<
 "\n"; } } }; } } while (false);

  return Changed;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
}
1525};

1527struct AAPointerInfoReturned final : AAPointerInfoImpl {
AAPointerInfoReturned(const IRPosition &IRP, Attributor &A)
    : AAPointerInfoImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
}
1540};

1542struct AAPointerInfoArgument final : AAPointerInfoFloating {
AAPointerInfoArgument(const IRPosition &IRP, Attributor &A)
    : AAPointerInfoFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAPointerInfoFloating::initialize(A);
  if (getAnchorScope()->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
}
1557};

1559struct AAPointerInfoCallSiteArgument final : AAPointerInfoFloating {
AAPointerInfoCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAPointerInfoFloating(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  using namespace AA::PointerInfo;
  // We handle memory intrinsics explicitly, at least the first (=
  // destination) and second (=source) arguments as we know how they are
  // accessed.
  if (auto *MI1.1
'MI' is non-null
 = dyn_cast_or_null<MemIntrinsic>(getCtxI())) {
1
Assuming the object is a 'MemIntrinsic'→
2
←
Taking true branch→
    ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
    int64_t LengthVal = OffsetAndSize::Unknown;
    if (Length)
3
←
Assuming 'Length' is null→
4
←
Taking false branch→
      LengthVal = Length->getSExtValue();
    Value &Ptr = getAssociatedValue();
    unsigned ArgNo = getIRPosition().getCallSiteArgNo();
    ChangeStatus Changed;
5
←
'Changed' declared without an initial value→
    if (ArgNo == 0) {
6
←
Assuming 'ArgNo' is equal to 0→
7
←
Taking true branch→
      handleAccess(A, *MI, Ptr, nullptr, AccessKind::AK_WRITE, 0, Changed,
8
←
Passing value via 7th parameter 'Changed'→
9
←
Calling 'AAPointerInfoFloating::handleAccess'→
                   nullptr, LengthVal);
    } else if (ArgNo == 1) {
      handleAccess(A, *MI, Ptr, nullptr, AccessKind::AK_READ, 0, Changed,
                   nullptr, LengthVal);
    } else {
      LLVM_DEBUG(dbgs() << "[AAPointerInfo] Unhandled memory intrinsic "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Unhandled memory intrinsic "
 << *MI << "\n"; } } while (false)
                        << *MI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPointerInfo] Unhandled memory intrinsic "
 << *MI << "\n"; } } while (false);
      return indicatePessimisticFixpoint();
    }
    return Changed;
  }

  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Argument *Arg = getAssociatedArgument();
  if (!Arg)
    return indicatePessimisticFixpoint();
  const IRPosition &ArgPos = IRPosition::argument(*Arg);
  auto &ArgAA =
      A.getAAFor<AAPointerInfo>(*this, ArgPos, DepClassTy::REQUIRED);
  return translateAndAddCalleeState(A, ArgAA, 0, *cast<CallBase>(getCtxI()));
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
}
1608};

1610struct AAPointerInfoCallSiteReturned final : AAPointerInfoFloating {
AAPointerInfoCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AAPointerInfoFloating(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  AAPointerInfoImpl::trackPointerInfoStatistics(getIRPosition());
}
1618};

1620/// -----------------------NoUnwind Function Attribute--------------------------

1622struct AANoUnwindImpl : AANoUnwind {
AANoUnwindImpl(const IRPosition &IRP, Attributor &A) : AANoUnwind(IRP, A) {}

const std::string getAsStr() const override {
  return getAssumed() ? "nounwind" : "may-unwind";
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto Opcodes = {
      (unsigned)Instruction::Invoke,      (unsigned)Instruction::CallBr,
      (unsigned)Instruction::Call,        (unsigned)Instruction::CleanupRet,
      (unsigned)Instruction::CatchSwitch, (unsigned)Instruction::Resume};

  auto CheckForNoUnwind = [&](Instruction &I) {
    if (!I.mayThrow())
      return true;

    if (const auto *CB = dyn_cast<CallBase>(&I)) {
      const auto &NoUnwindAA = A.getAAFor<AANoUnwind>(
          *this, IRPosition::callsite_function(*CB), DepClassTy::REQUIRED);
      return NoUnwindAA.isAssumedNoUnwind();
    }
    return false;
  };

  bool UsedAssumedInformation = false;
  if (!A.checkForAllInstructions(CheckForNoUnwind, *this, Opcodes,
                                 UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}
1655};

1657struct AANoUnwindFunction final : public AANoUnwindImpl {
AANoUnwindFunction(const IRPosition &IRP, Attributor &A)
    : AANoUnwindImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nounwind){ static llvm::Statistic NumIRFunction_nounwind = {"attributor"
, "NumIRFunction_nounwind", ("Number of " "functions" " marked '"
 "nounwind" "'")};; ++(NumIRFunction_nounwind); } }
1663};

1665/// NoUnwind attribute deduction for a call sites.
1666struct AANoUnwindCallSite final : AANoUnwindImpl {
AANoUnwindCallSite(const IRPosition &IRP, Attributor &A)
    : AANoUnwindImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoUnwindImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AANoUnwind>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nounwind){ static llvm::Statistic NumIRCS_nounwind = {"attributor", "NumIRCS_nounwind"
, ("Number of " "call site" " marked '" "nounwind" "'")};; ++
(NumIRCS_nounwind); }; }
1692};

1694/// --------------------- Function Return Values -------------------------------

1696/// "Attribute" that collects all potential returned values and the return
1697/// instructions that they arise from.
1698///
1699/// If there is a unique returned value R, the manifest method will:
1700///   - mark R with the "returned" attribute, if R is an argument.
1701class AAReturnedValuesImpl : public AAReturnedValues, public AbstractState {

/// Mapping of values potentially returned by the associated function to the
/// return instructions that might return them.
MapVector<Value *, SmallSetVector<ReturnInst *, 4>> ReturnedValues;

/// State flags
///
///{
bool IsFixed = false;
bool IsValidState = true;
///}

1714public:
AAReturnedValuesImpl(const IRPosition &IRP, Attributor &A)
    : AAReturnedValues(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // Reset the state.
  IsFixed = false;
  IsValidState = true;
  ReturnedValues.clear();

  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration()) {
    indicatePessimisticFixpoint();
    return;
  }
  assert(!F->getReturnType()->isVoidTy() &&(static_cast <bool> (!F->getReturnType()->isVoidTy
() && "Did not expect a void return type!") ? void (0
) : __assert_fail ("!F->getReturnType()->isVoidTy() && \"Did not expect a void return type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1731, __extension__
 __PRETTY_FUNCTION__))
         "Did not expect a void return type!")(static_cast <bool> (!F->getReturnType()->isVoidTy
() && "Did not expect a void return type!") ? void (0
) : __assert_fail ("!F->getReturnType()->isVoidTy() && \"Did not expect a void return type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1731, __extension__
 __PRETTY_FUNCTION__));

  // The map from instruction opcodes to those instructions in the function.
  auto &OpcodeInstMap = A.getInfoCache().getOpcodeInstMapForFunction(*F);

  // Look through all arguments, if one is marked as returned we are done.
  for (Argument &Arg : F->args()) {
    if (Arg.hasReturnedAttr()) {
      auto &ReturnInstSet = ReturnedValues[&Arg];
      if (auto *Insts = OpcodeInstMap.lookup(Instruction::Ret))
        for (Instruction *RI : *Insts)
          ReturnInstSet.insert(cast<ReturnInst>(RI));

      indicateOptimisticFixpoint();
      return;
    }
  }

  if (!A.isFunctionIPOAmendable(*F))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override;

/// See AbstractAttribute::getState(...).
AbstractState &getState() override { return *this; }

/// See AbstractAttribute::getState(...).
const AbstractState &getState() const override { return *this; }

/// See AbstractAttribute::updateImpl(Attributor &A).
ChangeStatus updateImpl(Attributor &A) override;

llvm::iterator_range<iterator> returned_values() override {
  return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
}

llvm::iterator_range<const_iterator> returned_values() const override {
  return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
}

/// Return the number of potential return values, -1 if unknown.
size_t getNumReturnValues() const override {
  return isValidState() ? ReturnedValues.size() : -1;
}

/// Return an assumed unique return value if a single candidate is found. If
/// there cannot be one, return a nullptr. If it is not clear yet, return the
/// Optional::NoneType.
Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;

/// See AbstractState::checkForAllReturnedValues(...).
bool checkForAllReturnedValuesAndReturnInsts(
    function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
    const override;

/// Pretty print the attribute similar to the IR representation.
const std::string getAsStr() const override;

/// See AbstractState::isAtFixpoint().
bool isAtFixpoint() const override { return IsFixed; }

/// See AbstractState::isValidState().
bool isValidState() const override { return IsValidState; }

/// See AbstractState::indicateOptimisticFixpoint(...).
ChangeStatus indicateOptimisticFixpoint() override {
  IsFixed = true;
  return ChangeStatus::UNCHANGED;
}

ChangeStatus indicatePessimisticFixpoint() override {
  IsFixed = true;
  IsValidState = false;
  return ChangeStatus::CHANGED;
}
1808};

1810ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
ChangeStatus Changed = ChangeStatus::UNCHANGED;

// Bookkeeping.
assert(isValidState())(static_cast <bool> (isValidState()) ? void (0) : __assert_fail
 ("isValidState()", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 1814, __extension__ __PRETTY_FUNCTION__));
STATS_DECLTRACK(KnownReturnValues, FunctionReturn,{ static llvm::Statistic NumIRFunctionReturn_KnownReturnValues
 = {"attributor", "NumIRFunctionReturn_KnownReturnValues", "Number of function with known return values"
};; ++(NumIRFunctionReturn_KnownReturnValues); }
                "Number of function with known return values"){ static llvm::Statistic NumIRFunctionReturn_KnownReturnValues
 = {"attributor", "NumIRFunctionReturn_KnownReturnValues", "Number of function with known return values"
};; ++(NumIRFunctionReturn_KnownReturnValues); };

// Check if we have an assumed unique return value that we could manifest.
Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);

if (!UniqueRV.hasValue() || !UniqueRV.getValue())
  return Changed;

// Bookkeeping.
STATS_DECLTRACK(UniqueReturnValue, FunctionReturn,{ static llvm::Statistic NumIRFunctionReturn_UniqueReturnValue
 = {"attributor", "NumIRFunctionReturn_UniqueReturnValue", "Number of function with unique return"
};; ++(NumIRFunctionReturn_UniqueReturnValue); }
                "Number of function with unique return"){ static llvm::Statistic NumIRFunctionReturn_UniqueReturnValue
 = {"attributor", "NumIRFunctionReturn_UniqueReturnValue", "Number of function with unique return"
};; ++(NumIRFunctionReturn_UniqueReturnValue); };
// If the assumed unique return value is an argument, annotate it.
if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
  if (UniqueRVArg->getType()->canLosslesslyBitCastTo(
          getAssociatedFunction()->getReturnType())) {
    getIRPosition() = IRPosition::argument(*UniqueRVArg);
    Changed = IRAttribute::manifest(A);
  }
}
return Changed;
1836}

1838const std::string AAReturnedValuesImpl::getAsStr() const {
return (isAtFixpoint() ? "returns(#" : "may-return(#") +
       (isValidState() ? std::to_string(getNumReturnValues()) : "?") + ")";
1841}

1843Optional<Value *>
1844AAReturnedValuesImpl::getAssumedUniqueReturnValue(Attributor &A) const {
// If checkForAllReturnedValues provides a unique value, ignoring potential
// undef values that can also be present, it is assumed to be the actual
// return value and forwarded to the caller of this method. If there are
// multiple, a nullptr is returned indicating there cannot be a unique
// returned value.
Optional<Value *> UniqueRV;
Type *Ty = getAssociatedFunction()->getReturnType();

auto Pred = [&](Value &RV) -> bool {
  UniqueRV = AA::combineOptionalValuesInAAValueLatice(UniqueRV, &RV, Ty);
  return UniqueRV != Optional<Value *>(nullptr);
};

if (!A.checkForAllReturnedValues(Pred, *this))
  UniqueRV = nullptr;

return UniqueRV;
1862}

1864bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
  function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)> Pred)
  const {
if (!isValidState())
  return false;

// Check all returned values but ignore call sites as long as we have not
// encountered an overdefined one during an update.
for (auto &It : ReturnedValues) {
  Value *RV = It.first;
  if (!Pred(*RV, It.second))
    return false;
}

return true;
1879}

1881ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) {
ChangeStatus Changed = ChangeStatus::UNCHANGED;

auto ReturnValueCB = [&](Value &V, const Instruction *CtxI, ReturnInst &Ret,
                         bool) -> bool {
  assert(AA::isValidInScope(V, Ret.getFunction()) &&(static_cast <bool> (AA::isValidInScope(V, Ret.getFunction
()) && "Assumed returned value should be valid in function scope!"
) ? void (0) : __assert_fail ("AA::isValidInScope(V, Ret.getFunction()) && \"Assumed returned value should be valid in function scope!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1887, __extension__
 __PRETTY_FUNCTION__))
         "Assumed returned value should be valid in function scope!")(static_cast <bool> (AA::isValidInScope(V, Ret.getFunction
()) && "Assumed returned value should be valid in function scope!"
) ? void (0) : __assert_fail ("AA::isValidInScope(V, Ret.getFunction()) && \"Assumed returned value should be valid in function scope!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1887, __extension__
 __PRETTY_FUNCTION__));
  if (ReturnedValues[&V].insert(&Ret))
    Changed = ChangeStatus::CHANGED;
  return true;
};

bool UsedAssumedInformation = false;
auto ReturnInstCB = [&](Instruction &I) {
  ReturnInst &Ret = cast<ReturnInst>(I);
  return genericValueTraversal<ReturnInst>(
      A, IRPosition::value(*Ret.getReturnValue()), *this, Ret, ReturnValueCB,
      &I, UsedAssumedInformation, /* UseValueSimplify */ true,
      /* MaxValues */ 16,
      /* StripCB */ nullptr, /* Intraprocedural */ true);
};

// Discover returned values from all live returned instructions in the
// associated function.
if (!A.checkForAllInstructions(ReturnInstCB, *this, {Instruction::Ret},
                               UsedAssumedInformation))
  return indicatePessimisticFixpoint();
return Changed;
1909}

1911struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
AAReturnedValuesFunction(const IRPosition &IRP, Attributor &A)
    : AAReturnedValuesImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(returned){ static llvm::Statistic NumIRArguments_returned = {"attributor"
, "NumIRArguments_returned", ("Number of " "arguments" " marked '"
 "returned" "'")};; ++(NumIRArguments_returned); } }
1917};

1919/// Returned values information for a call sites.
1920struct AAReturnedValuesCallSite final : AAReturnedValuesImpl {
AAReturnedValuesCallSite(const IRPosition &IRP, Attributor &A)
    : AAReturnedValuesImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites instead of
  //       redirecting requests to the callee.
  llvm_unreachable("Abstract attributes for returned values are not "::llvm::llvm_unreachable_internal("Abstract attributes for returned values are not "
 "supported for call sites yet!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 1931)
                   "supported for call sites yet!")::llvm::llvm_unreachable_internal("Abstract attributes for returned values are not "
 "supported for call sites yet!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 1931);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}
1941};

1943/// ------------------------ NoSync Function Attribute -------------------------

1945struct AANoSyncImpl : AANoSync {
AANoSyncImpl(const IRPosition &IRP, Attributor &A) : AANoSync(IRP, A) {}

const std::string getAsStr() const override {
  return getAssumed() ? "nosync" : "may-sync";
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override;
1954};

1956bool AANoSync::isNonRelaxedAtomic(const Instruction *I) {
if (!I->isAtomic())
  return false;

if (auto *FI = dyn_cast<FenceInst>(I))
  // All legal orderings for fence are stronger than monotonic.
  return FI->getSyncScopeID() != SyncScope::SingleThread;
if (auto *AI = dyn_cast<AtomicCmpXchgInst>(I)) {
  // Unordered is not a legal ordering for cmpxchg.
  return (AI->getSuccessOrdering() != AtomicOrdering::Monotonic ||
          AI->getFailureOrdering() != AtomicOrdering::Monotonic);
}

AtomicOrdering Ordering;
switch (I->getOpcode()) {
case Instruction::AtomicRMW:
  Ordering = cast<AtomicRMWInst>(I)->getOrdering();
  break;
case Instruction::Store:
  Ordering = cast<StoreInst>(I)->getOrdering();
  break;
case Instruction::Load:
  Ordering = cast<LoadInst>(I)->getOrdering();
  break;
default:
  llvm_unreachable(::llvm::llvm_unreachable_internal("New atomic operations need to be known in the attributor."
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1982)
      "New atomic operations need to be known in the attributor.")::llvm::llvm_unreachable_internal("New atomic operations need to be known in the attributor."
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 1982);
}

return (Ordering != AtomicOrdering::Unordered &&
        Ordering != AtomicOrdering::Monotonic);
1987}

1989/// Return true if this intrinsic is nosync.  This is only used for intrinsics
1990/// which would be nosync except that they have a volatile flag.  All other
1991/// intrinsics are simply annotated with the nosync attribute in Intrinsics.td.
1992bool AANoSync::isNoSyncIntrinsic(const Instruction *I) {
if (auto *MI = dyn_cast<MemIntrinsic>(I))
  return !MI->isVolatile();
return false;
1996}

1998ChangeStatus AANoSyncImpl::updateImpl(Attributor &A) {

auto CheckRWInstForNoSync = [&](Instruction &I) {
  return AA::isNoSyncInst(A, I, *this);
};

auto CheckForNoSync = [&](Instruction &I) {
  // At this point we handled all read/write effects and they are all
  // nosync, so they can be skipped.
  if (I.mayReadOrWriteMemory())
    return true;

  // non-convergent and readnone imply nosync.
  return !cast<CallBase>(I).isConvergent();
};

bool UsedAssumedInformation = false;
if (!A.checkForAllReadWriteInstructions(CheckRWInstForNoSync, *this,
                                        UsedAssumedInformation) ||
    !A.checkForAllCallLikeInstructions(CheckForNoSync, *this,
                                       UsedAssumedInformation))
  return indicatePessimisticFixpoint();

return ChangeStatus::UNCHANGED;
2022}

2024struct AANoSyncFunction final : public AANoSyncImpl {
AANoSyncFunction(const IRPosition &IRP, Attributor &A)
    : AANoSyncImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nosync){ static llvm::Statistic NumIRFunction_nosync = {"attributor"
, "NumIRFunction_nosync", ("Number of " "functions" " marked '"
 "nosync" "'")};; ++(NumIRFunction_nosync); } }
2030};

2032/// NoSync attribute deduction for a call sites.
2033struct AANoSyncCallSite final : AANoSyncImpl {
AANoSyncCallSite(const IRPosition &IRP, Attributor &A)
    : AANoSyncImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoSyncImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AANoSync>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nosync){ static llvm::Statistic NumIRCS_nosync = {"attributor", "NumIRCS_nosync"
, ("Number of " "call site" " marked '" "nosync" "'")};; ++(NumIRCS_nosync
); }; }
2059};

2061/// ------------------------ No-Free Attributes ----------------------------

2063struct AANoFreeImpl : public AANoFree {
AANoFreeImpl(const IRPosition &IRP, Attributor &A) : AANoFree(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto CheckForNoFree = [&](Instruction &I) {
    const auto &CB = cast<CallBase>(I);
    if (CB.hasFnAttr(Attribute::NoFree))
      return true;

    const auto &NoFreeAA = A.getAAFor<AANoFree>(
        *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);
    return NoFreeAA.isAssumedNoFree();
  };

  bool UsedAssumedInformation = false;
  if (!A.checkForAllCallLikeInstructions(CheckForNoFree, *this,
                                         UsedAssumedInformation))
    return indicatePessimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? "nofree" : "may-free";
}
2089};

2091struct AANoFreeFunction final : public AANoFreeImpl {
AANoFreeFunction(const IRPosition &IRP, Attributor &A)
    : AANoFreeImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(nofree){ static llvm::Statistic NumIRFunction_nofree = {"attributor"
, "NumIRFunction_nofree", ("Number of " "functions" " marked '"
 "nofree" "'")};; ++(NumIRFunction_nofree); } }
2097};

2099/// NoFree attribute deduction for a call sites.
2100struct AANoFreeCallSite final : AANoFreeImpl {
AANoFreeCallSite(const IRPosition &IRP, Attributor &A)
    : AANoFreeImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoFreeImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AANoFree>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(nofree){ static llvm::Statistic NumIRCS_nofree = {"attributor", "NumIRCS_nofree"
, ("Number of " "call site" " marked '" "nofree" "'")};; ++(NumIRCS_nofree
); }; }
2126};

2128/// NoFree attribute for floating values.
2129struct AANoFreeFloating : AANoFreeImpl {
AANoFreeFloating(const IRPosition &IRP, Attributor &A)
    : AANoFreeImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override{STATS_DECLTRACK_FLOATING_ATTR(nofree){ static llvm::Statistic NumIRFloating_nofree = {"attributor"
, "NumIRFloating_nofree", ("Number of floating values known to be '"
 "nofree" "'")};; ++(NumIRFloating_nofree); }}

/// See Abstract Attribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const IRPosition &IRP = getIRPosition();

  const auto &NoFreeAA = A.getAAFor<AANoFree>(
      *this, IRPosition::function_scope(IRP), DepClassTy::OPTIONAL);
  if (NoFreeAA.isAssumedNoFree())
    return ChangeStatus::UNCHANGED;

  Value &AssociatedValue = getIRPosition().getAssociatedValue();
  auto Pred = [&](const Use &U, bool &Follow) -> bool {
    Instruction *UserI = cast<Instruction>(U.getUser());
    if (auto *CB = dyn_cast<CallBase>(UserI)) {
      if (CB->isBundleOperand(&U))
        return false;
      if (!CB->isArgOperand(&U))
        return true;
      unsigned ArgNo = CB->getArgOperandNo(&U);

      const auto &NoFreeArg = A.getAAFor<AANoFree>(
          *this, IRPosition::callsite_argument(*CB, ArgNo),
          DepClassTy::REQUIRED);
      return NoFreeArg.isAssumedNoFree();
    }

    if (isa<GetElementPtrInst>(UserI) || isa<BitCastInst>(UserI) ||
        isa<PHINode>(UserI) || isa<SelectInst>(UserI)) {
      Follow = true;
      return true;
    }
    if (isa<StoreInst>(UserI) || isa<LoadInst>(UserI) ||
        isa<ReturnInst>(UserI))
      return true;

    // Unknown user.
    return false;
  };
  if (!A.checkForAllUses(Pred, *this, AssociatedValue))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}
2178};

2180/// NoFree attribute for a call site argument.
2181struct AANoFreeArgument final : AANoFreeFloating {
AANoFreeArgument(const IRPosition &IRP, Attributor &A)
    : AANoFreeFloating(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nofree){ static llvm::Statistic NumIRArguments_nofree = {"attributor"
, "NumIRArguments_nofree", ("Number of " "arguments" " marked '"
 "nofree" "'")};; ++(NumIRArguments_nofree); } }
2187};

2189/// NoFree attribute for call site arguments.
2190struct AANoFreeCallSiteArgument final : AANoFreeFloating {
AANoFreeCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AANoFreeFloating(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Argument *Arg = getAssociatedArgument();
  if (!Arg)
    return indicatePessimisticFixpoint();
  const IRPosition &ArgPos = IRPosition::argument(*Arg);
  auto &ArgAA = A.getAAFor<AANoFree>(*this, ArgPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), ArgAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override{STATS_DECLTRACK_CSARG_ATTR(nofree){ static llvm::Statistic NumIRCSArguments_nofree = {"attributor"
, "NumIRCSArguments_nofree", ("Number of " "call site arguments"
 " marked '" "nofree" "'")};; ++(NumIRCSArguments_nofree); }};
2210};

2212/// NoFree attribute for function return value.
2213struct AANoFreeReturned final : AANoFreeFloating {
AANoFreeReturned(const IRPosition &IRP, Attributor &A)
    : AANoFreeFloating(IRP, A) {
  llvm_unreachable("NoFree is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoFree is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 2216);
}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  llvm_unreachable("NoFree is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoFree is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 2221);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable("NoFree is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoFree is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 2226);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}
2231};

2233/// NoFree attribute deduction for a call site return value.
2234struct AANoFreeCallSiteReturned final : AANoFreeFloating {
AANoFreeCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AANoFreeFloating(IRP, A) {}

ChangeStatus manifest(Attributor &A) override {
  return ChangeStatus::UNCHANGED;
}
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nofree){ static llvm::Statistic NumIRCSReturn_nofree = {"attributor"
, "NumIRCSReturn_nofree", ("Number of " "call site returns" " marked '"
 "nofree" "'")};; ++(NumIRCSReturn_nofree); } }
2243};

2245/// ------------------------ NonNull Argument Attribute ------------------------
2246static int64_t getKnownNonNullAndDerefBytesForUse(
  Attributor &A, const AbstractAttribute &QueryingAA, Value &AssociatedValue,
  const Use *U, const Instruction *I, bool &IsNonNull, bool &TrackUse) {
TrackUse = false;

const Value *UseV = U->get();
if (!UseV->getType()->isPointerTy())
  return 0;

// We need to follow common pointer manipulation uses to the accesses they
// feed into. We can try to be smart to avoid looking through things we do not
// like for now, e.g., non-inbounds GEPs.
if (isa<CastInst>(I)) {
  TrackUse = true;
  return 0;
}

if (isa<GetElementPtrInst>(I)) {
  TrackUse = true;
  return 0;
}

Type *PtrTy = UseV->getType();
const Function *F = I->getFunction();
bool NullPointerIsDefined =
    F ? llvm::NullPointerIsDefined(F, PtrTy->getPointerAddressSpace()) : true;
const DataLayout &DL = A.getInfoCache().getDL();
if (const auto *CB = dyn_cast<CallBase>(I)) {
  if (CB->isBundleOperand(U)) {
    if (RetainedKnowledge RK = getKnowledgeFromUse(
            U, {Attribute::NonNull, Attribute::Dereferenceable})) {
      IsNonNull |=
          (RK.AttrKind == Attribute::NonNull || !NullPointerIsDefined);
      return RK.ArgValue;
    }
    return 0;
  }

  if (CB->isCallee(U)) {
    IsNonNull |= !NullPointerIsDefined;
    return 0;
  }

  unsigned ArgNo = CB->getArgOperandNo(U);
  IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
  // As long as we only use known information there is no need to track
  // dependences here.
  auto &DerefAA =
      A.getAAFor<AADereferenceable>(QueryingAA, IRP, DepClassTy::NONE);
  IsNonNull |= DerefAA.isKnownNonNull();
  return DerefAA.getKnownDereferenceableBytes();
}

Optional<MemoryLocation> Loc = MemoryLocation::getOrNone(I);
if (!Loc || Loc->Ptr != UseV || !Loc->Size.isPrecise() || I->isVolatile())
  return 0;

int64_t Offset;
const Value *Base =
    getMinimalBaseOfPointer(A, QueryingAA, Loc->Ptr, Offset, DL);
if (Base && Base == &AssociatedValue) {
  int64_t DerefBytes = Loc->Size.getValue() + Offset;
  IsNonNull |= !NullPointerIsDefined;
  return std::max(int64_t(0), DerefBytes);
}

/// Corner case when an offset is 0.
Base = GetPointerBaseWithConstantOffset(Loc->Ptr, Offset, DL,
                                        /*AllowNonInbounds*/ true);
if (Base && Base == &AssociatedValue && Offset == 0) {
  int64_t DerefBytes = Loc->Size.getValue();
  IsNonNull |= !NullPointerIsDefined;
  return std::max(int64_t(0), DerefBytes);
}

return 0;
2322}

2324struct AANonNullImpl : AANonNull {
AANonNullImpl(const IRPosition &IRP, Attributor &A)
    : AANonNull(IRP, A),
      NullIsDefined(NullPointerIsDefined(
          getAnchorScope(),
          getAssociatedValue().getType()->getPointerAddressSpace())) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  Value &V = getAssociatedValue();
  if (!NullIsDefined &&
      hasAttr({Attribute::NonNull, Attribute::Dereferenceable},
              /* IgnoreSubsumingPositions */ false, &A)) {
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<ConstantPointerNull>(V)) {
    indicatePessimisticFixpoint();
    return;
  }

  AANonNull::initialize(A);

  bool CanBeNull, CanBeFreed;
  if (V.getPointerDereferenceableBytes(A.getDataLayout(), CanBeNull,
                                       CanBeFreed)) {
    if (!CanBeNull) {
      indicateOptimisticFixpoint();
      return;
    }
  }

  if (isa<GlobalValue>(&getAssociatedValue())) {
    indicatePessimisticFixpoint();
    return;
  }

  if (Instruction *CtxI = getCtxI())
    followUsesInMBEC(*this, A, getState(), *CtxI);
}

/// See followUsesInMBEC
bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
                     AANonNull::StateType &State) {
  bool IsNonNull = false;
  bool TrackUse = false;
  getKnownNonNullAndDerefBytesForUse(A, *this, getAssociatedValue(), U, I,
                                     IsNonNull, TrackUse);
  State.setKnown(IsNonNull);
  return TrackUse;
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? "nonnull" : "may-null";
}

/// Flag to determine if the underlying value can be null and still allow
/// valid accesses.
const bool NullIsDefined;
2385};

2387/// NonNull attribute for a floating value.
2388struct AANonNullFloating : public AANonNullImpl {
AANonNullFloating(const IRPosition &IRP, Attributor &A)
    : AANonNullImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const DataLayout &DL = A.getDataLayout();

  DominatorTree *DT = nullptr;
  AssumptionCache *AC = nullptr;
  InformationCache &InfoCache = A.getInfoCache();
  if (const Function *Fn = getAnchorScope()) {
    DT = InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*Fn);
    AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*Fn);
  }

  auto VisitValueCB = [&](Value &V, const Instruction *CtxI,
                          AANonNull::StateType &T, bool Stripped) -> bool {
    const auto &AA = A.getAAFor<AANonNull>(*this, IRPosition::value(V),
                                           DepClassTy::REQUIRED);
    if (!Stripped && this == &AA) {
      if (!isKnownNonZero(&V, DL, 0, AC, CtxI, DT))
        T.indicatePessimisticFixpoint();
    } else {
      // Use abstract attribute information.
      const AANonNull::StateType &NS = AA.getState();
      T ^= NS;
    }
    return T.isValidState();
  };

  StateType T;
  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<StateType>(A, getIRPosition(), *this, T,
                                        VisitValueCB, getCtxI(),
                                        UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return clampStateAndIndicateChange(getState(), T);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull){ static llvm::Statistic NumIRFunctionReturn_nonnull = {"attributor"
, "NumIRFunctionReturn_nonnull", ("Number of " "function returns"
 " marked '" "nonnull" "'")};; ++(NumIRFunctionReturn_nonnull
); } }
2431};

2433/// NonNull attribute for function return value.
2434struct AANonNullReturned final
  : AAReturnedFromReturnedValues<AANonNull, AANonNull> {
AANonNullReturned(const IRPosition &IRP, Attributor &A)
    : AAReturnedFromReturnedValues<AANonNull, AANonNull>(IRP, A) {}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? "nonnull" : "may-null";
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(nonnull){ static llvm::Statistic NumIRFunctionReturn_nonnull = {"attributor"
, "NumIRFunctionReturn_nonnull", ("Number of " "function returns"
 " marked '" "nonnull" "'")};; ++(NumIRFunctionReturn_nonnull
); } }
2446};

2448/// NonNull attribute for function argument.
2449struct AANonNullArgument final
  : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl> {
AANonNullArgument(const IRPosition &IRP, Attributor &A)
    : AAArgumentFromCallSiteArguments<AANonNull, AANonNullImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nonnull){ static llvm::Statistic NumIRArguments_nonnull = {"attributor"
, "NumIRArguments_nonnull", ("Number of " "arguments" " marked '"
 "nonnull" "'")};; ++(NumIRArguments_nonnull); } }
2456};

2458struct AANonNullCallSiteArgument final : AANonNullFloating {
AANonNullCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AANonNullFloating(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(nonnull){ static llvm::Statistic NumIRCSArguments_nonnull = {"attributor"
, "NumIRCSArguments_nonnull", ("Number of " "call site arguments"
 " marked '" "nonnull" "'")};; ++(NumIRCSArguments_nonnull); } }
2464};

2466/// NonNull attribute for a call site return position.
2467struct AANonNullCallSiteReturned final
  : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl> {
AANonNullCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AACallSiteReturnedFromReturned<AANonNull, AANonNullImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(nonnull){ static llvm::Statistic NumIRCSReturn_nonnull = {"attributor"
, "NumIRCSReturn_nonnull", ("Number of " "call site returns" " marked '"
 "nonnull" "'")};; ++(NumIRCSReturn_nonnull); } }
2474};

2476/// ------------------------ No-Recurse Attributes ----------------------------

2478struct AANoRecurseImpl : public AANoRecurse {
AANoRecurseImpl(const IRPosition &IRP, Attributor &A) : AANoRecurse(IRP, A) {}

/// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override {
  return getAssumed() ? "norecurse" : "may-recurse";
}
2485};

2487struct AANoRecurseFunction final : AANoRecurseImpl {
AANoRecurseFunction(const IRPosition &IRP, Attributor &A)
    : AANoRecurseImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {

  // If all live call sites are known to be no-recurse, we are as well.
  auto CallSitePred = [&](AbstractCallSite ACS) {
    const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
        *this, IRPosition::function(*ACS.getInstruction()->getFunction()),
        DepClassTy::NONE);
    return NoRecurseAA.isKnownNoRecurse();
  };
  bool UsedAssumedInformation = false;
  if (A.checkForAllCallSites(CallSitePred, *this, true,
                             UsedAssumedInformation)) {
    // If we know all call sites and all are known no-recurse, we are done.
    // If all known call sites, which might not be all that exist, are known
    // to be no-recurse, we are not done but we can continue to assume
    // no-recurse. If one of the call sites we have not visited will become
    // live, another update is triggered.
    if (!UsedAssumedInformation)
      indicateOptimisticFixpoint();
    return ChangeStatus::UNCHANGED;
  }

  const AAFunctionReachability &EdgeReachability =
      A.getAAFor<AAFunctionReachability>(*this, getIRPosition(),
                                         DepClassTy::REQUIRED);
  if (EdgeReachability.canReach(A, *getAnchorScope()))
    return indicatePessimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}

void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(norecurse){ static llvm::Statistic NumIRFunction_norecurse = {"attributor"
, "NumIRFunction_norecurse", ("Number of " "functions" " marked '"
 "norecurse" "'")};; ++(NumIRFunction_norecurse); } }
2523};

2525/// NoRecurse attribute deduction for a call sites.
2526struct AANoRecurseCallSite final : AANoRecurseImpl {
AANoRecurseCallSite(const IRPosition &IRP, Attributor &A)
    : AANoRecurseImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoRecurseImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AANoRecurse>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(norecurse){ static llvm::Statistic NumIRCS_norecurse = {"attributor", "NumIRCS_norecurse"
, ("Number of " "call site" " marked '" "norecurse" "'")};; ++
(NumIRCS_norecurse); }; }
2552};

2554/// -------------------- Undefined-Behavior Attributes ------------------------

2556struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
AAUndefinedBehaviorImpl(const IRPosition &IRP, Attributor &A)
    : AAUndefinedBehavior(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
// through a pointer (i.e. also branches etc.)
ChangeStatus updateImpl(Attributor &A) override {
  const size_t UBPrevSize = KnownUBInsts.size();
  const size_t NoUBPrevSize = AssumedNoUBInsts.size();

  auto InspectMemAccessInstForUB = [&](Instruction &I) {
    // Lang ref now states volatile store is not UB, let's skip them.
    if (I.isVolatile() && I.mayWriteToMemory())
      return true;

    // Skip instructions that are already saved.
    if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
      return true;

    // If we reach here, we know we have an instruction
    // that accesses memory through a pointer operand,
    // for which getPointerOperand() should give it to us.
    Value *PtrOp =
        const_cast<Value *>(getPointerOperand(&I, /* AllowVolatile */ true));
    assert(PtrOp &&(static_cast <bool> (PtrOp && "Expected pointer operand of memory accessing instruction"
) ? void (0) : __assert_fail ("PtrOp && \"Expected pointer operand of memory accessing instruction\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 2581, __extension__
 __PRETTY_FUNCTION__))
           "Expected pointer operand of memory accessing instruction")(static_cast <bool> (PtrOp && "Expected pointer operand of memory accessing instruction"
) ? void (0) : __assert_fail ("PtrOp && \"Expected pointer operand of memory accessing instruction\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 2581, __extension__
 __PRETTY_FUNCTION__));

    // Either we stopped and the appropriate action was taken,
    // or we got back a simplified value to continue.
    Optional<Value *> SimplifiedPtrOp = stopOnUndefOrAssumed(A, PtrOp, &I);
    if (!SimplifiedPtrOp.hasValue() || !SimplifiedPtrOp.getValue())
      return true;
    const Value *PtrOpVal = SimplifiedPtrOp.getValue();

    // A memory access through a pointer is considered UB
    // only if the pointer has constant null value.
    // TODO: Expand it to not only check constant values.
    if (!isa<ConstantPointerNull>(PtrOpVal)) {
      AssumedNoUBInsts.insert(&I);
      return true;
    }
    const Type *PtrTy = PtrOpVal->getType();

    // Because we only consider instructions inside functions,
    // assume that a parent function exists.
    const Function *F = I.getFunction();

    // A memory access using constant null pointer is only considered UB
    // if null pointer is _not_ defined for the target platform.
    if (llvm::NullPointerIsDefined(F, PtrTy->getPointerAddressSpace()))
      AssumedNoUBInsts.insert(&I);
    else
      KnownUBInsts.insert(&I);
    return true;
  };

  auto InspectBrInstForUB = [&](Instruction &I) {
    // A conditional branch instruction is considered UB if it has `undef`
    // condition.

    // Skip instructions that are already saved.
    if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
      return true;

    // We know we have a branch instruction.
    auto *BrInst = cast<BranchInst>(&I);

    // Unconditional branches are never considered UB.
    if (BrInst->isUnconditional())
      return true;

    // Either we stopped and the appropriate action was taken,
    // or we got back a simplified value to continue.
    Optional<Value *> SimplifiedCond =
        stopOnUndefOrAssumed(A, BrInst->getCondition(), BrInst);
    if (!SimplifiedCond.hasValue() || !SimplifiedCond.getValue())
      return true;
    AssumedNoUBInsts.insert(&I);
    return true;
  };

  auto InspectCallSiteForUB = [&](Instruction &I) {
    // Check whether a callsite always cause UB or not

    // Skip instructions that are already saved.
    if (AssumedNoUBInsts.count(&I) || KnownUBInsts.count(&I))
      return true;

    // Check nonnull and noundef argument attribute violation for each
    // callsite.
    CallBase &CB = cast<CallBase>(I);
    Function *Callee = CB.getCalledFunction();
    if (!Callee)
      return true;
    for (unsigned idx = 0; idx < CB.arg_size(); idx++) {
      // If current argument is known to be simplified to null pointer and the
      // corresponding argument position is known to have nonnull attribute,
      // the argument is poison. Furthermore, if the argument is poison and
      // the position is known to have noundef attriubte, this callsite is
      // considered UB.
      if (idx >= Callee->arg_size())
        break;
      Value *ArgVal = CB.getArgOperand(idx);
      if (!ArgVal)
        continue;
      // Here, we handle three cases.
      //   (1) Not having a value means it is dead. (we can replace the value
      //       with undef)
      //   (2) Simplified to undef. The argument violate noundef attriubte.
      //   (3) Simplified to null pointer where known to be nonnull.
      //       The argument is a poison value and violate noundef attribute.
      IRPosition CalleeArgumentIRP = IRPosition::callsite_argument(CB, idx);
      auto &NoUndefAA =
          A.getAAFor<AANoUndef>(*this, CalleeArgumentIRP, DepClassTy::NONE);
      if (!NoUndefAA.isKnownNoUndef())
        continue;
      bool UsedAssumedInformation = false;
      Optional<Value *> SimplifiedVal = A.getAssumedSimplified(
          IRPosition::value(*ArgVal), *this, UsedAssumedInformation);
      if (UsedAssumedInformation)
        continue;
      if (SimplifiedVal.hasValue() && !SimplifiedVal.getValue())
        return true;
      if (!SimplifiedVal.hasValue() ||
          isa<UndefValue>(*SimplifiedVal.getValue())) {
        KnownUBInsts.insert(&I);
        continue;
      }
      if (!ArgVal->getType()->isPointerTy() ||
          !isa<ConstantPointerNull>(*SimplifiedVal.getValue()))
        continue;
      auto &NonNullAA =
          A.getAAFor<AANonNull>(*this, CalleeArgumentIRP, DepClassTy::NONE);
      if (NonNullAA.isKnownNonNull())
        KnownUBInsts.insert(&I);
    }
    return true;
  };

  auto InspectReturnInstForUB = [&](Instruction &I) {
    auto &RI = cast<ReturnInst>(I);
    // Either we stopped and the appropriate action was taken,
    // or we got back a simplified return value to continue.
    Optional<Value *> SimplifiedRetValue =
        stopOnUndefOrAssumed(A, RI.getReturnValue(), &I);
    if (!SimplifiedRetValue.hasValue() || !SimplifiedRetValue.getValue())
      return true;

    // Check if a return instruction always cause UB or not
    // Note: It is guaranteed that the returned position of the anchor
    //       scope has noundef attribute when this is called.
    //       We also ensure the return position is not "assumed dead"
    //       because the returned value was then potentially simplified to
    //       `undef` in AAReturnedValues without removing the `noundef`
    //       attribute yet.

    // When the returned position has noundef attriubte, UB occurs in the
    // following cases.
    //   (1) Returned value is known to be undef.
    //   (2) The value is known to be a null pointer and the returned
    //       position has nonnull attribute (because the returned value is
    //       poison).
    if (isa<ConstantPointerNull>(*SimplifiedRetValue)) {
      auto &NonNullAA = A.getAAFor<AANonNull>(
          *this, IRPosition::returned(*getAnchorScope()), DepClassTy::NONE);
      if (NonNullAA.isKnownNonNull())
        KnownUBInsts.insert(&I);
    }

    return true;
  };

  bool UsedAssumedInformation = false;
  A.checkForAllInstructions(InspectMemAccessInstForUB, *this,
                            {Instruction::Load, Instruction::Store,
                             Instruction::AtomicCmpXchg,
                             Instruction::AtomicRMW},
                            UsedAssumedInformation,
                            /* CheckBBLivenessOnly */ true);
  A.checkForAllInstructions(InspectBrInstForUB, *this, {Instruction::Br},
                            UsedAssumedInformation,
                            /* CheckBBLivenessOnly */ true);
  A.checkForAllCallLikeInstructions(InspectCallSiteForUB, *this,
                                    UsedAssumedInformation);

  // If the returned position of the anchor scope has noundef attriubte, check
  // all returned instructions.
  if (!getAnchorScope()->getReturnType()->isVoidTy()) {
    const IRPosition &ReturnIRP = IRPosition::returned(*getAnchorScope());
    if (!A.isAssumedDead(ReturnIRP, this, nullptr, UsedAssumedInformation)) {
      auto &RetPosNoUndefAA =
          A.getAAFor<AANoUndef>(*this, ReturnIRP, DepClassTy::NONE);
      if (RetPosNoUndefAA.isKnownNoUndef())
        A.checkForAllInstructions(InspectReturnInstForUB, *this,
                                  {Instruction::Ret}, UsedAssumedInformation,
                                  /* CheckBBLivenessOnly */ true);
    }
  }

  if (NoUBPrevSize != AssumedNoUBInsts.size() ||
      UBPrevSize != KnownUBInsts.size())
    return ChangeStatus::CHANGED;
  return ChangeStatus::UNCHANGED;
}

bool isKnownToCauseUB(Instruction *I) const override {
  return KnownUBInsts.count(I);
}

bool isAssumedToCauseUB(Instruction *I) const override {
  // In simple words, if an instruction is not in the assumed to _not_
  // cause UB, then it is assumed UB (that includes those
  // in the KnownUBInsts set). The rest is boilerplate
  // is to ensure that it is one of the instructions we test
  // for UB.

  switch (I->getOpcode()) {
  case Instruction::Load:
  case Instruction::Store:
  case Instruction::AtomicCmpXchg:
  case Instruction::AtomicRMW:
    return !AssumedNoUBInsts.count(I);
  case Instruction::Br: {
    auto BrInst = cast<BranchInst>(I);
    if (BrInst->isUnconditional())
      return false;
    return !AssumedNoUBInsts.count(I);
  } break;
  default:
    return false;
  }
  return false;
}

ChangeStatus manifest(Attributor &A) override {
  if (KnownUBInsts.empty())
    return ChangeStatus::UNCHANGED;
  for (Instruction *I : KnownUBInsts)
    A.changeToUnreachableAfterManifest(I);
  return ChangeStatus::CHANGED;
}

/// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override {
  return getAssumed() ? "undefined-behavior" : "no-ub";
}

/// Note: The correctness of this analysis depends on the fact that the
/// following 2 sets will stop changing after some point.
/// "Change" here means that their size changes.
/// The size of each set is monotonically increasing
/// (we only add items to them) and it is upper bounded by the number of
/// instructions in the processed function (we can never save more
/// elements in either set than this number). Hence, at some point,
/// they will stop increasing.
/// Consequently, at some point, both sets will have stopped
/// changing, effectively making the analysis reach a fixpoint.

/// Note: These 2 sets are disjoint and an instruction can be considered
/// one of 3 things:
/// 1) Known to cause UB (AAUndefinedBehavior could prove it) and put it in
///    the KnownUBInsts set.
/// 2) Assumed to cause UB (in every updateImpl, AAUndefinedBehavior
///    has a reason to assume it).
/// 3) Assumed to not cause UB. very other instruction - AAUndefinedBehavior
///    could not find a reason to assume or prove that it can cause UB,
///    hence it assumes it doesn't. We have a set for these instructions
///    so that we don't reprocess them in every update.
///    Note however that instructions in this set may cause UB.

2826protected:
/// A set of all live instructions _known_ to cause UB.
SmallPtrSet<Instruction *, 8> KnownUBInsts;

2830private:
/// A set of all the (live) instructions that are assumed to _not_ cause UB.
SmallPtrSet<Instruction *, 8> AssumedNoUBInsts;

// Should be called on updates in which if we're processing an instruction
// \p I that depends on a value \p V, one of the following has to happen:
// - If the value is assumed, then stop.
// - If the value is known but undef, then consider it UB.
// - Otherwise, do specific processing with the simplified value.
// We return None in the first 2 cases to signify that an appropriate
// action was taken and the caller should stop.
// Otherwise, we return the simplified value that the caller should
// use for specific processing.
Optional<Value *> stopOnUndefOrAssumed(Attributor &A, Value *V,
                                       Instruction *I) {
  bool UsedAssumedInformation = false;
  Optional<Value *> SimplifiedV = A.getAssumedSimplified(
      IRPosition::value(*V), *this, UsedAssumedInformation);
  if (!UsedAssumedInformation) {
    // Don't depend on assumed values.
    if (!SimplifiedV.hasValue()) {
      // If it is known (which we tested above) but it doesn't have a value,
      // then we can assume `undef` and hence the instruction is UB.
      KnownUBInsts.insert(I);
      return llvm::None;
    }
    if (!SimplifiedV.getValue())
      return nullptr;
    V = *SimplifiedV;
  }
  if (isa<UndefValue>(V)) {
    KnownUBInsts.insert(I);
    return llvm::None;
  }
  return V;
}
2866};

2868struct AAUndefinedBehaviorFunction final : AAUndefinedBehaviorImpl {
AAUndefinedBehaviorFunction(const IRPosition &IRP, Attributor &A)
    : AAUndefinedBehaviorImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECL(UndefinedBehaviorInstruction, Instruction,static llvm::Statistic NumIRInstruction_UndefinedBehaviorInstruction
 = {"attributor", "NumIRInstruction_UndefinedBehaviorInstruction"
, "Number of instructions known to have UB"};;
             "Number of instructions known to have UB")static llvm::Statistic NumIRInstruction_UndefinedBehaviorInstruction
 = {"attributor", "NumIRInstruction_UndefinedBehaviorInstruction"
, "Number of instructions known to have UB"};;;
  BUILD_STAT_NAME(UndefinedBehaviorInstruction, Instruction)NumIRInstruction_UndefinedBehaviorInstruction +=
      KnownUBInsts.size();
}
2879};

2881/// ------------------------ Will-Return Attributes ----------------------------

2883// Helper function that checks whether a function has any cycle which we don't
2884// know if it is bounded or not.
2885// Loops with maximum trip count are considered bounded, any other cycle not.
2886static bool mayContainUnboundedCycle(Function &F, Attributor &A) {
ScalarEvolution *SE =
    A.getInfoCache().getAnalysisResultForFunction<ScalarEvolutionAnalysis>(F);
LoopInfo *LI = A.getInfoCache().getAnalysisResultForFunction<LoopAnalysis>(F);
// If either SCEV or LoopInfo is not available for the function then we assume
// any cycle to be unbounded cycle.
// We use scc_iterator which uses Tarjan algorithm to find all the maximal
// SCCs.To detect if there's a cycle, we only need to find the maximal ones.
if (!SE || !LI) {
  for (scc_iterator<Function *> SCCI = scc_begin(&F); !SCCI.isAtEnd(); ++SCCI)
    if (SCCI.hasCycle())
      return true;
  return false;
}

// If there's irreducible control, the function may contain non-loop cycles.
if (mayContainIrreducibleControl(F, LI))
  return true;

// Any loop that does not have a max trip count is considered unbounded cycle.
for (auto *L : LI->getLoopsInPreorder()) {
  if (!SE->getSmallConstantMaxTripCount(L))
    return true;
}
return false;
2911}

2913struct AAWillReturnImpl : public AAWillReturn {
AAWillReturnImpl(const IRPosition &IRP, Attributor &A)
    : AAWillReturn(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAWillReturn::initialize(A);

  if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ true)) {
    indicateOptimisticFixpoint();
    return;
  }
}

/// Check for `mustprogress` and `readonly` as they imply `willreturn`.
bool isImpliedByMustprogressAndReadonly(Attributor &A, bool KnownOnly) {
  // Check for `mustprogress` in the scope and the associated function which
  // might be different if this is a call site.
  if ((!getAnchorScope() || !getAnchorScope()->mustProgress()) &&
      (!getAssociatedFunction() || !getAssociatedFunction()->mustProgress()))
    return false;

  bool IsKnown;
  if (AA::isAssumedReadOnly(A, getIRPosition(), *this, IsKnown))
    return IsKnown || !KnownOnly;
  return false;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
    return ChangeStatus::UNCHANGED;

  auto CheckForWillReturn = [&](Instruction &I) {
    IRPosition IPos = IRPosition::callsite_function(cast<CallBase>(I));
    const auto &WillReturnAA =
        A.getAAFor<AAWillReturn>(*this, IPos, DepClassTy::REQUIRED);
    if (WillReturnAA.isKnownWillReturn())
      return true;
    if (!WillReturnAA.isAssumedWillReturn())
      return false;
    const auto &NoRecurseAA =
        A.getAAFor<AANoRecurse>(*this, IPos, DepClassTy::REQUIRED);
    return NoRecurseAA.isAssumedNoRecurse();
  };

  bool UsedAssumedInformation = false;
  if (!A.checkForAllCallLikeInstructions(CheckForWillReturn, *this,
                                         UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override {
  return getAssumed() ? "willreturn" : "may-noreturn";
}
2971};

2973struct AAWillReturnFunction final : AAWillReturnImpl {
AAWillReturnFunction(const IRPosition &IRP, Attributor &A)
    : AAWillReturnImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAWillReturnImpl::initialize(A);

  Function *F = getAnchorScope();
  if (!F || F->isDeclaration() || mayContainUnboundedCycle(*F, A))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(willreturn){ static llvm::Statistic NumIRFunction_willreturn = {"attributor"
, "NumIRFunction_willreturn", ("Number of " "functions" " marked '"
 "willreturn" "'")};; ++(NumIRFunction_willreturn); } }
2988};

2990/// WillReturn attribute deduction for a call sites.
2991struct AAWillReturnCallSite final : AAWillReturnImpl {
AAWillReturnCallSite(const IRPosition &IRP, Attributor &A)
    : AAWillReturnImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAWillReturnImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || !A.isFunctionIPOAmendable(*F))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  if (isImpliedByMustprogressAndReadonly(A, /* KnownOnly */ false))
    return ChangeStatus::UNCHANGED;

  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AAWillReturn>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(willreturn){ static llvm::Statistic NumIRCS_willreturn = {"attributor", "NumIRCS_willreturn"
, ("Number of " "call site" " marked '" "willreturn" "'")};; ++
(NumIRCS_willreturn); }; }
3020};

3022/// -------------------AAReachability Attribute--------------------------

3024struct AAReachabilityImpl : AAReachability {
AAReachabilityImpl(const IRPosition &IRP, Attributor &A)
    : AAReachability(IRP, A) {}

const std::string getAsStr() const override {
  // TODO: Return the number of reachable queries.
  return "reachable";
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(
      *this, IRPosition::function(*getAnchorScope()), DepClassTy::REQUIRED);
  if (!NoRecurseAA.isAssumedNoRecurse())
    return indicatePessimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}
3041};

3043struct AAReachabilityFunction final : public AAReachabilityImpl {
AAReachabilityFunction(const IRPosition &IRP, Attributor &A)
    : AAReachabilityImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(reachable){ static llvm::Statistic NumIRFunction_reachable = {"attributor"
, "NumIRFunction_reachable", ("Number of " "functions" " marked '"
 "reachable" "'")};; ++(NumIRFunction_reachable); }; }
3049};

3051/// ------------------------ NoAlias Argument Attribute ------------------------

3053struct AANoAliasImpl : AANoAlias {
AANoAliasImpl(const IRPosition &IRP, Attributor &A) : AANoAlias(IRP, A) {
  assert(getAssociatedType()->isPointerTy() &&(static_cast <bool> (getAssociatedType()->isPointerTy
() && "Noalias is a pointer attribute") ? void (0) : __assert_fail
 ("getAssociatedType()->isPointerTy() && \"Noalias is a pointer attribute\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3056, __extension__
 __PRETTY_FUNCTION__))
         "Noalias is a pointer attribute")(static_cast <bool> (getAssociatedType()->isPointerTy
() && "Noalias is a pointer attribute") ? void (0) : __assert_fail
 ("getAssociatedType()->isPointerTy() && \"Noalias is a pointer attribute\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3056, __extension__
 __PRETTY_FUNCTION__));
}

const std::string getAsStr() const override {
  return getAssumed() ? "noalias" : "may-alias";
}
3062};

3064/// NoAlias attribute for a floating value.
3065struct AANoAliasFloating final : AANoAliasImpl {
AANoAliasFloating(const IRPosition &IRP, Attributor &A)
    : AANoAliasImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoAliasImpl::initialize(A);
  Value *Val = &getAssociatedValue();
  do {
    CastInst *CI = dyn_cast<CastInst>(Val);
    if (!CI)
      break;
    Value *Base = CI->getOperand(0);
    if (!Base->hasOneUse())
      break;
    Val = Base;
  } while (true);

  if (!Val->getType()->isPointerTy()) {
    indicatePessimisticFixpoint();
    return;
  }

  if (isa<AllocaInst>(Val))
    indicateOptimisticFixpoint();
  else if (isa<ConstantPointerNull>(Val) &&
           !NullPointerIsDefined(getAnchorScope(),
                                 Val->getType()->getPointerAddressSpace()))
    indicateOptimisticFixpoint();
  else if (Val != &getAssociatedValue()) {
    const auto &ValNoAliasAA = A.getAAFor<AANoAlias>(
        *this, IRPosition::value(*Val), DepClassTy::OPTIONAL);
    if (ValNoAliasAA.isKnownNoAlias())
      indicateOptimisticFixpoint();
  }
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Implement this.
  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(noalias){ static llvm::Statistic NumIRFloating_noalias = {"attributor"
, "NumIRFloating_noalias", ("Number of floating values known to be '"
 "noalias" "'")};; ++(NumIRFloating_noalias); }
}
3112};

3114/// NoAlias attribute for an argument.
3115struct AANoAliasArgument final
  : AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl> {
using Base = AAArgumentFromCallSiteArguments<AANoAlias, AANoAliasImpl>;
AANoAliasArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  Base::initialize(A);
  // See callsite argument attribute and callee argument attribute.
  if (hasAttr({Attribute::ByVal}))
    indicateOptimisticFixpoint();
}

/// See AbstractAttribute::update(...).
ChangeStatus updateImpl(Attributor &A) override {
  // We have to make sure no-alias on the argument does not break
  // synchronization when this is a callback argument, see also [1] below.
  // If synchronization cannot be affected, we delegate to the base updateImpl
  // function, otherwise we give up for now.

  // If the function is no-sync, no-alias cannot break synchronization.
  const auto &NoSyncAA =
      A.getAAFor<AANoSync>(*this, IRPosition::function_scope(getIRPosition()),
                           DepClassTy::OPTIONAL);
  if (NoSyncAA.isAssumedNoSync())
    return Base::updateImpl(A);

  // If the argument is read-only, no-alias cannot break synchronization.
  bool IsKnown;
  if (AA::isAssumedReadOnly(A, getIRPosition(), *this, IsKnown))
    return Base::updateImpl(A);

  // If the argument is never passed through callbacks, no-alias cannot break
  // synchronization.
  bool UsedAssumedInformation = false;
  if (A.checkForAllCallSites(
          [](AbstractCallSite ACS) { return !ACS.isCallbackCall(); }, *this,
          true, UsedAssumedInformation))
    return Base::updateImpl(A);

  // TODO: add no-alias but make sure it doesn't break synchronization by
  // introducing fake uses. See:
  // [1] Compiler Optimizations for OpenMP, J. Doerfert and H. Finkel,
  //     International Workshop on OpenMP 2018,
  //     http://compilers.cs.uni-saarland.de/people/doerfert/par_opt18.pdf

  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noalias){ static llvm::Statistic NumIRArguments_noalias = {"attributor"
, "NumIRArguments_noalias", ("Number of " "arguments" " marked '"
 "noalias" "'")};; ++(NumIRArguments_noalias); } }
3166};

3168struct AANoAliasCallSiteArgument final : AANoAliasImpl {
AANoAliasCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AANoAliasImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // See callsite argument attribute and callee argument attribute.
  const auto &CB = cast<CallBase>(getAnchorValue());
  if (CB.paramHasAttr(getCallSiteArgNo(), Attribute::NoAlias))
    indicateOptimisticFixpoint();
  Value &Val = getAssociatedValue();
  if (isa<ConstantPointerNull>(Val) &&
      !NullPointerIsDefined(getAnchorScope(),
                            Val.getType()->getPointerAddressSpace()))
    indicateOptimisticFixpoint();
}

/// Determine if the underlying value may alias with the call site argument
/// \p OtherArgNo of \p ICS (= the underlying call site).
bool mayAliasWithArgument(Attributor &A, AAResults *&AAR,
                          const AAMemoryBehavior &MemBehaviorAA,
                          const CallBase &CB, unsigned OtherArgNo) {
  // We do not need to worry about aliasing with the underlying IRP.
  if (this->getCalleeArgNo() == (int)OtherArgNo)
    return false;

  // If it is not a pointer or pointer vector we do not alias.
  const Value *ArgOp = CB.getArgOperand(OtherArgNo);
  if (!ArgOp->getType()->isPtrOrPtrVectorTy())
    return false;

  auto &CBArgMemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
      *this, IRPosition::callsite_argument(CB, OtherArgNo), DepClassTy::NONE);

  // If the argument is readnone, there is no read-write aliasing.
  if (CBArgMemBehaviorAA.isAssumedReadNone()) {
    A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
    return false;
  }

  // If the argument is readonly and the underlying value is readonly, there
  // is no read-write aliasing.
  bool IsReadOnly = MemBehaviorAA.isAssumedReadOnly();
  if (CBArgMemBehaviorAA.isAssumedReadOnly() && IsReadOnly) {
    A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
    A.recordDependence(CBArgMemBehaviorAA, *this, DepClassTy::OPTIONAL);
    return false;
  }

  // We have to utilize actual alias analysis queries so we need the object.
  if (!AAR)
    AAR = A.getInfoCache().getAAResultsForFunction(*getAnchorScope());

  // Try to rule it out at the call site.
  bool IsAliasing = !AAR || !AAR->isNoAlias(&getAssociatedValue(), ArgOp);
  LLVM_DEBUG(dbgs() << "[NoAliasCSArg] Check alias between "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[NoAliasCSArg] Check alias between "
 "callsite arguments: " << getAssociatedValue() <<
 " " << *ArgOp << " => " << (IsAliasing ?
 "" : "no-") << "alias \n"; } } while (false)
                       "callsite arguments: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[NoAliasCSArg] Check alias between "
 "callsite arguments: " << getAssociatedValue() <<
 " " << *ArgOp << " => " << (IsAliasing ?
 "" : "no-") << "alias \n"; } } while (false)
                    << getAssociatedValue() << " " << *ArgOp << " => "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[NoAliasCSArg] Check alias between "
 "callsite arguments: " << getAssociatedValue() <<
 " " << *ArgOp << " => " << (IsAliasing ?
 "" : "no-") << "alias \n"; } } while (false)
                    << (IsAliasing ? "" : "no-") << "alias \n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[NoAliasCSArg] Check alias between "
 "callsite arguments: " << getAssociatedValue() <<
 " " << *ArgOp << " => " << (IsAliasing ?
 "" : "no-") << "alias \n"; } } while (false);

  return IsAliasing;
}

bool
isKnownNoAliasDueToNoAliasPreservation(Attributor &A, AAResults *&AAR,
                                       const AAMemoryBehavior &MemBehaviorAA,
                                       const AANoAlias &NoAliasAA) {
  // We can deduce "noalias" if the following conditions hold.
  // (i)   Associated value is assumed to be noalias in the definition.
  // (ii)  Associated value is assumed to be no-capture in all the uses
  //       possibly executed before this callsite.
  // (iii) There is no other pointer argument which could alias with the
  //       value.

  bool AssociatedValueIsNoAliasAtDef = NoAliasAA.isAssumedNoAlias();
  if (!AssociatedValueIsNoAliasAtDef) {
    LLVM_DEBUG(dbgs() << "[AANoAlias] " << getAssociatedValue()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAlias] " << getAssociatedValue
() << " is not no-alias at the definition\n"; } } while
 (false)
                      << " is not no-alias at the definition\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAlias] " << getAssociatedValue
() << " is not no-alias at the definition\n"; } } while
 (false);
    return false;
  }

  A.recordDependence(NoAliasAA, *this, DepClassTy::OPTIONAL);

  const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
  const Function *ScopeFn = VIRP.getAnchorScope();
  auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, VIRP, DepClassTy::NONE);
  // Check whether the value is captured in the scope using AANoCapture.
  //      Look at CFG and check only uses possibly executed before this
  //      callsite.
  auto UsePred = [&](const Use &U, bool &Follow) -> bool {
    Instruction *UserI = cast<Instruction>(U.getUser());

    // If UserI is the curr instruction and there is a single potential use of
    // the value in UserI we allow the use.
    // TODO: We should inspect the operands and allow those that cannot alias
    //       with the value.
    if (UserI == getCtxI() && UserI->getNumOperands() == 1)
      return true;

    if (ScopeFn) {
      const auto &ReachabilityAA = A.getAAFor<AAReachability>(
          *this, IRPosition::function(*ScopeFn), DepClassTy::OPTIONAL);

      if (!ReachabilityAA.isAssumedReachable(A, *UserI, *getCtxI()))
        return true;

      if (auto *CB = dyn_cast<CallBase>(UserI)) {
        if (CB->isArgOperand(&U)) {

          unsigned ArgNo = CB->getArgOperandNo(&U);

          const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
              *this, IRPosition::callsite_argument(*CB, ArgNo),
              DepClassTy::OPTIONAL);

          if (NoCaptureAA.isAssumedNoCapture())
            return true;
        }
      }
    }

    // For cases which can potentially have more users
    if (isa<GetElementPtrInst>(U) || isa<BitCastInst>(U) || isa<PHINode>(U) ||
        isa<SelectInst>(U)) {
      Follow = true;
      return true;
    }

    LLVM_DEBUG(dbgs() << "[AANoAliasCSArg] Unknown user: " << *U << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAliasCSArg] Unknown user: "
 << *U << "\n"; } } while (false);
    return false;
  };

  if (!NoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
    if (!A.checkForAllUses(UsePred, *this, getAssociatedValue())) {
      LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAliasCSArg] " <<
 getAssociatedValue() << " cannot be noalias as it is potentially captured\n"
; } } while (false)
          dbgs() << "[AANoAliasCSArg] " << getAssociatedValue()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAliasCSArg] " <<
 getAssociatedValue() << " cannot be noalias as it is potentially captured\n"
; } } while (false)
                 << " cannot be noalias as it is potentially captured\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAliasCSArg] " <<
 getAssociatedValue() << " cannot be noalias as it is potentially captured\n"
; } } while (false);
      return false;
    }
  }
  A.recordDependence(NoCaptureAA, *this, DepClassTy::OPTIONAL);

  // Check there is no other pointer argument which could alias with the
  // value passed at this call site.
  // TODO: AbstractCallSite
  const auto &CB = cast<CallBase>(getAnchorValue());
  for (unsigned OtherArgNo = 0; OtherArgNo < CB.arg_size(); OtherArgNo++)
    if (mayAliasWithArgument(A, AAR, MemBehaviorAA, CB, OtherArgNo))
      return false;

  return true;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // If the argument is readnone we are done as there are no accesses via the
  // argument.
  auto &MemBehaviorAA =
      A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(), DepClassTy::NONE);
  if (MemBehaviorAA.isAssumedReadNone()) {
    A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
    return ChangeStatus::UNCHANGED;
  }

  const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
  const auto &NoAliasAA =
      A.getAAFor<AANoAlias>(*this, VIRP, DepClassTy::NONE);

  AAResults *AAR = nullptr;
  if (isKnownNoAliasDueToNoAliasPreservation(A, AAR, MemBehaviorAA,
                                             NoAliasAA)) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAlias] No-Alias deduced via no-alias preservation\n"
; } } while (false)
        dbgs() << "[AANoAlias] No-Alias deduced via no-alias preservation\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AANoAlias] No-Alias deduced via no-alias preservation\n"
; } } while (false);
    return ChangeStatus::UNCHANGED;
  }

  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(noalias){ static llvm::Statistic NumIRCSArguments_noalias = {"attributor"
, "NumIRCSArguments_noalias", ("Number of " "call site arguments"
 " marked '" "noalias" "'")};; ++(NumIRCSArguments_noalias); } }
3349};

3351/// NoAlias attribute for function return value.
3352struct AANoAliasReturned final : AANoAliasImpl {
AANoAliasReturned(const IRPosition &IRP, Attributor &A)
    : AANoAliasImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoAliasImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
virtual ChangeStatus updateImpl(Attributor &A) override {

  auto CheckReturnValue = [&](Value &RV) -> bool {
    if (Constant *C = dyn_cast<Constant>(&RV))
      if (C->isNullValue() || isa<UndefValue>(C))
        return true;

    /// For now, we can only deduce noalias if we have call sites.
    /// FIXME: add more support.
    if (!isa<CallBase>(&RV))
      return false;

    const IRPosition &RVPos = IRPosition::value(RV);
    const auto &NoAliasAA =
        A.getAAFor<AANoAlias>(*this, RVPos, DepClassTy::REQUIRED);
    if (!NoAliasAA.isAssumedNoAlias())
      return false;

    const auto &NoCaptureAA =
        A.getAAFor<AANoCapture>(*this, RVPos, DepClassTy::REQUIRED);
    return NoCaptureAA.isAssumedNoCaptureMaybeReturned();
  };

  if (!A.checkForAllReturnedValues(CheckReturnValue, *this))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noalias){ static llvm::Statistic NumIRFunctionReturn_noalias = {"attributor"
, "NumIRFunctionReturn_noalias", ("Number of " "function returns"
 " marked '" "noalias" "'")};; ++(NumIRFunctionReturn_noalias
); } }
3396};

3398/// NoAlias attribute deduction for a call site return value.
3399struct AANoAliasCallSiteReturned final : AANoAliasImpl {
AANoAliasCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AANoAliasImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoAliasImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::returned(*F);
  auto &FnAA = A.getAAFor<AANoAlias>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(noalias){ static llvm::Statistic NumIRCSReturn_noalias = {"attributor"
, "NumIRCSReturn_noalias", ("Number of " "call site returns" " marked '"
 "noalias" "'")};; ++(NumIRCSReturn_noalias); }; }
3425};

3427/// -------------------AAIsDead Function Attribute-----------------------

3429struct AAIsDeadValueImpl : public AAIsDead {
AAIsDeadValueImpl(const IRPosition &IRP, Attributor &A) : AAIsDead(IRP, A) {}

/// See AAIsDead::isAssumedDead().
bool isAssumedDead() const override { return isAssumed(IS_DEAD); }

/// See AAIsDead::isKnownDead().
bool isKnownDead() const override { return isKnown(IS_DEAD); }

/// See AAIsDead::isAssumedDead(BasicBlock *).
bool isAssumedDead(const BasicBlock *BB) const override { return false; }

/// See AAIsDead::isKnownDead(BasicBlock *).
bool isKnownDead(const BasicBlock *BB) const override { return false; }

/// See AAIsDead::isAssumedDead(Instruction *I).
bool isAssumedDead(const Instruction *I) const override {
  return I == getCtxI() && isAssumedDead();
}

/// See AAIsDead::isKnownDead(Instruction *I).
bool isKnownDead(const Instruction *I) const override {
  return isAssumedDead(I) && isKnownDead();
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return isAssumedDead() ? "assumed-dead" : "assumed-live";
}

/// Check if all uses are assumed dead.
bool areAllUsesAssumedDead(Attributor &A, Value &V) {
  // Callers might not check the type, void has no uses.
  if (V.getType()->isVoidTy())
    return true;

  // If we replace a value with a constant there are no uses left afterwards.
  if (!isa<Constant>(V)) {
    bool UsedAssumedInformation = false;
    Optional<Constant *> C =
        A.getAssumedConstant(V, *this, UsedAssumedInformation);
    if (!C.hasValue() || *C)
      return true;
  }

  auto UsePred = [&](const Use &U, bool &Follow) { return false; };
  // Explicitly set the dependence class to required because we want a long
  // chain of N dependent instructions to be considered live as soon as one is
  // without going through N update cycles. This is not required for
  // correctness.
  return A.checkForAllUses(UsePred, *this, V, /* CheckBBLivenessOnly */ false,
                           DepClassTy::REQUIRED);
}

/// Determine if \p I is assumed to be side-effect free.
bool isAssumedSideEffectFree(Attributor &A, Instruction *I) {
  if (!I || wouldInstructionBeTriviallyDead(I))
    return true;

  auto *CB = dyn_cast<CallBase>(I);
  if (!CB || isa<IntrinsicInst>(CB))
    return false;

  const IRPosition &CallIRP = IRPosition::callsite_function(*CB);
  const auto &NoUnwindAA =
      A.getAndUpdateAAFor<AANoUnwind>(*this, CallIRP, DepClassTy::NONE);
  if (!NoUnwindAA.isAssumedNoUnwind())
    return false;
  if (!NoUnwindAA.isKnownNoUnwind())
    A.recordDependence(NoUnwindAA, *this, DepClassTy::OPTIONAL);

  bool IsKnown;
  return AA::isAssumedReadOnly(A, CallIRP, *this, IsKnown);
}
3503};

3505struct AAIsDeadFloating : public AAIsDeadValueImpl {
AAIsDeadFloating(const IRPosition &IRP, Attributor &A)
    : AAIsDeadValueImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (isa<UndefValue>(getAssociatedValue())) {
    indicatePessimisticFixpoint();
    return;
  }

  Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
  if (!isAssumedSideEffectFree(A, I)) {
    if (!isa_and_nonnull<StoreInst>(I))
      indicatePessimisticFixpoint();
    else
      removeAssumedBits(HAS_NO_EFFECT);
  }
}

bool isDeadStore(Attributor &A, StoreInst &SI) {
  // Lang ref now states volatile store is not UB/dead, let's skip them.
  if (SI.isVolatile())
    return false;

  bool UsedAssumedInformation = false;
  SmallSetVector<Value *, 4> PotentialCopies;
  if (!AA::getPotentialCopiesOfStoredValue(A, SI, PotentialCopies, *this,
                                           UsedAssumedInformation))
    return false;
  return llvm::all_of(PotentialCopies, [&](Value *V) {
    return A.isAssumedDead(IRPosition::value(*V), this, nullptr,
                           UsedAssumedInformation);
  });
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
  if (auto *SI = dyn_cast_or_null<StoreInst>(I)) {
    if (!isDeadStore(A, *SI))
      return indicatePessimisticFixpoint();
  } else {
    if (!isAssumedSideEffectFree(A, I))
      return indicatePessimisticFixpoint();
    if (!areAllUsesAssumedDead(A, getAssociatedValue()))
      return indicatePessimisticFixpoint();
  }
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  Value &V = getAssociatedValue();
  if (auto *I = dyn_cast<Instruction>(&V)) {
    // If we get here we basically know the users are all dead. We check if
    // isAssumedSideEffectFree returns true here again because it might not be
    // the case and only the users are dead but the instruction (=call) is
    // still needed.
    if (isa<StoreInst>(I) ||
        (isAssumedSideEffectFree(A, I) && !isa<InvokeInst>(I))) {
      A.deleteAfterManifest(*I);
      return ChangeStatus::CHANGED;
    }
  }
  if (V.use_empty())
    return ChangeStatus::UNCHANGED;

  bool UsedAssumedInformation = false;
  Optional<Constant *> C =
      A.getAssumedConstant(V, *this, UsedAssumedInformation);
  if (C.hasValue() && C.getValue())
    return ChangeStatus::UNCHANGED;

  // Replace the value with undef as it is dead but keep droppable uses around
  // as they provide information we don't want to give up on just yet.
  UndefValue &UV = *UndefValue::get(V.getType());
  bool AnyChange =
      A.changeValueAfterManifest(V, UV, /* ChangeDropppable */ false);
  return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(IsDead){ static llvm::Statistic NumIRFloating_IsDead = {"attributor"
, "NumIRFloating_IsDead", ("Number of floating values known to be '"
 "IsDead" "'")};; ++(NumIRFloating_IsDead); }
}
3591};

3593struct AAIsDeadArgument : public AAIsDeadFloating {
AAIsDeadArgument(const IRPosition &IRP, Attributor &A)
    : AAIsDeadFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (!A.isFunctionIPOAmendable(*getAnchorScope()))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = AAIsDeadFloating::manifest(A);
  Argument &Arg = *getAssociatedArgument();
  if (A.isValidFunctionSignatureRewrite(Arg, /* ReplacementTypes */ {}))
    if (A.registerFunctionSignatureRewrite(
            Arg, /* ReplacementTypes */ {},
            Attributor::ArgumentReplacementInfo::CalleeRepairCBTy{},
            Attributor::ArgumentReplacementInfo::ACSRepairCBTy{})) {
      Arg.dropDroppableUses();
      return ChangeStatus::CHANGED;
    }
  return Changed;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(IsDead){ static llvm::Statistic NumIRArguments_IsDead = {"attributor"
, "NumIRArguments_IsDead", ("Number of " "arguments" " marked '"
 "IsDead" "'")};; ++(NumIRArguments_IsDead); } }
3620};

3622struct AAIsDeadCallSiteArgument : public AAIsDeadValueImpl {
AAIsDeadCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAIsDeadValueImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (isa<UndefValue>(getAssociatedValue()))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Argument *Arg = getAssociatedArgument();
  if (!Arg)
    return indicatePessimisticFixpoint();
  const IRPosition &ArgPos = IRPosition::argument(*Arg);
  auto &ArgAA = A.getAAFor<AAIsDead>(*this, ArgPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), ArgAA.getState());
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  CallBase &CB = cast<CallBase>(getAnchorValue());
  Use &U = CB.getArgOperandUse(getCallSiteArgNo());
  assert(!isa<UndefValue>(U.get()) &&(static_cast <bool> (!isa<UndefValue>(U.get()) &&
 "Expected undef values to be filtered out!") ? void (0) : __assert_fail
 ("!isa<UndefValue>(U.get()) && \"Expected undef values to be filtered out!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3651, __extension__
 __PRETTY_FUNCTION__))
         "Expected undef values to be filtered out!")(static_cast <bool> (!isa<UndefValue>(U.get()) &&
 "Expected undef values to be filtered out!") ? void (0) : __assert_fail
 ("!isa<UndefValue>(U.get()) && \"Expected undef values to be filtered out!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3651, __extension__
 __PRETTY_FUNCTION__));
  UndefValue &UV = *UndefValue::get(U->getType());
  if (A.changeUseAfterManifest(U, UV))
    return ChangeStatus::CHANGED;
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(IsDead){ static llvm::Statistic NumIRCSArguments_IsDead = {"attributor"
, "NumIRCSArguments_IsDead", ("Number of " "call site arguments"
 " marked '" "IsDead" "'")};; ++(NumIRCSArguments_IsDead); } }
3660};

3662struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
AAIsDeadCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AAIsDeadFloating(IRP, A) {}

/// See AAIsDead::isAssumedDead().
bool isAssumedDead() const override {
  return AAIsDeadFloating::isAssumedDead() && IsAssumedSideEffectFree;
}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (isa<UndefValue>(getAssociatedValue())) {
    indicatePessimisticFixpoint();
    return;
  }

  // We track this separately as a secondary state.
  IsAssumedSideEffectFree = isAssumedSideEffectFree(A, getCtxI());
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Changed = ChangeStatus::UNCHANGED;
  if (IsAssumedSideEffectFree && !isAssumedSideEffectFree(A, getCtxI())) {
    IsAssumedSideEffectFree = false;
    Changed = ChangeStatus::CHANGED;
  }
  if (!areAllUsesAssumedDead(A, getAssociatedValue()))
    return indicatePessimisticFixpoint();
  return Changed;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (IsAssumedSideEffectFree)
    STATS_DECLTRACK_CSRET_ATTR(IsDead){ static llvm::Statistic NumIRCSReturn_IsDead = {"attributor"
, "NumIRCSReturn_IsDead", ("Number of " "call site returns" " marked '"
 "IsDead" "'")};; ++(NumIRCSReturn_IsDead); }
  else
    STATS_DECLTRACK_CSRET_ATTR(UnusedResult){ static llvm::Statistic NumIRCSReturn_UnusedResult = {"attributor"
, "NumIRCSReturn_UnusedResult", ("Number of " "call site returns"
 " marked '" "UnusedResult" "'")};; ++(NumIRCSReturn_UnusedResult
); }
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return isAssumedDead()
             ? "assumed-dead"
             : (getAssumed() ? "assumed-dead-users" : "assumed-live");
}

3709private:
bool IsAssumedSideEffectFree = true;
3711};

3713struct AAIsDeadReturned : public AAIsDeadValueImpl {
AAIsDeadReturned(const IRPosition &IRP, Attributor &A)
    : AAIsDeadValueImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {

  bool UsedAssumedInformation = false;
  A.checkForAllInstructions([](Instruction &) { return true; }, *this,
                            {Instruction::Ret}, UsedAssumedInformation);

  auto PredForCallSite = [&](AbstractCallSite ACS) {
    if (ACS.isCallbackCall() || !ACS.getInstruction())
      return false;
    return areAllUsesAssumedDead(A, *ACS.getInstruction());
  };

  if (!A.checkForAllCallSites(PredForCallSite, *this, true,
                              UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // TODO: Rewrite the signature to return void?
  bool AnyChange = false;
  UndefValue &UV = *UndefValue::get(getAssociatedFunction()->getReturnType());
  auto RetInstPred = [&](Instruction &I) {
    ReturnInst &RI = cast<ReturnInst>(I);
    if (!isa<UndefValue>(RI.getReturnValue()))
      AnyChange |= A.changeUseAfterManifest(RI.getOperandUse(0), UV);
    return true;
  };
  bool UsedAssumedInformation = false;
  A.checkForAllInstructions(RetInstPred, *this, {Instruction::Ret},
                            UsedAssumedInformation);
  return AnyChange ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(IsDead){ static llvm::Statistic NumIRFunctionReturn_IsDead = {"attributor"
, "NumIRFunctionReturn_IsDead", ("Number of " "function returns"
 " marked '" "IsDead" "'")};; ++(NumIRFunctionReturn_IsDead);
 } }
3756};

3758struct AAIsDeadFunction : public AAIsDead {
AAIsDeadFunction(const IRPosition &IRP, Attributor &A) : AAIsDead(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  const Function *F = getAnchorScope();
  if (F && !F->isDeclaration()) {
    // We only want to compute liveness once. If the function is not part of
    // the SCC, skip it.
    if (A.isRunOn(*const_cast<Function *>(F))) {
      ToBeExploredFrom.insert(&F->getEntryBlock().front());
      assumeLive(A, F->getEntryBlock());
    } else {
      indicatePessimisticFixpoint();
    }
  }
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return "Live[#BB " + std::to_string(AssumedLiveBlocks.size()) + "/" +
         std::to_string(getAnchorScope()->size()) + "][#TBEP " +
         std::to_string(ToBeExploredFrom.size()) + "][#KDE " +
         std::to_string(KnownDeadEnds.size()) + "]";
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  assert(getState().isValidState() &&(static_cast <bool> (getState().isValidState() &&
 "Attempted to manifest an invalid state!") ? void (0) : __assert_fail
 ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3787, __extension__
 __PRETTY_FUNCTION__))
         "Attempted to manifest an invalid state!")(static_cast <bool> (getState().isValidState() &&
 "Attempted to manifest an invalid state!") ? void (0) : __assert_fail
 ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3787, __extension__
 __PRETTY_FUNCTION__));

  ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
  Function &F = *getAnchorScope();

  if (AssumedLiveBlocks.empty()) {
    A.deleteAfterManifest(F);
    return ChangeStatus::CHANGED;
  }

  // Flag to determine if we can change an invoke to a call assuming the
  // callee is nounwind. This is not possible if the personality of the
  // function allows to catch asynchronous exceptions.
  bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);

  KnownDeadEnds.set_union(ToBeExploredFrom);
  for (const Instruction *DeadEndI : KnownDeadEnds) {
    auto *CB = dyn_cast<CallBase>(DeadEndI);
    if (!CB)
      continue;
    const auto &NoReturnAA = A.getAndUpdateAAFor<AANoReturn>(
        *this, IRPosition::callsite_function(*CB), DepClassTy::OPTIONAL);
    bool MayReturn = !NoReturnAA.isAssumedNoReturn();
    if (MayReturn && (!Invoke2CallAllowed || !isa<InvokeInst>(CB)))
      continue;

    if (auto *II = dyn_cast<InvokeInst>(DeadEndI))
      A.registerInvokeWithDeadSuccessor(const_cast<InvokeInst &>(*II));
    else
      A.changeToUnreachableAfterManifest(
          const_cast<Instruction *>(DeadEndI->getNextNode()));
    HasChanged = ChangeStatus::CHANGED;
  }

  STATS_DECL(AAIsDead, BasicBlock, "Number of dead basic blocks deleted.")static llvm::Statistic NumIRBasicBlock_AAIsDead = {"attributor"
, "NumIRBasicBlock_AAIsDead", "Number of dead basic blocks deleted."
};;;
  for (BasicBlock &BB : F)
    if (!AssumedLiveBlocks.count(&BB)) {
      A.deleteAfterManifest(BB);
      ++BUILD_STAT_NAME(AAIsDead, BasicBlock)NumIRBasicBlock_AAIsDead;
      HasChanged = ChangeStatus::CHANGED;
    }

  return HasChanged;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override;

bool isEdgeDead(const BasicBlock *From, const BasicBlock *To) const override {
  assert(From->getParent() == getAnchorScope() &&(static_cast <bool> (From->getParent() == getAnchorScope
() && To->getParent() == getAnchorScope() &&
 "Used AAIsDead of the wrong function") ? void (0) : __assert_fail
 ("From->getParent() == getAnchorScope() && To->getParent() == getAnchorScope() && \"Used AAIsDead of the wrong function\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3838, __extension__
 __PRETTY_FUNCTION__))
         To->getParent() == getAnchorScope() &&(static_cast <bool> (From->getParent() == getAnchorScope
() && To->getParent() == getAnchorScope() &&
 "Used AAIsDead of the wrong function") ? void (0) : __assert_fail
 ("From->getParent() == getAnchorScope() && To->getParent() == getAnchorScope() && \"Used AAIsDead of the wrong function\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3838, __extension__
 __PRETTY_FUNCTION__))
         "Used AAIsDead of the wrong function")(static_cast <bool> (From->getParent() == getAnchorScope
() && To->getParent() == getAnchorScope() &&
 "Used AAIsDead of the wrong function") ? void (0) : __assert_fail
 ("From->getParent() == getAnchorScope() && To->getParent() == getAnchorScope() && \"Used AAIsDead of the wrong function\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3838, __extension__
 __PRETTY_FUNCTION__));
  return isValidState() && !AssumedLiveEdges.count(std::make_pair(From, To));
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}

/// Returns true if the function is assumed dead.
bool isAssumedDead() const override { return false; }

/// See AAIsDead::isKnownDead().
bool isKnownDead() const override { return false; }

/// See AAIsDead::isAssumedDead(BasicBlock *).
bool isAssumedDead(const BasicBlock *BB) const override {
  assert(BB->getParent() == getAnchorScope() &&(static_cast <bool> (BB->getParent() == getAnchorScope
() && "BB must be in the same anchor scope function."
) ? void (0) : __assert_fail ("BB->getParent() == getAnchorScope() && \"BB must be in the same anchor scope function.\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3854, __extension__
 __PRETTY_FUNCTION__))
         "BB must be in the same anchor scope function.")(static_cast <bool> (BB->getParent() == getAnchorScope
() && "BB must be in the same anchor scope function."
) ? void (0) : __assert_fail ("BB->getParent() == getAnchorScope() && \"BB must be in the same anchor scope function.\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3854, __extension__
 __PRETTY_FUNCTION__));

  if (!getAssumed())
    return false;
  return !AssumedLiveBlocks.count(BB);
}

/// See AAIsDead::isKnownDead(BasicBlock *).
bool isKnownDead(const BasicBlock *BB) const override {
  return getKnown() && isAssumedDead(BB);
}

/// See AAIsDead::isAssumed(Instruction *I).
bool isAssumedDead(const Instruction *I) const override {
  assert(I->getParent()->getParent() == getAnchorScope() &&(static_cast <bool> (I->getParent()->getParent() ==
 getAnchorScope() && "Instruction must be in the same anchor scope function."
) ? void (0) : __assert_fail ("I->getParent()->getParent() == getAnchorScope() && \"Instruction must be in the same anchor scope function.\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3869, __extension__
 __PRETTY_FUNCTION__))
         "Instruction must be in the same anchor scope function.")(static_cast <bool> (I->getParent()->getParent() ==
 getAnchorScope() && "Instruction must be in the same anchor scope function."
) ? void (0) : __assert_fail ("I->getParent()->getParent() == getAnchorScope() && \"Instruction must be in the same anchor scope function.\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 3869, __extension__
 __PRETTY_FUNCTION__));

  if (!getAssumed())
    return false;

  // If it is not in AssumedLiveBlocks then it for sure dead.
  // Otherwise, it can still be after noreturn call in a live block.
  if (!AssumedLiveBlocks.count(I->getParent()))
    return true;

  // If it is not after a liveness barrier it is live.
  const Instruction *PrevI = I->getPrevNode();
  while (PrevI) {
    if (KnownDeadEnds.count(PrevI) || ToBeExploredFrom.count(PrevI))
      return true;
    PrevI = PrevI->getPrevNode();
  }
  return false;
}

/// See AAIsDead::isKnownDead(Instruction *I).
bool isKnownDead(const Instruction *I) const override {
  return getKnown() && isAssumedDead(I);
}

/// Assume \p BB is (partially) live now and indicate to the Attributor \p A
/// that internal function called from \p BB should now be looked at.
bool assumeLive(Attributor &A, const BasicBlock &BB) {
  if (!AssumedLiveBlocks.insert(&BB).second)
    return false;

  // We assume that all of BB is (probably) live now and if there are calls to
  // internal functions we will assume that those are now live as well. This
  // is a performance optimization for blocks with calls to a lot of internal
  // functions. It can however cause dead functions to be treated as live.
  for (const Instruction &I : BB)
    if (const auto *CB = dyn_cast<CallBase>(&I))
      if (const Function *F = CB->getCalledFunction())
        if (F->hasLocalLinkage())
          A.markLiveInternalFunction(*F);
  return true;
}

/// Collection of instructions that need to be explored again, e.g., we
/// did assume they do not transfer control to (one of their) successors.
SmallSetVector<const Instruction *, 8> ToBeExploredFrom;

/// Collection of instructions that are known to not transfer control.
SmallSetVector<const Instruction *, 8> KnownDeadEnds;

/// Collection of all assumed live edges
DenseSet<std::pair<const BasicBlock *, const BasicBlock *>> AssumedLiveEdges;

/// Collection of all assumed live BasicBlocks.
DenseSet<const BasicBlock *> AssumedLiveBlocks;
3924};

3926static bool
3927identifyAliveSuccessors(Attributor &A, const CallBase &CB,
                      AbstractAttribute &AA,
                      SmallVectorImpl<const Instruction *> &AliveSuccessors) {
const IRPosition &IPos = IRPosition::callsite_function(CB);

const auto &NoReturnAA =
    A.getAndUpdateAAFor<AANoReturn>(AA, IPos, DepClassTy::OPTIONAL);
if (NoReturnAA.isAssumedNoReturn())
  return !NoReturnAA.isKnownNoReturn();
if (CB.isTerminator())
  AliveSuccessors.push_back(&CB.getSuccessor(0)->front());
else
  AliveSuccessors.push_back(CB.getNextNode());
return false;
3941}

3943static bool
3944identifyAliveSuccessors(Attributor &A, const InvokeInst &II,
                      AbstractAttribute &AA,
                      SmallVectorImpl<const Instruction *> &AliveSuccessors) {
bool UsedAssumedInformation =
    identifyAliveSuccessors(A, cast<CallBase>(II), AA, AliveSuccessors);

// First, determine if we can change an invoke to a call assuming the
// callee is nounwind. This is not possible if the personality of the
// function allows to catch asynchronous exceptions.
if (AAIsDeadFunction::mayCatchAsynchronousExceptions(*II.getFunction())) {
  AliveSuccessors.push_back(&II.getUnwindDest()->front());
} else {
  const IRPosition &IPos = IRPosition::callsite_function(II);
  const auto &AANoUnw =
      A.getAndUpdateAAFor<AANoUnwind>(AA, IPos, DepClassTy::OPTIONAL);
  if (AANoUnw.isAssumedNoUnwind()) {
    UsedAssumedInformation |= !AANoUnw.isKnownNoUnwind();
  } else {
    AliveSuccessors.push_back(&II.getUnwindDest()->front());
  }
}
return UsedAssumedInformation;
3966}

3968static bool
3969identifyAliveSuccessors(Attributor &A, const BranchInst &BI,
                      AbstractAttribute &AA,
                      SmallVectorImpl<const Instruction *> &AliveSuccessors) {
bool UsedAssumedInformation = false;
if (BI.getNumSuccessors() == 1) {
  AliveSuccessors.push_back(&BI.getSuccessor(0)->front());
} else {
  Optional<Constant *> C =
      A.getAssumedConstant(*BI.getCondition(), AA, UsedAssumedInformation);
  if (!C.hasValue() || isa_and_nonnull<UndefValue>(C.getValue())) {
    // No value yet, assume both edges are dead.
  } else if (isa_and_nonnull<ConstantInt>(*C)) {
    const BasicBlock *SuccBB =
        BI.getSuccessor(1 - cast<ConstantInt>(*C)->getValue().getZExtValue());
    AliveSuccessors.push_back(&SuccBB->front());
  } else {
    AliveSuccessors.push_back(&BI.getSuccessor(0)->front());
    AliveSuccessors.push_back(&BI.getSuccessor(1)->front());
    UsedAssumedInformation = false;
  }
}
return UsedAssumedInformation;
3991}

3993static bool
3994identifyAliveSuccessors(Attributor &A, const SwitchInst &SI,
                      AbstractAttribute &AA,
                      SmallVectorImpl<const Instruction *> &AliveSuccessors) {
bool UsedAssumedInformation = false;
Optional<Constant *> C =
    A.getAssumedConstant(*SI.getCondition(), AA, UsedAssumedInformation);
if (!C.hasValue() || isa_and_nonnull<UndefValue>(C.getValue())) {
  // No value yet, assume all edges are dead.
} else if (isa_and_nonnull<ConstantInt>(C.getValue())) {
  for (auto &CaseIt : SI.cases()) {
    if (CaseIt.getCaseValue() == C.getValue()) {
      AliveSuccessors.push_back(&CaseIt.getCaseSuccessor()->front());
      return UsedAssumedInformation;
    }
  }
  AliveSuccessors.push_back(&SI.getDefaultDest()->front());
  return UsedAssumedInformation;
} else {
  for (const BasicBlock *SuccBB : successors(SI.getParent()))
    AliveSuccessors.push_back(&SuccBB->front());
}
return UsedAssumedInformation;
4016}

4018ChangeStatus AAIsDeadFunction::updateImpl(Attributor &A) {
ChangeStatus Change = ChangeStatus::UNCHANGED;

LLVM_DEBUG(dbgs() << "[AAIsDead] Live [" << AssumedLiveBlocks.size() << "/"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Live [" <<
 AssumedLiveBlocks.size() << "/" << getAnchorScope
()->size() << "] BBs and " << ToBeExploredFrom
.size() << " exploration points and " << KnownDeadEnds
.size() << " known dead ends\n"; } } while (false)
                  << getAnchorScope()->size() << "] BBs and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Live [" <<
 AssumedLiveBlocks.size() << "/" << getAnchorScope
()->size() << "] BBs and " << ToBeExploredFrom
.size() << " exploration points and " << KnownDeadEnds
.size() << " known dead ends\n"; } } while (false)
                  << ToBeExploredFrom.size() << " exploration points and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Live [" <<
 AssumedLiveBlocks.size() << "/" << getAnchorScope
()->size() << "] BBs and " << ToBeExploredFrom
.size() << " exploration points and " << KnownDeadEnds
.size() << " known dead ends\n"; } } while (false)
                  << KnownDeadEnds.size() << " known dead ends\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Live [" <<
 AssumedLiveBlocks.size() << "/" << getAnchorScope
()->size() << "] BBs and " << ToBeExploredFrom
.size() << " exploration points and " << KnownDeadEnds
.size() << " known dead ends\n"; } } while (false);

// Copy and clear the list of instructions we need to explore from. It is
// refilled with instructions the next update has to look at.
SmallVector<const Instruction *, 8> Worklist(ToBeExploredFrom.begin(),
                                             ToBeExploredFrom.end());
decltype(ToBeExploredFrom) NewToBeExploredFrom;

SmallVector<const Instruction *, 8> AliveSuccessors;
while (!Worklist.empty()) {
  const Instruction *I = Worklist.pop_back_val();
  LLVM_DEBUG(dbgs() << "[AAIsDead] Exploration inst: " << *I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Exploration inst: "
 << *I << "\n"; } } while (false);

  // Fast forward for uninteresting instructions. We could look for UB here
  // though.
  while (!I->isTerminator() && !isa<CallBase>(I))
    I = I->getNextNode();

  AliveSuccessors.clear();

  bool UsedAssumedInformation = false;
  switch (I->getOpcode()) {
  // TODO: look for (assumed) UB to backwards propagate "deadness".
  default:
    assert(I->isTerminator() &&(static_cast <bool> (I->isTerminator() && "Expected non-terminators to be handled already!"
) ? void (0) : __assert_fail ("I->isTerminator() && \"Expected non-terminators to be handled already!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 4049, __extension__
 __PRETTY_FUNCTION__))
           "Expected non-terminators to be handled already!")(static_cast <bool> (I->isTerminator() && "Expected non-terminators to be handled already!"
) ? void (0) : __assert_fail ("I->isTerminator() && \"Expected non-terminators to be handled already!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 4049, __extension__
 __PRETTY_FUNCTION__));
    for (const BasicBlock *SuccBB : successors(I->getParent()))
      AliveSuccessors.push_back(&SuccBB->front());
    break;
  case Instruction::Call:
    UsedAssumedInformation = identifyAliveSuccessors(A, cast<CallInst>(*I),
                                                     *this, AliveSuccessors);
    break;
  case Instruction::Invoke:
    UsedAssumedInformation = identifyAliveSuccessors(A, cast<InvokeInst>(*I),
                                                     *this, AliveSuccessors);
    break;
  case Instruction::Br:
    UsedAssumedInformation = identifyAliveSuccessors(A, cast<BranchInst>(*I),
                                                     *this, AliveSuccessors);
    break;
  case Instruction::Switch:
    UsedAssumedInformation = identifyAliveSuccessors(A, cast<SwitchInst>(*I),
                                                     *this, AliveSuccessors);
    break;
  }

  if (UsedAssumedInformation) {
    NewToBeExploredFrom.insert(I);
  } else if (AliveSuccessors.empty() ||
             (I->isTerminator() &&
              AliveSuccessors.size() < I->getNumSuccessors())) {
    if (KnownDeadEnds.insert(I))
      Change = ChangeStatus::CHANGED;
  }

  LLVM_DEBUG(dbgs() << "[AAIsDead] #AliveSuccessors: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] #AliveSuccessors: "
 << AliveSuccessors.size() << " UsedAssumedInformation: "
 << UsedAssumedInformation << "\n"; } } while (false
)
                    << AliveSuccessors.size() << " UsedAssumedInformation: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] #AliveSuccessors: "
 << AliveSuccessors.size() << " UsedAssumedInformation: "
 << UsedAssumedInformation << "\n"; } } while (false
)
                    << UsedAssumedInformation << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] #AliveSuccessors: "
 << AliveSuccessors.size() << " UsedAssumedInformation: "
 << UsedAssumedInformation << "\n"; } } while (false
);

  for (const Instruction *AliveSuccessor : AliveSuccessors) {
    if (!I->isTerminator()) {
      assert(AliveSuccessors.size() == 1 &&(static_cast <bool> (AliveSuccessors.size() == 1 &&
 "Non-terminator expected to have a single successor!") ? void
 (0) : __assert_fail ("AliveSuccessors.size() == 1 && \"Non-terminator expected to have a single successor!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 4087, __extension__
 __PRETTY_FUNCTION__))
             "Non-terminator expected to have a single successor!")(static_cast <bool> (AliveSuccessors.size() == 1 &&
 "Non-terminator expected to have a single successor!") ? void
 (0) : __assert_fail ("AliveSuccessors.size() == 1 && \"Non-terminator expected to have a single successor!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 4087, __extension__
 __PRETTY_FUNCTION__));
      Worklist.push_back(AliveSuccessor);
    } else {
      // record the assumed live edge
      auto Edge = std::make_pair(I->getParent(), AliveSuccessor->getParent());
      if (AssumedLiveEdges.insert(Edge).second)
        Change = ChangeStatus::CHANGED;
      if (assumeLive(A, *AliveSuccessor->getParent()))
        Worklist.push_back(AliveSuccessor);
    }
  }
}

// Check if the content of ToBeExploredFrom changed, ignore the order.
if (NewToBeExploredFrom.size() != ToBeExploredFrom.size() ||
    llvm::any_of(NewToBeExploredFrom, [&](const Instruction *I) {
      return !ToBeExploredFrom.count(I);
    })) {
  Change = ChangeStatus::CHANGED;
  ToBeExploredFrom = std::move(NewToBeExploredFrom);
}

// If we know everything is live there is no need to query for liveness.
// Instead, indicating a pessimistic fixpoint will cause the state to be
// "invalid" and all queries to be answered conservatively without lookups.
// To be in this state we have to (1) finished the exploration and (3) not
// discovered any non-trivial dead end and (2) not ruled unreachable code
// dead.
if (ToBeExploredFrom.empty() &&
    getAnchorScope()->size() == AssumedLiveBlocks.size() &&
    llvm::all_of(KnownDeadEnds, [](const Instruction *DeadEndI) {
      return DeadEndI->isTerminator() && DeadEndI->getNumSuccessors() == 0;
    }))
  return indicatePessimisticFixpoint();
return Change;
4122}

4124/// Liveness information for a call sites.
4125struct AAIsDeadCallSite final : AAIsDeadFunction {
AAIsDeadCallSite(const IRPosition &IRP, Attributor &A)
    : AAIsDeadFunction(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites instead of
  //       redirecting requests to the callee.
  llvm_unreachable("Abstract attributes for liveness are not "::llvm::llvm_unreachable_internal("Abstract attributes for liveness are not "
 "supported for call sites yet!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 4136)
                   "supported for call sites yet!")::llvm::llvm_unreachable_internal("Abstract attributes for liveness are not "
 "supported for call sites yet!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 4136);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}
4146};

4148/// -------------------- Dereferenceable Argument Attribute --------------------

4150struct AADereferenceableImpl : AADereferenceable {
AADereferenceableImpl(const IRPosition &IRP, Attributor &A)
    : AADereferenceable(IRP, A) {}
using StateType = DerefState;

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  SmallVector<Attribute, 4> Attrs;
  getAttrs({Attribute::Dereferenceable, Attribute::DereferenceableOrNull},
           Attrs, /* IgnoreSubsumingPositions */ false, &A);
  for (const Attribute &Attr : Attrs)
    takeKnownDerefBytesMaximum(Attr.getValueAsInt());

  const IRPosition &IRP = this->getIRPosition();
  NonNullAA = &A.getAAFor<AANonNull>(*this, IRP, DepClassTy::NONE);

  bool CanBeNull, CanBeFreed;
  takeKnownDerefBytesMaximum(
      IRP.getAssociatedValue().getPointerDereferenceableBytes(
          A.getDataLayout(), CanBeNull, CanBeFreed));

  bool IsFnInterface = IRP.isFnInterfaceKind();
  Function *FnScope = IRP.getAnchorScope();
  if (IsFnInterface && (!FnScope || !A.isFunctionIPOAmendable(*FnScope))) {
    indicatePessimisticFixpoint();
    return;
  }

  if (Instruction *CtxI = getCtxI())
    followUsesInMBEC(*this, A, getState(), *CtxI);
}

/// See AbstractAttribute::getState()
/// {
StateType &getState() override { return *this; }
const StateType &getState() const override { return *this; }
/// }

/// Helper function for collecting accessed bytes in must-be-executed-context
void addAccessedBytesForUse(Attributor &A, const Use *U, const Instruction *I,
                            DerefState &State) {
  const Value *UseV = U->get();
  if (!UseV->getType()->isPointerTy())
    return;

  Optional<MemoryLocation> Loc = MemoryLocation::getOrNone(I);
  if (!Loc || Loc->Ptr != UseV || !Loc->Size.isPrecise() || I->isVolatile())
    return;

  int64_t Offset;
  const Value *Base = GetPointerBaseWithConstantOffset(
      Loc->Ptr, Offset, A.getDataLayout(), /*AllowNonInbounds*/ true);
  if (Base && Base == &getAssociatedValue())
    State.addAccessedBytes(Offset, Loc->Size.getValue());
}

/// See followUsesInMBEC
bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
                     AADereferenceable::StateType &State) {
  bool IsNonNull = false;
  bool TrackUse = false;
  int64_t DerefBytes = getKnownNonNullAndDerefBytesForUse(
      A, *this, getAssociatedValue(), U, I, IsNonNull, TrackUse);
  LLVM_DEBUG(dbgs() << "[AADereferenceable] Deref bytes: " << DerefBytesdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AADereferenceable] Deref bytes: "
 << DerefBytes << " for instruction " << *I
 << "\n"; } } while (false)
                    << " for instruction " << *I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AADereferenceable] Deref bytes: "
 << DerefBytes << " for instruction " << *I
 << "\n"; } } while (false);

  addAccessedBytesForUse(A, U, I, State);
  State.takeKnownDerefBytesMaximum(DerefBytes);
  return TrackUse;
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Change = AADereferenceable::manifest(A);
  if (isAssumedNonNull() && hasAttr(Attribute::DereferenceableOrNull)) {
    removeAttrs({Attribute::DereferenceableOrNull});
    return ChangeStatus::CHANGED;
  }
  return Change;
}

void getDeducedAttributes(LLVMContext &Ctx,
                          SmallVectorImpl<Attribute> &Attrs) const override {
  // TODO: Add *_globally support
  if (isAssumedNonNull())
    Attrs.emplace_back(Attribute::getWithDereferenceableBytes(
        Ctx, getAssumedDereferenceableBytes()));
  else
    Attrs.emplace_back(Attribute::getWithDereferenceableOrNullBytes(
        Ctx, getAssumedDereferenceableBytes()));
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  if (!getAssumedDereferenceableBytes())
    return "unknown-dereferenceable";
  return std::string("dereferenceable") +
         (isAssumedNonNull() ? "" : "_or_null") +
         (isAssumedGlobal() ? "_globally" : "") + "<" +
         std::to_string(getKnownDereferenceableBytes()) + "-" +
         std::to_string(getAssumedDereferenceableBytes()) + ">";
}
4252};

4254/// Dereferenceable attribute for a floating value.
4255struct AADereferenceableFloating : AADereferenceableImpl {
AADereferenceableFloating(const IRPosition &IRP, Attributor &A)
    : AADereferenceableImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const DataLayout &DL = A.getDataLayout();

  auto VisitValueCB = [&](const Value &V, const Instruction *, DerefState &T,
                          bool Stripped) -> bool {
    unsigned IdxWidth =
        DL.getIndexSizeInBits(V.getType()->getPointerAddressSpace());
    APInt Offset(IdxWidth, 0);
    const Value *Base =
        stripAndAccumulateMinimalOffsets(A, *this, &V, DL, Offset, false);

    const auto &AA = A.getAAFor<AADereferenceable>(
        *this, IRPosition::value(*Base), DepClassTy::REQUIRED);
    int64_t DerefBytes = 0;
    if (!Stripped && this == &AA) {
      // Use IR information if we did not strip anything.
      // TODO: track globally.
      bool CanBeNull, CanBeFreed;
      DerefBytes =
          Base->getPointerDereferenceableBytes(DL, CanBeNull, CanBeFreed);
      T.GlobalState.indicatePessimisticFixpoint();
    } else {
      const DerefState &DS = AA.getState();
      DerefBytes = DS.DerefBytesState.getAssumed();
      T.GlobalState &= DS.GlobalState;
    }

    // For now we do not try to "increase" dereferenceability due to negative
    // indices as we first have to come up with code to deal with loops and
    // for overflows of the dereferenceable bytes.
    int64_t OffsetSExt = Offset.getSExtValue();
    if (OffsetSExt < 0)
      OffsetSExt = 0;

    T.takeAssumedDerefBytesMinimum(
        std::max(int64_t(0), DerefBytes - OffsetSExt));

    if (this == &AA) {
      if (!Stripped) {
        // If nothing was stripped IR information is all we got.
        T.takeKnownDerefBytesMaximum(
            std::max(int64_t(0), DerefBytes - OffsetSExt));
        T.indicatePessimisticFixpoint();
      } else if (OffsetSExt > 0) {
        // If something was stripped but there is circular reasoning we look
        // for the offset. If it is positive we basically decrease the
        // dereferenceable bytes in a circluar loop now, which will simply
        // drive them down to the known value in a very slow way which we
        // can accelerate.
        T.indicatePessimisticFixpoint();
      }
    }

    return T.isValidState();
  };

  DerefState T;
  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<DerefState>(A, getIRPosition(), *this, T,
                                         VisitValueCB, getCtxI(),
                                         UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return clampStateAndIndicateChange(getState(), T);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(dereferenceable){ static llvm::Statistic NumIRFloating_dereferenceable = {"attributor"
, "NumIRFloating_dereferenceable", ("Number of floating values known to be '"
 "dereferenceable" "'")};; ++(NumIRFloating_dereferenceable);
 }
}
4330};

4332/// Dereferenceable attribute for a return value.
4333struct AADereferenceableReturned final
  : AAReturnedFromReturnedValues<AADereferenceable, AADereferenceableImpl> {
AADereferenceableReturned(const IRPosition &IRP, Attributor &A)
    : AAReturnedFromReturnedValues<AADereferenceable, AADereferenceableImpl>(
          IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FNRET_ATTR(dereferenceable){ static llvm::Statistic NumIRFunctionReturn_dereferenceable =
 {"attributor", "NumIRFunctionReturn_dereferenceable", ("Number of "
 "function returns" " marked '" "dereferenceable" "'")};; ++(
NumIRFunctionReturn_dereferenceable); }
}
4343};

4345/// Dereferenceable attribute for an argument
4346struct AADereferenceableArgument final
  : AAArgumentFromCallSiteArguments<AADereferenceable,
                                    AADereferenceableImpl> {
using Base =
    AAArgumentFromCallSiteArguments<AADereferenceable, AADereferenceableImpl>;
AADereferenceableArgument(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_ARG_ATTR(dereferenceable){ static llvm::Statistic NumIRArguments_dereferenceable = {"attributor"
, "NumIRArguments_dereferenceable", ("Number of " "arguments"
 " marked '" "dereferenceable" "'")};; ++(NumIRArguments_dereferenceable
); }
}
4358};

4360/// Dereferenceable attribute for a call site argument.
4361struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {
AADereferenceableCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AADereferenceableFloating(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSARG_ATTR(dereferenceable){ static llvm::Statistic NumIRCSArguments_dereferenceable = {
"attributor", "NumIRCSArguments_dereferenceable", ("Number of "
 "call site arguments" " marked '" "dereferenceable" "'")};; ++
(NumIRCSArguments_dereferenceable); }
}
4369};

4371/// Dereferenceable attribute deduction for a call site return value.
4372struct AADereferenceableCallSiteReturned final
  : AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl> {
using Base =
    AACallSiteReturnedFromReturned<AADereferenceable, AADereferenceableImpl>;
AADereferenceableCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CS_ATTR(dereferenceable){ static llvm::Statistic NumIRCS_dereferenceable = {"attributor"
, "NumIRCS_dereferenceable", ("Number of " "call site" " marked '"
 "dereferenceable" "'")};; ++(NumIRCS_dereferenceable); };
}
4383};

4385// ------------------------ Align Argument Attribute ------------------------

4387static unsigned getKnownAlignForUse(Attributor &A, AAAlign &QueryingAA,
                                  Value &AssociatedValue, const Use *U,
                                  const Instruction *I, bool &TrackUse) {
// We need to follow common pointer manipulation uses to the accesses they
// feed into.
if (isa<CastInst>(I)) {
  // Follow all but ptr2int casts.
  TrackUse = !isa<PtrToIntInst>(I);
  return 0;
}
if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
  if (GEP->hasAllConstantIndices())
    TrackUse = true;
  return 0;
}

MaybeAlign MA;
if (const auto *CB = dyn_cast<CallBase>(I)) {
  if (CB->isBundleOperand(U) || CB->isCallee(U))
    return 0;

  unsigned ArgNo = CB->getArgOperandNo(U);
  IRPosition IRP = IRPosition::callsite_argument(*CB, ArgNo);
  // As long as we only use known information there is no need to track
  // dependences here.
  auto &AlignAA = A.getAAFor<AAAlign>(QueryingAA, IRP, DepClassTy::NONE);
  MA = MaybeAlign(AlignAA.getKnownAlign());
}

const DataLayout &DL = A.getDataLayout();
const Value *UseV = U->get();
if (auto *SI = dyn_cast<StoreInst>(I)) {
  if (SI->getPointerOperand() == UseV)
    MA = SI->getAlign();
} else if (auto *LI = dyn_cast<LoadInst>(I)) {
  if (LI->getPointerOperand() == UseV)
    MA = LI->getAlign();
}

if (!MA || *MA <= QueryingAA.getKnownAlign())
  return 0;

unsigned Alignment = MA->value();
int64_t Offset;

if (const Value *Base = GetPointerBaseWithConstantOffset(UseV, Offset, DL)) {
  if (Base == &AssociatedValue) {
    // BasePointerAddr + Offset = Alignment * Q for some integer Q.
    // So we can say that the maximum power of two which is a divisor of
    // gcd(Offset, Alignment) is an alignment.

    uint32_t gcd =
        greatestCommonDivisor(uint32_t(abs((int32_t)Offset)), Alignment);
    Alignment = llvm::PowerOf2Floor(gcd);
  }
}

return Alignment;
4445}

4447struct AAAlignImpl : AAAlign {
AAAlignImpl(const IRPosition &IRP, Attributor &A) : AAAlign(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  SmallVector<Attribute, 4> Attrs;
  getAttrs({Attribute::Alignment}, Attrs);
  for (const Attribute &Attr : Attrs)
    takeKnownMaximum(Attr.getValueAsInt());

  Value &V = getAssociatedValue();
  // TODO: This is a HACK to avoid getPointerAlignment to introduce a ptr2int
  //       use of the function pointer. This was caused by D73131. We want to
  //       avoid this for function pointers especially because we iterate
  //       their uses and int2ptr is not handled. It is not a correctness
  //       problem though!
  if (!V.getType()->getPointerElementType()->isFunctionTy())
    takeKnownMaximum(V.getPointerAlignment(A.getDataLayout()).value());

  if (getIRPosition().isFnInterfaceKind() &&
      (!getAnchorScope() ||
       !A.isFunctionIPOAmendable(*getAssociatedFunction()))) {
    indicatePessimisticFixpoint();
    return;
  }

  if (Instruction *CtxI = getCtxI())
    followUsesInMBEC(*this, A, getState(), *CtxI);
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus LoadStoreChanged = ChangeStatus::UNCHANGED;

  // Check for users that allow alignment annotations.
  Value &AssociatedValue = getAssociatedValue();
  for (const Use &U : AssociatedValue.uses()) {
    if (auto *SI = dyn_cast<StoreInst>(U.getUser())) {
      if (SI->getPointerOperand() == &AssociatedValue)
        if (SI->getAlignment() < getAssumedAlign()) {
          STATS_DECLTRACK(AAAlign, Store,{ static llvm::Statistic NumIRStore_AAAlign = {"attributor", "NumIRStore_AAAlign"
, "Number of times alignment added to a store"};; ++(NumIRStore_AAAlign
); }
                          "Number of times alignment added to a store"){ static llvm::Statistic NumIRStore_AAAlign = {"attributor", "NumIRStore_AAAlign"
, "Number of times alignment added to a store"};; ++(NumIRStore_AAAlign
); };
          SI->setAlignment(Align(getAssumedAlign()));
          LoadStoreChanged = ChangeStatus::CHANGED;
        }
    } else if (auto *LI = dyn_cast<LoadInst>(U.getUser())) {
      if (LI->getPointerOperand() == &AssociatedValue)
        if (LI->getAlignment() < getAssumedAlign()) {
          LI->setAlignment(Align(getAssumedAlign()));
          STATS_DECLTRACK(AAAlign, Load,{ static llvm::Statistic NumIRLoad_AAAlign = {"attributor", "NumIRLoad_AAAlign"
, "Number of times alignment added to a load"};; ++(NumIRLoad_AAAlign
); }
                          "Number of times alignment added to a load"){ static llvm::Statistic NumIRLoad_AAAlign = {"attributor", "NumIRLoad_AAAlign"
, "Number of times alignment added to a load"};; ++(NumIRLoad_AAAlign
); };
          LoadStoreChanged = ChangeStatus::CHANGED;
        }
    }
  }

  ChangeStatus Changed = AAAlign::manifest(A);

  Align InheritAlign =
      getAssociatedValue().getPointerAlignment(A.getDataLayout());
  if (InheritAlign >= getAssumedAlign())
    return LoadStoreChanged;
  return Changed | LoadStoreChanged;
}

// TODO: Provide a helper to determine the implied ABI alignment and check in
//       the existing manifest method and a new one for AAAlignImpl that value
//       to avoid making the alignment explicit if it did not improve.

/// See AbstractAttribute::getDeducedAttributes
virtual void
getDeducedAttributes(LLVMContext &Ctx,
                     SmallVectorImpl<Attribute> &Attrs) const override {
  if (getAssumedAlign() > 1)
    Attrs.emplace_back(
        Attribute::getWithAlignment(Ctx, Align(getAssumedAlign())));
}

/// See followUsesInMBEC
bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
                     AAAlign::StateType &State) {
  bool TrackUse = false;

  unsigned int KnownAlign =
      getKnownAlignForUse(A, *this, getAssociatedValue(), U, I, TrackUse);
  State.takeKnownMaximum(KnownAlign);

  return TrackUse;
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumedAlign() ? ("align<" + std::to_string(getKnownAlign()) +
                              "-" + std::to_string(getAssumedAlign()) + ">")
                           : "unknown-align";
}
4543};

4545/// Align attribute for a floating value.
4546struct AAAlignFloating : AAAlignImpl {
AAAlignFloating(const IRPosition &IRP, Attributor &A) : AAAlignImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const DataLayout &DL = A.getDataLayout();

  auto VisitValueCB = [&](Value &V, const Instruction *,
                          AAAlign::StateType &T, bool Stripped) -> bool {
    const auto &AA = A.getAAFor<AAAlign>(*this, IRPosition::value(V),
                                         DepClassTy::REQUIRED);
    if (!Stripped && this == &AA) {
      int64_t Offset;
      unsigned Alignment = 1;
      if (const Value *Base =
              GetPointerBaseWithConstantOffset(&V, Offset, DL)) {
        Align PA = Base->getPointerAlignment(DL);
        // BasePointerAddr + Offset = Alignment * Q for some integer Q.
        // So we can say that the maximum power of two which is a divisor of
        // gcd(Offset, Alignment) is an alignment.

        uint32_t gcd = greatestCommonDivisor(uint32_t(abs((int32_t)Offset)),
                                             uint32_t(PA.value()));
        Alignment = llvm::PowerOf2Floor(gcd);
      } else {
        Alignment = V.getPointerAlignment(DL).value();
      }
      // Use only IR information if we did not strip anything.
      T.takeKnownMaximum(Alignment);
      T.indicatePessimisticFixpoint();
    } else {
      // Use abstract attribute information.
      const AAAlign::StateType &DS = AA.getState();
      T ^= DS;
    }
    return T.isValidState();
  };

  StateType T;
  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<StateType>(A, getIRPosition(), *this, T,
                                        VisitValueCB, getCtxI(),
                                        UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  // TODO: If we know we visited all incoming values, thus no are assumed
  // dead, we can take the known information from the state T.
  return clampStateAndIndicateChange(getState(), T);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FLOATING_ATTR(align){ static llvm::Statistic NumIRFloating_align = {"attributor",
 "NumIRFloating_align", ("Number of floating values known to be '"
 "align" "'")};; ++(NumIRFloating_align); } }
4598};

4600/// Align attribute for function return value.
4601struct AAAlignReturned final
  : AAReturnedFromReturnedValues<AAAlign, AAAlignImpl> {
using Base = AAReturnedFromReturnedValues<AAAlign, AAAlignImpl>;
AAAlignReturned(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  Base::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(aligned){ static llvm::Statistic NumIRFunctionReturn_aligned = {"attributor"
, "NumIRFunctionReturn_aligned", ("Number of " "function returns"
 " marked '" "aligned" "'")};; ++(NumIRFunctionReturn_aligned
); } }
4616};

4618/// Align attribute for function argument.
4619struct AAAlignArgument final
  : AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl> {
using Base = AAArgumentFromCallSiteArguments<AAAlign, AAAlignImpl>;
AAAlignArgument(const IRPosition &IRP, Attributor &A) : Base(IRP, A) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // If the associated argument is involved in a must-tail call we give up
  // because we would need to keep the argument alignments of caller and
  // callee in-sync. Just does not seem worth the trouble right now.
  if (A.getInfoCache().isInvolvedInMustTailCall(*getAssociatedArgument()))
    return ChangeStatus::UNCHANGED;
  return Base::manifest(A);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(aligned){ static llvm::Statistic NumIRArguments_aligned = {"attributor"
, "NumIRArguments_aligned", ("Number of " "arguments" " marked '"
 "aligned" "'")};; ++(NumIRArguments_aligned); } }
4636};

4638struct AAAlignCallSiteArgument final : AAAlignFloating {
AAAlignCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAAlignFloating(IRP, A) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // If the associated argument is involved in a must-tail call we give up
  // because we would need to keep the argument alignments of caller and
  // callee in-sync. Just does not seem worth the trouble right now.
  if (Argument *Arg = getAssociatedArgument())
    if (A.getInfoCache().isInvolvedInMustTailCall(*Arg))
      return ChangeStatus::UNCHANGED;
  ChangeStatus Changed = AAAlignImpl::manifest(A);
  Align InheritAlign =
      getAssociatedValue().getPointerAlignment(A.getDataLayout());
  if (InheritAlign >= getAssumedAlign())
    Changed = ChangeStatus::UNCHANGED;
  return Changed;
}

/// See AbstractAttribute::updateImpl(Attributor &A).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Changed = AAAlignFloating::updateImpl(A);
  if (Argument *Arg = getAssociatedArgument()) {
    // We only take known information from the argument
    // so we do not need to track a dependence.
    const auto &ArgAlignAA = A.getAAFor<AAAlign>(
        *this, IRPosition::argument(*Arg), DepClassTy::NONE);
    takeKnownMaximum(ArgAlignAA.getKnownAlign());
  }
  return Changed;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(aligned){ static llvm::Statistic NumIRCSArguments_aligned = {"attributor"
, "NumIRCSArguments_aligned", ("Number of " "call site arguments"
 " marked '" "aligned" "'")};; ++(NumIRCSArguments_aligned); } }
4673};

4675/// Align attribute deduction for a call site return value.
4676struct AAAlignCallSiteReturned final
  : AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl> {
using Base = AACallSiteReturnedFromReturned<AAAlign, AAAlignImpl>;
AAAlignCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  Base::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(align){ static llvm::Statistic NumIRCS_align = {"attributor", "NumIRCS_align"
, ("Number of " "call site" " marked '" "align" "'")};; ++(NumIRCS_align
); }; }
4692};

4694/// ------------------ Function No-Return Attribute ----------------------------
4695struct AANoReturnImpl : public AANoReturn {
AANoReturnImpl(const IRPosition &IRP, Attributor &A) : AANoReturn(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoReturn::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? "noreturn" : "may-return";
}

/// See AbstractAttribute::updateImpl(Attributor &A).
virtual ChangeStatus updateImpl(Attributor &A) override {
  auto CheckForNoReturn = [](Instruction &) { return false; };
  bool UsedAssumedInformation = false;
  if (!A.checkForAllInstructions(CheckForNoReturn, *this,
                                 {(unsigned)Instruction::Ret},
                                 UsedAssumedInformation))
    return indicatePessimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}
4721};

4723struct AANoReturnFunction final : AANoReturnImpl {
AANoReturnFunction(const IRPosition &IRP, Attributor &A)
    : AANoReturnImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(noreturn){ static llvm::Statistic NumIRFunction_noreturn = {"attributor"
, "NumIRFunction_noreturn", ("Number of " "functions" " marked '"
 "noreturn" "'")};; ++(NumIRFunction_noreturn); } }
4729};

4731/// NoReturn attribute deduction for a call sites.
4732struct AANoReturnCallSite final : AANoReturnImpl {
AANoReturnCallSite(const IRPosition &IRP, Attributor &A)
    : AANoReturnImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoReturnImpl::initialize(A);
  if (Function *F = getAssociatedFunction()) {
    const IRPosition &FnPos = IRPosition::function(*F);
    auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos, DepClassTy::REQUIRED);
    if (!FnAA.isAssumedNoReturn())
      indicatePessimisticFixpoint();
  }
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA = A.getAAFor<AANoReturn>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(noreturn){ static llvm::Statistic NumIRCS_noreturn = {"attributor", "NumIRCS_noreturn"
, ("Number of " "call site" " marked '" "noreturn" "'")};; ++
(NumIRCS_noreturn); }; }
4761};

4763/// ----------------------- Variable Capturing ---------------------------------

4765/// A class to hold the state of for no-capture attributes.
4766struct AANoCaptureImpl : public AANoCapture {
AANoCaptureImpl(const IRPosition &IRP, Attributor &A) : AANoCapture(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (hasAttr(getAttrKind(), /* IgnoreSubsumingPositions */ true)) {
    indicateOptimisticFixpoint();
    return;
  }
  Function *AnchorScope = getAnchorScope();
  if (isFnInterfaceKind() &&
      (!AnchorScope || !A.isFunctionIPOAmendable(*AnchorScope))) {
    indicatePessimisticFixpoint();
    return;
  }

  // You cannot "capture" null in the default address space.
  if (isa<ConstantPointerNull>(getAssociatedValue()) &&
      getAssociatedValue().getType()->getPointerAddressSpace() == 0) {
    indicateOptimisticFixpoint();
    return;
  }

  const Function *F =
      isArgumentPosition() ? getAssociatedFunction() : AnchorScope;

  // Check what state the associated function can actually capture.
  if (F)
    determineFunctionCaptureCapabilities(getIRPosition(), *F, *this);
  else
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override;

/// see AbstractAttribute::isAssumedNoCaptureMaybeReturned(...).
virtual void
getDeducedAttributes(LLVMContext &Ctx,
                     SmallVectorImpl<Attribute> &Attrs) const override {
  if (!isAssumedNoCaptureMaybeReturned())
    return;

  if (isArgumentPosition()) {
    if (isAssumedNoCapture())
      Attrs.emplace_back(Attribute::get(Ctx, Attribute::NoCapture));
    else if (ManifestInternal)
      Attrs.emplace_back(Attribute::get(Ctx, "no-capture-maybe-returned"));
  }
}

/// Set the NOT_CAPTURED_IN_MEM and NOT_CAPTURED_IN_RET bits in \p Known
/// depending on the ability of the function associated with \p IRP to capture
/// state in memory and through "returning/throwing", respectively.
static void determineFunctionCaptureCapabilities(const IRPosition &IRP,
                                                 const Function &F,
                                                 BitIntegerState &State) {
  // TODO: Once we have memory behavior attributes we should use them here.

  // If we know we cannot communicate or write to memory, we do not care about
  // ptr2int anymore.
  if (F.onlyReadsMemory() && F.doesNotThrow() &&
      F.getReturnType()->isVoidTy()) {
    State.addKnownBits(NO_CAPTURE);
    return;
  }

  // A function cannot capture state in memory if it only reads memory, it can
  // however return/throw state and the state might be influenced by the
  // pointer value, e.g., loading from a returned pointer might reveal a bit.
  if (F.onlyReadsMemory())
    State.addKnownBits(NOT_CAPTURED_IN_MEM);

  // A function cannot communicate state back if it does not through
  // exceptions and doesn not return values.
  if (F.doesNotThrow() && F.getReturnType()->isVoidTy())
    State.addKnownBits(NOT_CAPTURED_IN_RET);

  // Check existing "returned" attributes.
  int ArgNo = IRP.getCalleeArgNo();
  if (F.doesNotThrow() && ArgNo >= 0) {
    for (unsigned u = 0, e = F.arg_size(); u < e; ++u)
      if (F.hasParamAttribute(u, Attribute::Returned)) {
        if (u == unsigned(ArgNo))
          State.removeAssumedBits(NOT_CAPTURED_IN_RET);
        else if (F.onlyReadsMemory())
          State.addKnownBits(NO_CAPTURE);
        else
          State.addKnownBits(NOT_CAPTURED_IN_RET);
        break;
      }
  }
}

/// See AbstractState::getAsStr().
const std::string getAsStr() const override {
  if (isKnownNoCapture())
    return "known not-captured";
  if (isAssumedNoCapture())
    return "assumed not-captured";
  if (isKnownNoCaptureMaybeReturned())
    return "known not-captured-maybe-returned";
  if (isAssumedNoCaptureMaybeReturned())
    return "assumed not-captured-maybe-returned";
  return "assumed-captured";
}
4872};

4874/// Attributor-aware capture tracker.
4875struct AACaptureUseTracker final : public CaptureTracker {

/// Create a capture tracker that can lookup in-flight abstract attributes
/// through the Attributor \p A.
///
/// If a use leads to a potential capture, \p CapturedInMemory is set and the
/// search is stopped. If a use leads to a return instruction,
/// \p CommunicatedBack is set to true and \p CapturedInMemory is not changed.
/// If a use leads to a ptr2int which may capture the value,
/// \p CapturedInInteger is set. If a use is found that is currently assumed
/// "no-capture-maybe-returned", the user is added to the \p PotentialCopies
/// set. All values in \p PotentialCopies are later tracked as well. For every
/// explored use we decrement \p RemainingUsesToExplore. Once it reaches 0,
/// the search is stopped with \p CapturedInMemory and \p CapturedInInteger
/// conservatively set to true.
AACaptureUseTracker(Attributor &A, AANoCapture &NoCaptureAA,
                    const AAIsDead &IsDeadAA, AANoCapture::StateType &State,
                    SmallSetVector<Value *, 4> &PotentialCopies,
                    unsigned &RemainingUsesToExplore)
    : A(A), NoCaptureAA(NoCaptureAA), IsDeadAA(IsDeadAA), State(State),
      PotentialCopies(PotentialCopies),
      RemainingUsesToExplore(RemainingUsesToExplore) {}

/// Determine if \p V maybe captured. *Also updates the state!*
bool valueMayBeCaptured(const Value *V) {
  if (V->getType()->isPointerTy()) {
    PointerMayBeCaptured(V, this);
  } else {
    State.indicatePessimisticFixpoint();
  }
  return State.isAssumed(AANoCapture::NO_CAPTURE_MAYBE_RETURNED);
}

/// See CaptureTracker::tooManyUses().
void tooManyUses() override {
  State.removeAssumedBits(AANoCapture::NO_CAPTURE);
}

bool isDereferenceableOrNull(Value *O, const DataLayout &DL) override {
  if (CaptureTracker::isDereferenceableOrNull(O, DL))
    return true;
  const auto &DerefAA = A.getAAFor<AADereferenceable>(
      NoCaptureAA, IRPosition::value(*O), DepClassTy::OPTIONAL);
  return DerefAA.getAssumedDereferenceableBytes();
}

/// See CaptureTracker::captured(...).
bool captured(const Use *U) override {
  Instruction *UInst = cast<Instruction>(U->getUser());
  LLVM_DEBUG(dbgs() << "Check use: " << *U->get() << " in " << *UInstdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Check use: " << *U->
get() << " in " << *UInst << "\n"; } } while
 (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Check use: " << *U->
get() << " in " << *UInst << "\n"; } } while
 (false);

  // Because we may reuse the tracker multiple times we keep track of the
  // number of explored uses ourselves as well.
  if (RemainingUsesToExplore-- == 0) {
    LLVM_DEBUG(dbgs() << " - too many uses to explore!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << " - too many uses to explore!\n"
; } } while (false);
    return isCapturedIn(/* Memory */ true, /* Integer */ true,
                        /* Return */ true);
  }

  // Deal with ptr2int by following uses.
  if (isa<PtrToIntInst>(UInst)) {
    LLVM_DEBUG(dbgs() << " - ptr2int assume the worst!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << " - ptr2int assume the worst!\n"
; } } while (false);
    return valueMayBeCaptured(UInst);
  }

  // For stores we check if we can follow the value through memory or not.
  if (auto *SI = dyn_cast<StoreInst>(UInst)) {
    if (SI->isVolatile())
      return isCapturedIn(/* Memory */ true, /* Integer */ false,
                          /* Return */ false);
    bool UsedAssumedInformation = false;
    if (!AA::getPotentialCopiesOfStoredValue(
            A, *SI, PotentialCopies, NoCaptureAA, UsedAssumedInformation))
      return isCapturedIn(/* Memory */ true, /* Integer */ false,
                          /* Return */ false);
    // Not captured directly, potential copies will be checked.
    return isCapturedIn(/* Memory */ false, /* Integer */ false,
                        /* Return */ false);
  }

  // Explicitly catch return instructions.
  if (isa<ReturnInst>(UInst)) {
    if (UInst->getFunction() == NoCaptureAA.getAnchorScope())
      return isCapturedIn(/* Memory */ false, /* Integer */ false,
                          /* Return */ true);
    return isCapturedIn(/* Memory */ true, /* Integer */ true,
                        /* Return */ true);
  }

  // For now we only use special logic for call sites. However, the tracker
  // itself knows about a lot of other non-capturing cases already.
  auto *CB = dyn_cast<CallBase>(UInst);
  if (!CB || !CB->isArgOperand(U))
    return isCapturedIn(/* Memory */ true, /* Integer */ true,
                        /* Return */ true);

  unsigned ArgNo = CB->getArgOperandNo(U);
  const IRPosition &CSArgPos = IRPosition::callsite_argument(*CB, ArgNo);
  // If we have a abstract no-capture attribute for the argument we can use
  // it to justify a non-capture attribute here. This allows recursion!
  auto &ArgNoCaptureAA =
      A.getAAFor<AANoCapture>(NoCaptureAA, CSArgPos, DepClassTy::REQUIRED);
  if (ArgNoCaptureAA.isAssumedNoCapture())
    return isCapturedIn(/* Memory */ false, /* Integer */ false,
                        /* Return */ false);
  if (ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
    addPotentialCopy(*CB);
    return isCapturedIn(/* Memory */ false, /* Integer */ false,
                        /* Return */ false);
  }

  // Lastly, we could not find a reason no-capture can be assumed so we don't.
  return isCapturedIn(/* Memory */ true, /* Integer */ true,
                      /* Return */ true);
}

/// Register \p CS as potential copy of the value we are checking.
void addPotentialCopy(CallBase &CB) { PotentialCopies.insert(&CB); }

/// See CaptureTracker::shouldExplore(...).
bool shouldExplore(const Use *U) override {
  // Check liveness and ignore droppable users.
  bool UsedAssumedInformation = false;
  return !U->getUser()->isDroppable() &&
         !A.isAssumedDead(*U, &NoCaptureAA, &IsDeadAA,
                          UsedAssumedInformation);
}

/// Update the state according to \p CapturedInMem, \p CapturedInInt, and
/// \p CapturedInRet, then return the appropriate value for use in the
/// CaptureTracker::captured() interface.
bool isCapturedIn(bool CapturedInMem, bool CapturedInInt,
                  bool CapturedInRet) {
  LLVM_DEBUG(dbgs() << " - captures [Mem " << CapturedInMem << "|Int "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << " - captures [Mem " <<
 CapturedInMem << "|Int " << CapturedInInt <<
 "|Ret " << CapturedInRet << "]\n"; } } while (false
)
                    << CapturedInInt << "|Ret " << CapturedInRet << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << " - captures [Mem " <<
 CapturedInMem << "|Int " << CapturedInInt <<
 "|Ret " << CapturedInRet << "]\n"; } } while (false
);
  if (CapturedInMem)
    State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_MEM);
  if (CapturedInInt)
    State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_INT);
  if (CapturedInRet)
    State.removeAssumedBits(AANoCapture::NOT_CAPTURED_IN_RET);
  return !State.isAssumed(AANoCapture::NO_CAPTURE_MAYBE_RETURNED);
}

5020private:
/// The attributor providing in-flight abstract attributes.
Attributor &A;

/// The abstract attribute currently updated.
AANoCapture &NoCaptureAA;

/// The abstract liveness state.
const AAIsDead &IsDeadAA;

/// The state currently updated.
AANoCapture::StateType &State;

/// Set of potential copies of the tracked value.
SmallSetVector<Value *, 4> &PotentialCopies;

/// Global counter to limit the number of explored uses.
unsigned &RemainingUsesToExplore;
5038};

5040ChangeStatus AANoCaptureImpl::updateImpl(Attributor &A) {
const IRPosition &IRP = getIRPosition();
Value *V = isArgumentPosition() ? IRP.getAssociatedArgument()
                                : &IRP.getAssociatedValue();
if (!V)
  return indicatePessimisticFixpoint();

const Function *F =
    isArgumentPosition() ? IRP.getAssociatedFunction() : IRP.getAnchorScope();
assert(F && "Expected a function!")(static_cast <bool> (F && "Expected a function!"
) ? void (0) : __assert_fail ("F && \"Expected a function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5049, __extension__
 __PRETTY_FUNCTION__));
const IRPosition &FnPos = IRPosition::function(*F);
const auto &IsDeadAA = A.getAAFor<AAIsDead>(*this, FnPos, DepClassTy::NONE);

AANoCapture::StateType T;

// Readonly means we cannot capture through memory.
bool IsKnown;
if (AA::isAssumedReadOnly(A, FnPos, *this, IsKnown)) {
  T.addKnownBits(NOT_CAPTURED_IN_MEM);
  if (IsKnown)
    addKnownBits(NOT_CAPTURED_IN_MEM);
}

// Make sure all returned values are different than the underlying value.
// TODO: we could do this in a more sophisticated way inside
//       AAReturnedValues, e.g., track all values that escape through returns
//       directly somehow.
auto CheckReturnedArgs = [&](const AAReturnedValues &RVAA) {
  bool SeenConstant = false;
  for (auto &It : RVAA.returned_values()) {
    if (isa<Constant>(It.first)) {
      if (SeenConstant)
        return false;
      SeenConstant = true;
    } else if (!isa<Argument>(It.first) ||
               It.first == getAssociatedArgument())
      return false;
  }
  return true;
};

const auto &NoUnwindAA =
    A.getAAFor<AANoUnwind>(*this, FnPos, DepClassTy::OPTIONAL);
if (NoUnwindAA.isAssumedNoUnwind()) {
  bool IsVoidTy = F->getReturnType()->isVoidTy();
  const AAReturnedValues *RVAA =
      IsVoidTy ? nullptr
               : &A.getAAFor<AAReturnedValues>(*this, FnPos,

                                               DepClassTy::OPTIONAL);
  if (IsVoidTy || CheckReturnedArgs(*RVAA)) {
    T.addKnownBits(NOT_CAPTURED_IN_RET);
    if (T.isKnown(NOT_CAPTURED_IN_MEM))
      return ChangeStatus::UNCHANGED;
    if (NoUnwindAA.isKnownNoUnwind() &&
        (IsVoidTy || RVAA->getState().isAtFixpoint())) {
      addKnownBits(NOT_CAPTURED_IN_RET);
      if (isKnown(NOT_CAPTURED_IN_MEM))
        return indicateOptimisticFixpoint();
    }
  }
}

// Use the CaptureTracker interface and logic with the specialized tracker,
// defined in AACaptureUseTracker, that can look at in-flight abstract
// attributes and directly updates the assumed state.
SmallSetVector<Value *, 4> PotentialCopies;
unsigned RemainingUsesToExplore =
    getDefaultMaxUsesToExploreForCaptureTracking();
AACaptureUseTracker Tracker(A, *this, IsDeadAA, T, PotentialCopies,
                            RemainingUsesToExplore);

// Check all potential copies of the associated value until we can assume
// none will be captured or we have to assume at least one might be.
unsigned Idx = 0;
PotentialCopies.insert(V);
while (T.isAssumed(NO_CAPTURE_MAYBE_RETURNED) && Idx < PotentialCopies.size())
  Tracker.valueMayBeCaptured(PotentialCopies[Idx++]);

AANoCapture::StateType &S = getState();
auto Assumed = S.getAssumed();
S.intersectAssumedBits(T.getAssumed());
if (!isAssumedNoCaptureMaybeReturned())
  return indicatePessimisticFixpoint();
return Assumed == S.getAssumed() ? ChangeStatus::UNCHANGED
                                 : ChangeStatus::CHANGED;
5126}

5128/// NoCapture attribute for function arguments.
5129struct AANoCaptureArgument final : AANoCaptureImpl {
AANoCaptureArgument(const IRPosition &IRP, Attributor &A)
    : AANoCaptureImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(nocapture){ static llvm::Statistic NumIRArguments_nocapture = {"attributor"
, "NumIRArguments_nocapture", ("Number of " "arguments" " marked '"
 "nocapture" "'")};; ++(NumIRArguments_nocapture); } }
5135};

5137/// NoCapture attribute for call site arguments.
5138struct AANoCaptureCallSiteArgument final : AANoCaptureImpl {
AANoCaptureCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AANoCaptureImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (Argument *Arg = getAssociatedArgument())
    if (Arg->hasByValAttr())
      indicateOptimisticFixpoint();
  AANoCaptureImpl::initialize(A);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Argument *Arg = getAssociatedArgument();
  if (!Arg)
    return indicatePessimisticFixpoint();
  const IRPosition &ArgPos = IRPosition::argument(*Arg);
  auto &ArgAA = A.getAAFor<AANoCapture>(*this, ArgPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), ArgAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override{STATS_DECLTRACK_CSARG_ATTR(nocapture){ static llvm::Statistic NumIRCSArguments_nocapture = {"attributor"
, "NumIRCSArguments_nocapture", ("Number of " "call site arguments"
 " marked '" "nocapture" "'")};; ++(NumIRCSArguments_nocapture
); }};
5166};

5168/// NoCapture attribute for floating values.
5169struct AANoCaptureFloating final : AANoCaptureImpl {
AANoCaptureFloating(const IRPosition &IRP, Attributor &A)
    : AANoCaptureImpl(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(nocapture){ static llvm::Statistic NumIRFloating_nocapture = {"attributor"
, "NumIRFloating_nocapture", ("Number of floating values known to be '"
 "nocapture" "'")};; ++(NumIRFloating_nocapture); }
}
5177};

5179/// NoCapture attribute for function return value.
5180struct AANoCaptureReturned final : AANoCaptureImpl {
AANoCaptureReturned(const IRPosition &IRP, Attributor &A)
    : AANoCaptureImpl(IRP, A) {
  llvm_unreachable("NoCapture is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoCapture is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5183);
}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  llvm_unreachable("NoCapture is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoCapture is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5188);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable("NoCapture is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoCapture is not applicable to function returns!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5193);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}
5198};

5200/// NoCapture attribute deduction for a call site return value.
5201struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
AANoCaptureCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AANoCaptureImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  const Function *F = getAnchorScope();
  // Check what state the associated function can actually capture.
  determineFunctionCaptureCapabilities(getIRPosition(), *F, *this);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSRET_ATTR(nocapture){ static llvm::Statistic NumIRCSReturn_nocapture = {"attributor"
, "NumIRCSReturn_nocapture", ("Number of " "call site returns"
 " marked '" "nocapture" "'")};; ++(NumIRCSReturn_nocapture);
 }
}
5216};

5218/// ------------------ Value Simplify Attribute ----------------------------

5220bool ValueSimplifyStateType::unionAssumed(Optional<Value *> Other) {
// FIXME: Add a typecast support.
SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
    SimplifiedAssociatedValue, Other, Ty);
if (SimplifiedAssociatedValue == Optional<Value *>(nullptr))
  return false;

LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
  if (SimplifiedAssociatedValue.hasValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
    dbgs() << "[ValueSimplify] is assumed to be "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
           << **SimplifiedAssociatedValue << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
  elsedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
    dbgs() << "[ValueSimplify] is assumed to be <none>\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (SimplifiedAssociatedValue.hasValue())
 dbgs() << "[ValueSimplify] is assumed to be " <<
 **SimplifiedAssociatedValue << "\n"; else dbgs() <<
 "[ValueSimplify] is assumed to be <none>\n"; }; } } while
 (false);
return true;
5235}

5237struct AAValueSimplifyImpl : AAValueSimplify {
AAValueSimplifyImpl(const IRPosition &IRP, Attributor &A)
    : AAValueSimplify(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (getAssociatedValue().getType()->isVoidTy())
    indicatePessimisticFixpoint();
  if (A.hasSimplificationCallback(getIRPosition()))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { errs() << "SAV: " << SimplifiedAssociatedValue
 << " "; if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue
) errs() << "SAV: " << **SimplifiedAssociatedValue
 << " "; }; } } while (false)
    errs() << "SAV: " << SimplifiedAssociatedValue << " ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { errs() << "SAV: " << SimplifiedAssociatedValue
 << " "; if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue
) errs() << "SAV: " << **SimplifiedAssociatedValue
 << " "; }; } } while (false)
    if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { errs() << "SAV: " << SimplifiedAssociatedValue
 << " "; if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue
) errs() << "SAV: " << **SimplifiedAssociatedValue
 << " "; }; } } while (false)
      errs() << "SAV: " << **SimplifiedAssociatedValue << " ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { errs() << "SAV: " << SimplifiedAssociatedValue
 << " "; if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue
) errs() << "SAV: " << **SimplifiedAssociatedValue
 << " "; }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { errs() << "SAV: " << SimplifiedAssociatedValue
 << " "; if (SimplifiedAssociatedValue && *SimplifiedAssociatedValue
) errs() << "SAV: " << **SimplifiedAssociatedValue
 << " "; }; } } while (false);
  return isValidState() ? (isAtFixpoint() ? "simplified" : "maybe-simple")
                        : "not-simple";
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}

/// See AAValueSimplify::getAssumedSimplifiedValue()
Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
  return SimplifiedAssociatedValue;
}

/// Return a value we can use as replacement for the associated one, or
/// nullptr if we don't have one that makes sense.
Value *getReplacementValue(Attributor &A) const {
  Value *NewV;
  NewV = SimplifiedAssociatedValue.hasValue()
             ? SimplifiedAssociatedValue.getValue()
             : UndefValue::get(getAssociatedType());
  if (!NewV)
    return nullptr;
  NewV = AA::getWithType(*NewV, *getAssociatedType());
  if (!NewV || NewV == &getAssociatedValue())
    return nullptr;
  const Instruction *CtxI = getCtxI();
  if (CtxI && !AA::isValidAtPosition(*NewV, *CtxI, A.getInfoCache()))
    return nullptr;
  if (!CtxI && !AA::isValidInScope(*NewV, getAnchorScope()))
    return nullptr;
  return NewV;
}

/// Helper function for querying AAValueSimplify and updating candicate.
/// \param IRP The value position we are trying to unify with SimplifiedValue
bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                    const IRPosition &IRP, bool Simplify = true) {
  bool UsedAssumedInformation = false;
  Optional<Value *> QueryingValueSimplified = &IRP.getAssociatedValue();
  if (Simplify)
    QueryingValueSimplified =
        A.getAssumedSimplified(IRP, QueryingAA, UsedAssumedInformation);
  return unionAssumed(QueryingValueSimplified);
}

/// Returns a candidate is found or not
template <typename AAType> bool askSimplifiedValueFor(Attributor &A) {
  if (!getAssociatedValue().getType()->isIntegerTy())
    return false;

  // This will also pass the call base context.
  const auto &AA =
      A.getAAFor<AAType>(*this, getIRPosition(), DepClassTy::NONE);

  Optional<ConstantInt *> COpt = AA.getAssumedConstantInt(A);

  if (!COpt.hasValue()) {
    SimplifiedAssociatedValue = llvm::None;
    A.recordDependence(AA, *this, DepClassTy::OPTIONAL);
    return true;
  }
  if (auto *C = COpt.getValue()) {
    SimplifiedAssociatedValue = C;
    A.recordDependence(AA, *this, DepClassTy::OPTIONAL);
    return true;
  }
  return false;
}

bool askSimplifiedValueForOtherAAs(Attributor &A) {
  if (askSimplifiedValueFor<AAValueConstantRange>(A))
    return true;
  if (askSimplifiedValueFor<AAPotentialValues>(A))
    return true;
  return false;
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = ChangeStatus::UNCHANGED;
  if (getAssociatedValue().user_empty())
    return Changed;

  if (auto *NewV = getReplacementValue(A)) {
    LLVM_DEBUG(dbgs() << "[ValueSimplify] " << getAssociatedValue() << " -> "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 getAssociatedValue() << " -> " << *NewV <<
 " :: " << *this << "\n"; } } while (false)
                      << *NewV << " :: " << *this << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 getAssociatedValue() << " -> " << *NewV <<
 " :: " << *this << "\n"; } } while (false);
    if (A.changeValueAfterManifest(getAssociatedValue(), *NewV))
      Changed = ChangeStatus::CHANGED;
  }

  return Changed | AAValueSimplify::manifest(A);
}

/// See AbstractState::indicatePessimisticFixpoint(...).
ChangeStatus indicatePessimisticFixpoint() override {
  SimplifiedAssociatedValue = &getAssociatedValue();
  return AAValueSimplify::indicatePessimisticFixpoint();
}

static bool handleLoad(Attributor &A, const AbstractAttribute &AA,
                       LoadInst &L, function_ref<bool(Value &)> Union) {
  auto UnionWrapper = [&](Value &V, Value &Obj) {
    if (isa<AllocaInst>(Obj))
      return Union(V);
    if (!AA::isDynamicallyUnique(A, AA, V))
      return false;
    if (!AA::isValidAtPosition(V, L, A.getInfoCache()))
      return false;
    return Union(V);
  };

  Value &Ptr = *L.getPointerOperand();
  SmallVector<Value *, 8> Objects;
  bool UsedAssumedInformation = false;
  if (!AA::getAssumedUnderlyingObjects(A, Ptr, Objects, AA, &L,
                                       UsedAssumedInformation))
    return false;

  const auto *TLI =
      A.getInfoCache().getTargetLibraryInfoForFunction(*L.getFunction());
  for (Value *Obj : Objects) {
    LLVM_DEBUG(dbgs() << "Visit underlying object " << *Obj << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Visit underlying object " <<
 *Obj << "\n"; } } while (false);
    if (isa<UndefValue>(Obj))
      continue;
    if (isa<ConstantPointerNull>(Obj)) {
      // A null pointer access can be undefined but any offset from null may
      // be OK. We do not try to optimize the latter.
      if (!NullPointerIsDefined(L.getFunction(),
                                Ptr.getType()->getPointerAddressSpace()) &&
          A.getAssumedSimplified(Ptr, AA, UsedAssumedInformation) == Obj)
        continue;
      return false;
    }
    Constant *InitialVal = AA::getInitialValueForObj(*Obj, *L.getType(), TLI);
    if (!InitialVal || !Union(*InitialVal))
      return false;

    LLVM_DEBUG(dbgs() << "Underlying object amenable to load-store "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Underlying object amenable to load-store "
 "propagation, checking accesses next.\n"; } } while (false)
                         "propagation, checking accesses next.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Underlying object amenable to load-store "
 "propagation, checking accesses next.\n"; } } while (false);

    auto CheckAccess = [&](const AAPointerInfo::Access &Acc, bool IsExact) {
      LLVM_DEBUG(dbgs() << " - visit access " << Acc << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << " - visit access " <<
 Acc << "\n"; } } while (false);
      if (Acc.isWrittenValueYetUndetermined())
        return true;
      Value *Content = Acc.getWrittenValue();
      if (!Content)
        return false;
      Value *CastedContent =
          AA::getWithType(*Content, *AA.getAssociatedType());
      if (!CastedContent)
        return false;
      if (IsExact)
        return UnionWrapper(*CastedContent, *Obj);
      if (auto *C = dyn_cast<Constant>(CastedContent))
        if (C->isNullValue() || C->isAllOnesValue() || isa<UndefValue>(C))
          return UnionWrapper(*CastedContent, *Obj);
      return false;
    };

    auto &PI = A.getAAFor<AAPointerInfo>(AA, IRPosition::value(*Obj),
                                         DepClassTy::REQUIRED);
    if (!PI.forallInterferingWrites(A, AA, L, CheckAccess))
      return false;
  }
  return true;
}
5421};

5423struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
AAValueSimplifyArgument(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyImpl(IRP, A) {}

void initialize(Attributor &A) override {
  AAValueSimplifyImpl::initialize(A);
  if (!getAnchorScope() || getAnchorScope()->isDeclaration())
    indicatePessimisticFixpoint();
  if (hasAttr({Attribute::InAlloca, Attribute::Preallocated,
               Attribute::StructRet, Attribute::Nest, Attribute::ByVal},
              /* IgnoreSubsumingPositions */ true))
    indicatePessimisticFixpoint();

  // FIXME: This is a hack to prevent us from propagating function poiner in
  // the new pass manager CGSCC pass as it creates call edges the
  // CallGraphUpdater cannot handle yet.
  Value &V = getAssociatedValue();
  if (V.getType()->isPointerTy() &&
      V.getType()->getPointerElementType()->isFunctionTy() &&
      !A.isModulePass())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // Byval is only replacable if it is readonly otherwise we would write into
  // the replaced value and not the copy that byval creates implicitly.
  Argument *Arg = getAssociatedArgument();
  if (Arg->hasByValAttr()) {
    // TODO: We probably need to verify synchronization is not an issue, e.g.,
    //       there is no race by not copying a constant byval.
    bool IsKnown;
    if (!AA::isAssumedReadOnly(A, getIRPosition(), *this, IsKnown))
      return indicatePessimisticFixpoint();
  }

  auto Before = SimplifiedAssociatedValue;

  auto PredForCallSite = [&](AbstractCallSite ACS) {
    const IRPosition &ACSArgPos =
        IRPosition::callsite_argument(ACS, getCallSiteArgNo());
    // Check if a coresponding argument was found or if it is on not
    // associated (which can happen for callback calls).
    if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
      return false;

    // Simplify the argument operand explicitly and check if the result is
    // valid in the current scope. This avoids refering to simplified values
    // in other functions, e.g., we don't want to say a an argument in a
    // static function is actually an argument in a different function.
    bool UsedAssumedInformation = false;
    Optional<Constant *> SimpleArgOp =
        A.getAssumedConstant(ACSArgPos, *this, UsedAssumedInformation);
    if (!SimpleArgOp.hasValue())
      return true;
    if (!SimpleArgOp.getValue())
      return false;
    if (!AA::isDynamicallyUnique(A, *this, **SimpleArgOp))
      return false;
    return unionAssumed(*SimpleArgOp);
  };

  // Generate a answer specific to a call site context.
  bool Success;
  bool UsedAssumedInformation = false;
  if (hasCallBaseContext() &&
      getCallBaseContext()->getCalledFunction() == Arg->getParent())
    Success = PredForCallSite(
        AbstractCallSite(&getCallBaseContext()->getCalledOperandUse()));
  else
    Success = A.checkForAllCallSites(PredForCallSite, *this, true,
                                     UsedAssumedInformation);

  if (!Success)
    if (!askSimplifiedValueForOtherAAs(A))
      return indicatePessimisticFixpoint();

  // If a candicate was found in this update, return CHANGED.
  return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
                                             : ChangeStatus ::CHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_ARG_ATTR(value_simplify){ static llvm::Statistic NumIRArguments_value_simplify = {"attributor"
, "NumIRArguments_value_simplify", ("Number of " "arguments" " marked '"
 "value_simplify" "'")};; ++(NumIRArguments_value_simplify); }
}
5509};

5511struct AAValueSimplifyReturned : AAValueSimplifyImpl {
AAValueSimplifyReturned(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyImpl(IRP, A) {}

/// See AAValueSimplify::getAssumedSimplifiedValue()
Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
  if (!isValidState())
    return nullptr;
  return SimplifiedAssociatedValue;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto Before = SimplifiedAssociatedValue;

  auto PredForReturned = [&](Value &V) {
    return checkAndUpdate(A, *this,
                          IRPosition::value(V, getCallBaseContext()));
  };

  if (!A.checkForAllReturnedValues(PredForReturned, *this))
    if (!askSimplifiedValueForOtherAAs(A))
      return indicatePessimisticFixpoint();

  // If a candicate was found in this update, return CHANGED.
  return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
                                             : ChangeStatus ::CHANGED;
}

ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = ChangeStatus::UNCHANGED;

  if (auto *NewV = getReplacementValue(A)) {
    auto PredForReturned =
        [&](Value &, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
          for (ReturnInst *RI : RetInsts) {
            Value *ReturnedVal = RI->getReturnValue();
            if (ReturnedVal == NewV || isa<UndefValue>(ReturnedVal))
              return true;
            assert(RI->getFunction() == getAnchorScope() &&(static_cast <bool> (RI->getFunction() == getAnchorScope
() && "ReturnInst in wrong function!") ? void (0) : __assert_fail
 ("RI->getFunction() == getAnchorScope() && \"ReturnInst in wrong function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5551, __extension__
 __PRETTY_FUNCTION__))
                   "ReturnInst in wrong function!")(static_cast <bool> (RI->getFunction() == getAnchorScope
() && "ReturnInst in wrong function!") ? void (0) : __assert_fail
 ("RI->getFunction() == getAnchorScope() && \"ReturnInst in wrong function!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5551, __extension__
 __PRETTY_FUNCTION__));
            LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 *ReturnedVal << " -> " << *NewV << " in "
 << *RI << " :: " << *this << "\n"; }
 } while (false)
                       << "[ValueSimplify] " << *ReturnedVal << " -> "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 *ReturnedVal << " -> " << *NewV << " in "
 << *RI << " :: " << *this << "\n"; }
 } while (false)
                       << *NewV << " in " << *RI << " :: " << *this << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 *ReturnedVal << " -> " << *NewV << " in "
 << *RI << " :: " << *this << "\n"; }
 } while (false);
            if (A.changeUseAfterManifest(RI->getOperandUse(0), *NewV))
              Changed = ChangeStatus::CHANGED;
          }
          return true;
        };
    A.checkForAllReturnedValuesAndReturnInsts(PredForReturned, *this);
  }

  return Changed | AAValueSimplify::manifest(A);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FNRET_ATTR(value_simplify){ static llvm::Statistic NumIRFunctionReturn_value_simplify =
 {"attributor", "NumIRFunctionReturn_value_simplify", ("Number of "
 "function returns" " marked '" "value_simplify" "'")};; ++(NumIRFunctionReturn_value_simplify
); }
}
5570};

5572struct AAValueSimplifyFloating : AAValueSimplifyImpl {
AAValueSimplifyFloating(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAValueSimplifyImpl::initialize(A);
  Value &V = getAnchorValue();

  // TODO: add other stuffs
  if (isa<Constant>(V))
    indicatePessimisticFixpoint();
}

/// Check if \p Cmp is a comparison we can simplify.
///
/// We handle multiple cases, one in which at least one operand is an
/// (assumed) nullptr. If so, try to simplify it using AANonNull on the other
/// operand. Return true if successful, in that case SimplifiedAssociatedValue
/// will be updated.
bool handleCmp(Attributor &A, CmpInst &Cmp) {
  auto Union = [&](Value &V) {
    SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
        SimplifiedAssociatedValue, &V, V.getType());
    return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
  };

  Value *LHS = Cmp.getOperand(0);
  Value *RHS = Cmp.getOperand(1);

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return true;
  if (!SimplifiedLHS.getValue())
    return false;
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return true;
  if (!SimplifiedRHS.getValue())
    return false;
  RHS = *SimplifiedRHS;

  LLVMContext &Ctx = Cmp.getContext();
  // Handle the trivial case first in which we don't even need to think about
  // null or non-null.
  if (LHS == RHS && (Cmp.isTrueWhenEqual() || Cmp.isFalseWhenEqual())) {
    Constant *NewVal =
        ConstantInt::get(Type::getInt1Ty(Ctx), Cmp.isTrueWhenEqual());
    if (!Union(*NewVal))
      return false;
    if (!UsedAssumedInformation)
      indicateOptimisticFixpoint();
    return true;
  }

  // From now on we only handle equalities (==, !=).
  ICmpInst *ICmp = dyn_cast<ICmpInst>(&Cmp);
  if (!ICmp || !ICmp->isEquality())
    return false;

  bool LHSIsNull = isa<ConstantPointerNull>(LHS);
  bool RHSIsNull = isa<ConstantPointerNull>(RHS);
  if (!LHSIsNull && !RHSIsNull)
    return false;

  // Left is the nullptr ==/!= non-nullptr case. We'll use AANonNull on the
  // non-nullptr operand and if we assume it's non-null we can conclude the
  // result of the comparison.
  assert((LHSIsNull || RHSIsNull) &&(static_cast <bool> ((LHSIsNull || RHSIsNull) &&
 "Expected nullptr versus non-nullptr comparison at this point"
) ? void (0) : __assert_fail ("(LHSIsNull || RHSIsNull) && \"Expected nullptr versus non-nullptr comparison at this point\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5649, __extension__
 __PRETTY_FUNCTION__))
         "Expected nullptr versus non-nullptr comparison at this point")(static_cast <bool> ((LHSIsNull || RHSIsNull) &&
 "Expected nullptr versus non-nullptr comparison at this point"
) ? void (0) : __assert_fail ("(LHSIsNull || RHSIsNull) && \"Expected nullptr versus non-nullptr comparison at this point\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5649, __extension__
 __PRETTY_FUNCTION__));

  // The index is the operand that we assume is not null.
  unsigned PtrIdx = LHSIsNull;
  auto &PtrNonNullAA = A.getAAFor<AANonNull>(
      *this, IRPosition::value(*ICmp->getOperand(PtrIdx)),
      DepClassTy::REQUIRED);
  if (!PtrNonNullAA.isAssumedNonNull())
    return false;
  UsedAssumedInformation |= !PtrNonNullAA.isKnownNonNull();

  // The new value depends on the predicate, true for != and false for ==.
  Constant *NewVal = ConstantInt::get(
      Type::getInt1Ty(Ctx), ICmp->getPredicate() == CmpInst::ICMP_NE);
  if (!Union(*NewVal))
    return false;

  if (!UsedAssumedInformation)
    indicateOptimisticFixpoint();

  return true;
}

bool updateWithLoad(Attributor &A, LoadInst &L) {
  auto Union = [&](Value &V) {
    SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
        SimplifiedAssociatedValue, &V, L.getType());
    return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
  };
  return handleLoad(A, *this, L, Union);
}

/// Use the generic, non-optimistic InstSimplfy functionality if we managed to
/// simplify any operand of the instruction \p I. Return true if successful,
/// in that case SimplifiedAssociatedValue will be updated.
bool handleGenericInst(Attributor &A, Instruction &I) {
  bool SomeSimplified = false;
  bool UsedAssumedInformation = false;

  SmallVector<Value *, 8> NewOps(I.getNumOperands());
  int Idx = 0;
  for (Value *Op : I.operands()) {
    const auto &SimplifiedOp =
        A.getAssumedSimplified(IRPosition::value(*Op, getCallBaseContext()),
                               *this, UsedAssumedInformation);
    // If we are not sure about any operand we are not sure about the entire
    // instruction, we'll wait.
    if (!SimplifiedOp.hasValue())
      return true;

    if (SimplifiedOp.getValue())
      NewOps[Idx] = SimplifiedOp.getValue();
    else
      NewOps[Idx] = Op;

    SomeSimplified |= (NewOps[Idx] != Op);
    ++Idx;
  }

  // We won't bother with the InstSimplify interface if we didn't simplify any
  // operand ourselves.
  if (!SomeSimplified)
    return false;

  InformationCache &InfoCache = A.getInfoCache();
  Function *F = I.getFunction();
  const auto *DT =
      InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*F);
  const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
  auto *AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*F);
  OptimizationRemarkEmitter *ORE = nullptr;

  const DataLayout &DL = I.getModule()->getDataLayout();
  SimplifyQuery Q(DL, TLI, DT, AC, &I);
  if (Value *SimplifiedI =
          SimplifyInstructionWithOperands(&I, NewOps, Q, ORE)) {
    SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
        SimplifiedAssociatedValue, SimplifiedI, I.getType());
    return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
  }
  return false;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto Before = SimplifiedAssociatedValue;

  auto VisitValueCB = [&](Value &V, const Instruction *CtxI, bool &,
                          bool Stripped) -> bool {
    auto &AA = A.getAAFor<AAValueSimplify>(
        *this, IRPosition::value(V, getCallBaseContext()),
        DepClassTy::REQUIRED);
    if (!Stripped && this == &AA) {

      if (auto *I = dyn_cast<Instruction>(&V)) {
        if (auto *LI = dyn_cast<LoadInst>(&V))
          if (updateWithLoad(A, *LI))
            return true;
        if (auto *Cmp = dyn_cast<CmpInst>(&V))
          if (handleCmp(A, *Cmp))
            return true;
        if (handleGenericInst(A, *I))
          return true;
      }
      // TODO: Look the instruction and check recursively.

      LLVM_DEBUG(dbgs() << "[ValueSimplify] Can't be stripped more : " << Vdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] Can't be stripped more : "
 << V << "\n"; } } while (false)
                        << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] Can't be stripped more : "
 << V << "\n"; } } while (false);
      return false;
    }
    return checkAndUpdate(A, *this,
                          IRPosition::value(V, getCallBaseContext()));
  };

  bool Dummy = false;
  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<bool>(A, getIRPosition(), *this, Dummy,
                                   VisitValueCB, getCtxI(),
                                   UsedAssumedInformation,
                                   /* UseValueSimplify */ false))
    if (!askSimplifiedValueForOtherAAs(A))
      return indicatePessimisticFixpoint();

  // If a candicate was found in this update, return CHANGED.
  return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
                                             : ChangeStatus ::CHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(value_simplify){ static llvm::Statistic NumIRFloating_value_simplify = {"attributor"
, "NumIRFloating_value_simplify", ("Number of floating values known to be '"
 "value_simplify" "'")};; ++(NumIRFloating_value_simplify); }
}
5781};

5783struct AAValueSimplifyFunction : AAValueSimplifyImpl {
AAValueSimplifyFunction(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  SimplifiedAssociatedValue = nullptr;
  indicateOptimisticFixpoint();
}
/// See AbstractAttribute::initialize(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable(::llvm::llvm_unreachable_internal("AAValueSimplify(Function|CallSite)::updateImpl will not be called"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5795)
      "AAValueSimplify(Function|CallSite)::updateImpl will not be called")::llvm::llvm_unreachable_internal("AAValueSimplify(Function|CallSite)::updateImpl will not be called"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5795);
}
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FN_ATTR(value_simplify){ static llvm::Statistic NumIRFunction_value_simplify = {"attributor"
, "NumIRFunction_value_simplify", ("Number of " "functions" " marked '"
 "value_simplify" "'")};; ++(NumIRFunction_value_simplify); }
}
5801};

5803struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
AAValueSimplifyCallSite(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyFunction(IRP, A) {}
/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CS_ATTR(value_simplify){ static llvm::Statistic NumIRCS_value_simplify = {"attributor"
, "NumIRCS_value_simplify", ("Number of " "call site" " marked '"
 "value_simplify" "'")};; ++(NumIRCS_value_simplify); }
}
5810};

5812struct AAValueSimplifyCallSiteReturned : AAValueSimplifyImpl {
AAValueSimplifyCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyImpl(IRP, A) {}

void initialize(Attributor &A) override {
  AAValueSimplifyImpl::initialize(A);
  if (!getAssociatedFunction())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto Before = SimplifiedAssociatedValue;
  auto &RetAA = A.getAAFor<AAReturnedValues>(
      *this, IRPosition::function(*getAssociatedFunction()),
      DepClassTy::REQUIRED);
  auto PredForReturned =
      [&](Value &RetVal, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
        bool UsedAssumedInformation = false;
        Optional<Value *> CSRetVal = A.translateArgumentToCallSiteContent(
            &RetVal, *cast<CallBase>(getCtxI()), *this,
            UsedAssumedInformation);
        SimplifiedAssociatedValue = AA::combineOptionalValuesInAAValueLatice(
            SimplifiedAssociatedValue, CSRetVal, getAssociatedType());
        return SimplifiedAssociatedValue != Optional<Value *>(nullptr);
      };
  if (!RetAA.checkForAllReturnedValuesAndReturnInsts(PredForReturned))
    if (!askSimplifiedValueForOtherAAs(A))
      return indicatePessimisticFixpoint();
  return Before == SimplifiedAssociatedValue ? ChangeStatus::UNCHANGED
                                             : ChangeStatus ::CHANGED;
}

void trackStatistics() const override {
  STATS_DECLTRACK_CSRET_ATTR(value_simplify){ static llvm::Statistic NumIRCSReturn_value_simplify = {"attributor"
, "NumIRCSReturn_value_simplify", ("Number of " "call site returns"
 " marked '" "value_simplify" "'")};; ++(NumIRCSReturn_value_simplify
); }
}
5848};

5850struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
AAValueSimplifyCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAValueSimplifyFloating(IRP, A) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = ChangeStatus::UNCHANGED;

  if (auto *NewV = getReplacementValue(A)) {
    Use &U = cast<CallBase>(&getAnchorValue())
                 ->getArgOperandUse(getCallSiteArgNo());
    if (A.changeUseAfterManifest(U, *NewV))
      Changed = ChangeStatus::CHANGED;
  }

  return Changed | AAValueSimplify::manifest(A);
}

void trackStatistics() const override {
  STATS_DECLTRACK_CSARG_ATTR(value_simplify){ static llvm::Statistic NumIRCSArguments_value_simplify = {"attributor"
, "NumIRCSArguments_value_simplify", ("Number of " "call site arguments"
 " marked '" "value_simplify" "'")};; ++(NumIRCSArguments_value_simplify
); }
}
5871};

5873/// ----------------------- Heap-To-Stack Conversion ---------------------------
5874struct AAHeapToStackFunction final : public AAHeapToStack {

struct AllocationInfo {
  /// The call that allocates the memory.
  CallBase *const CB;

  /// The library function id for the allocation.
  LibFunc LibraryFunctionId = NotLibFunc;

  /// The status wrt. a rewrite.
  enum {
    STACK_DUE_TO_USE,
    STACK_DUE_TO_FREE,
    INVALID,
  } Status = STACK_DUE_TO_USE;

  /// Flag to indicate if we encountered a use that might free this allocation
  /// but which is not in the deallocation infos.
  bool HasPotentiallyFreeingUnknownUses = false;

  /// The set of free calls that use this allocation.
  SmallPtrSet<CallBase *, 1> PotentialFreeCalls{};
};

struct DeallocationInfo {
  /// The call that deallocates the memory.
  CallBase *const CB;

  /// Flag to indicate if we don't know all objects this deallocation might
  /// free.
  bool MightFreeUnknownObjects = false;

  /// The set of allocation calls that are potentially freed.
  SmallPtrSet<CallBase *, 1> PotentialAllocationCalls{};
};

AAHeapToStackFunction(const IRPosition &IRP, Attributor &A)
    : AAHeapToStack(IRP, A) {}

~AAHeapToStackFunction() {
  // Ensure we call the destructor so we release any memory allocated in the
  // sets.
  for (auto &It : AllocationInfos)
    It.getSecond()->~AllocationInfo();
  for (auto &It : DeallocationInfos)
    It.getSecond()->~DeallocationInfo();
}

void initialize(Attributor &A) override {
  AAHeapToStack::initialize(A);

  const Function *F = getAnchorScope();
  const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);

  auto AllocationIdentifierCB = [&](Instruction &I) {
    CallBase *CB = dyn_cast<CallBase>(&I);
    if (!CB)
      return true;
    if (isFreeCall(CB, TLI)) {
      DeallocationInfos[CB] = new (A.Allocator) DeallocationInfo{CB};
      return true;
    }
    // To do heap to stack, we need to know that the allocation itself is
    // removable once uses are rewritten, and that we can initialize the
    // alloca to the same pattern as the original allocation result.
    if (isAllocationFn(CB, TLI) && isAllocRemovable(CB, TLI)) {
      auto *I8Ty = Type::getInt8Ty(CB->getParent()->getContext());
      if (nullptr != getInitialValueOfAllocation(CB, TLI, I8Ty)) {
        AllocationInfo *AI = new (A.Allocator) AllocationInfo{CB};
        AllocationInfos[CB] = AI;
        TLI->getLibFunc(*CB, AI->LibraryFunctionId);
      }
    }
    return true;
  };

  bool UsedAssumedInformation = false;
  bool Success = A.checkForAllCallLikeInstructions(
      AllocationIdentifierCB, *this, UsedAssumedInformation,
      /* CheckBBLivenessOnly */ false,
      /* CheckPotentiallyDead */ true);
  (void)Success;
  assert(Success && "Did not expect the call base visit callback to fail!")(static_cast <bool> (Success && "Did not expect the call base visit callback to fail!"
) ? void (0) : __assert_fail ("Success && \"Did not expect the call base visit callback to fail!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 5956, __extension__
 __PRETTY_FUNCTION__));
}

const std::string getAsStr() const override {
  unsigned NumH2SMallocs = 0, NumInvalidMallocs = 0;
  for (const auto &It : AllocationInfos) {
    if (It.second->Status == AllocationInfo::INVALID)
      ++NumInvalidMallocs;
    else
      ++NumH2SMallocs;
  }
  return "[H2S] Mallocs Good/Bad: " + std::to_string(NumH2SMallocs) + "/" +
         std::to_string(NumInvalidMallocs);
}

/// See AbstractAttribute::trackStatistics().
void trackStatistics() const override {
  STATS_DECL(static llvm::Statistic NumIRFunction_MallocCalls = {"attributor"
, "NumIRFunction_MallocCalls", "Number of malloc/calloc/aligned_alloc calls converted to allocas"
};;
      MallocCalls, Function,static llvm::Statistic NumIRFunction_MallocCalls = {"attributor"
, "NumIRFunction_MallocCalls", "Number of malloc/calloc/aligned_alloc calls converted to allocas"
};;
      "Number of malloc/calloc/aligned_alloc calls converted to allocas")static llvm::Statistic NumIRFunction_MallocCalls = {"attributor"
, "NumIRFunction_MallocCalls", "Number of malloc/calloc/aligned_alloc calls converted to allocas"
};;;
  for (auto &It : AllocationInfos)
    if (It.second->Status != AllocationInfo::INVALID)
      ++BUILD_STAT_NAME(MallocCalls, Function)NumIRFunction_MallocCalls;
}

bool isAssumedHeapToStack(const CallBase &CB) const override {
  if (isValidState())
    if (AllocationInfo *AI = AllocationInfos.lookup(&CB))
      return AI->Status != AllocationInfo::INVALID;
  return false;
}

bool isAssumedHeapToStackRemovedFree(CallBase &CB) const override {
  if (!isValidState())
    return false;

  for (auto &It : AllocationInfos) {
    AllocationInfo &AI = *It.second;
    if (AI.Status == AllocationInfo::INVALID)
      continue;

    if (AI.PotentialFreeCalls.count(&CB))
      return true;
  }

  return false;
}

ChangeStatus manifest(Attributor &A) override {
  assert(getState().isValidState() &&(static_cast <bool> (getState().isValidState() &&
 "Attempted to manifest an invalid state!") ? void (0) : __assert_fail
 ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6006, __extension__
 __PRETTY_FUNCTION__))
         "Attempted to manifest an invalid state!")(static_cast <bool> (getState().isValidState() &&
 "Attempted to manifest an invalid state!") ? void (0) : __assert_fail
 ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6006, __extension__
 __PRETTY_FUNCTION__));

  ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
  Function *F = getAnchorScope();
  const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);

  for (auto &It : AllocationInfos) {
    AllocationInfo &AI = *It.second;
    if (AI.Status == AllocationInfo::INVALID)
      continue;

    for (CallBase *FreeCall : AI.PotentialFreeCalls) {
      LLVM_DEBUG(dbgs() << "H2S: Removing free call: " << *FreeCall << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "H2S: Removing free call: "
 << *FreeCall << "\n"; } } while (false);
      A.deleteAfterManifest(*FreeCall);
      HasChanged = ChangeStatus::CHANGED;
    }

    LLVM_DEBUG(dbgs() << "H2S: Removing malloc-like call: " << *AI.CBdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "H2S: Removing malloc-like call: "
 << *AI.CB << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "H2S: Removing malloc-like call: "
 << *AI.CB << "\n"; } } while (false);

    auto Remark = [&](OptimizationRemark OR) {
      LibFunc IsAllocShared;
      if (TLI->getLibFunc(*AI.CB, IsAllocShared))
        if (IsAllocShared == LibFunc___kmpc_alloc_shared)
          return OR << "Moving globalized variable to the stack.";
      return OR << "Moving memory allocation from the heap to the stack.";
    };
    if (AI.LibraryFunctionId == LibFunc___kmpc_alloc_shared)
      A.emitRemark<OptimizationRemark>(AI.CB, "OMP110", Remark);
    else
      A.emitRemark<OptimizationRemark>(AI.CB, "HeapToStack", Remark);

    const DataLayout &DL = A.getInfoCache().getDL();
    Value *Size;
    Optional<APInt> SizeAPI = getSize(A, *this, AI);
    if (SizeAPI.hasValue()) {
      Size = ConstantInt::get(AI.CB->getContext(), *SizeAPI);
    } else {
      LLVMContext &Ctx = AI.CB->getContext();
      ObjectSizeOpts Opts;
      ObjectSizeOffsetEvaluator Eval(DL, TLI, Ctx, Opts);
      SizeOffsetEvalType SizeOffsetPair = Eval.compute(AI.CB);
      assert(SizeOffsetPair != ObjectSizeOffsetEvaluator::unknown() &&(static_cast <bool> (SizeOffsetPair != ObjectSizeOffsetEvaluator
::unknown() && cast<ConstantInt>(SizeOffsetPair
.second)->isZero()) ? void (0) : __assert_fail ("SizeOffsetPair != ObjectSizeOffsetEvaluator::unknown() && cast<ConstantInt>(SizeOffsetPair.second)->isZero()"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6049, __extension__
 __PRETTY_FUNCTION__))
             cast<ConstantInt>(SizeOffsetPair.second)->isZero())(static_cast <bool> (SizeOffsetPair != ObjectSizeOffsetEvaluator
::unknown() && cast<ConstantInt>(SizeOffsetPair
.second)->isZero()) ? void (0) : __assert_fail ("SizeOffsetPair != ObjectSizeOffsetEvaluator::unknown() && cast<ConstantInt>(SizeOffsetPair.second)->isZero()"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6049, __extension__
 __PRETTY_FUNCTION__));
      Size = SizeOffsetPair.first;
    }

    Align Alignment(1);
    if (MaybeAlign RetAlign = AI.CB->getRetAlign())
      Alignment = max(Alignment, RetAlign);
    if (Value *Align = getAllocAlignment(AI.CB, TLI)) {
      Optional<APInt> AlignmentAPI = getAPInt(A, *this, *Align);
      assert(AlignmentAPI.hasValue() &&(static_cast <bool> (AlignmentAPI.hasValue() &&
 "Expected an alignment during manifest!") ? void (0) : __assert_fail
 ("AlignmentAPI.hasValue() && \"Expected an alignment during manifest!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6059, __extension__
 __PRETTY_FUNCTION__))
             "Expected an alignment during manifest!")(static_cast <bool> (AlignmentAPI.hasValue() &&
 "Expected an alignment during manifest!") ? void (0) : __assert_fail
 ("AlignmentAPI.hasValue() && \"Expected an alignment during manifest!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6059, __extension__
 __PRETTY_FUNCTION__));
      Alignment =
          max(Alignment, MaybeAlign(AlignmentAPI.getValue().getZExtValue()));
    }

    // TODO: Hoist the alloca towards the function entry.
    unsigned AS = DL.getAllocaAddrSpace();
    Instruction *Alloca = new AllocaInst(Type::getInt8Ty(F->getContext()), AS,
                                         Size, Alignment, "", AI.CB);

    if (Alloca->getType() != AI.CB->getType())
      Alloca = BitCastInst::CreatePointerBitCastOrAddrSpaceCast(
          Alloca, AI.CB->getType(), "malloc_cast", AI.CB);

    auto *I8Ty = Type::getInt8Ty(F->getContext());
    auto *InitVal = getInitialValueOfAllocation(AI.CB, TLI, I8Ty);
    assert(InitVal &&(static_cast <bool> (InitVal && "Must be able to materialize initial memory state of allocation"
) ? void (0) : __assert_fail ("InitVal && \"Must be able to materialize initial memory state of allocation\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6076, __extension__
 __PRETTY_FUNCTION__))
           "Must be able to materialize initial memory state of allocation")(static_cast <bool> (InitVal && "Must be able to materialize initial memory state of allocation"
) ? void (0) : __assert_fail ("InitVal && \"Must be able to materialize initial memory state of allocation\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6076, __extension__
 __PRETTY_FUNCTION__));

    A.changeValueAfterManifest(*AI.CB, *Alloca);

    if (auto *II = dyn_cast<InvokeInst>(AI.CB)) {
      auto *NBB = II->getNormalDest();
      BranchInst::Create(NBB, AI.CB->getParent());
      A.deleteAfterManifest(*AI.CB);
    } else {
      A.deleteAfterManifest(*AI.CB);
    }

    // Initialize the alloca with the same value as used by the allocation
    // function.  We can skip undef as the initial value of an alloc is
    // undef, and the memset would simply end up being DSEd.
    if (!isa<UndefValue>(InitVal)) {
      IRBuilder<> Builder(Alloca->getNextNode());
      // TODO: Use alignment above if align!=1
      Builder.CreateMemSet(Alloca, InitVal, Size, None);
    }
    HasChanged = ChangeStatus::CHANGED;
  }

  return HasChanged;
}

Optional<APInt> getAPInt(Attributor &A, const AbstractAttribute &AA,
                         Value &V) {
  bool UsedAssumedInformation = false;
  Optional<Constant *> SimpleV =
      A.getAssumedConstant(V, AA, UsedAssumedInformation);
  if (!SimpleV.hasValue())
    return APInt(64, 0);
  if (auto *CI = dyn_cast_or_null<ConstantInt>(SimpleV.getValue()))
    return CI->getValue();
  return llvm::None;
}

Optional<APInt> getSize(Attributor &A, const AbstractAttribute &AA,
                        AllocationInfo &AI) {
  auto Mapper = [&](const Value *V) -> const Value * {
    bool UsedAssumedInformation = false;
    if (Optional<Constant *> SimpleV =
            A.getAssumedConstant(*V, AA, UsedAssumedInformation))
      if (*SimpleV)
        return *SimpleV;
    return V;
  };

  const Function *F = getAnchorScope();
  const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
  return getAllocSize(AI.CB, TLI, Mapper);
}

/// Collection of all malloc-like calls in a function with associated
/// information.
DenseMap<CallBase *, AllocationInfo *> AllocationInfos;

/// Collection of all free-like calls in a function with associated
/// information.
DenseMap<CallBase *, DeallocationInfo *> DeallocationInfos;

ChangeStatus updateImpl(Attributor &A) override;
6139};

6141ChangeStatus AAHeapToStackFunction::updateImpl(Attributor &A) {
ChangeStatus Changed = ChangeStatus::UNCHANGED;
const Function *F = getAnchorScope();
const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);

const auto &LivenessAA =
    A.getAAFor<AAIsDead>(*this, IRPosition::function(*F), DepClassTy::NONE);

MustBeExecutedContextExplorer &Explorer =
    A.getInfoCache().getMustBeExecutedContextExplorer();

bool StackIsAccessibleByOtherThreads =
    A.getInfoCache().stackIsAccessibleByOtherThreads();

// Flag to ensure we update our deallocation information at most once per
// updateImpl call and only if we use the free check reasoning.
bool HasUpdatedFrees = false;

auto UpdateFrees = [&]() {
  HasUpdatedFrees = true;

  for (auto &It : DeallocationInfos) {
    DeallocationInfo &DI = *It.second;
    // For now we cannot use deallocations that have unknown inputs, skip
    // them.
    if (DI.MightFreeUnknownObjects)
      continue;

    // No need to analyze dead calls, ignore them instead.
    bool UsedAssumedInformation = false;
    if (A.isAssumedDead(*DI.CB, this, &LivenessAA, UsedAssumedInformation,
                        /* CheckBBLivenessOnly */ true))
      continue;

    // Use the optimistic version to get the freed objects, ignoring dead
    // branches etc.
    SmallVector<Value *, 8> Objects;
    if (!AA::getAssumedUnderlyingObjects(A, *DI.CB->getArgOperand(0), Objects,
                                         *this, DI.CB,
                                         UsedAssumedInformation)) {
      LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unexpected failure in getAssumedUnderlyingObjects!\n"
; } } while (false)
          dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unexpected failure in getAssumedUnderlyingObjects!\n"
; } } while (false)
          << "[H2S] Unexpected failure in getAssumedUnderlyingObjects!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unexpected failure in getAssumedUnderlyingObjects!\n"
; } } while (false);
      DI.MightFreeUnknownObjects = true;
      continue;
    }

    // Check each object explicitly.
    for (auto *Obj : Objects) {
      // Free of null and undef can be ignored as no-ops (or UB in the latter
      // case).
      if (isa<ConstantPointerNull>(Obj) || isa<UndefValue>(Obj))
        continue;

      CallBase *ObjCB = dyn_cast<CallBase>(Obj);
      if (!ObjCB) {
        LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Free of a non-call object: "
 << *Obj << "\n"; } } while (false)
                   << "[H2S] Free of a non-call object: " << *Obj << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Free of a non-call object: "
 << *Obj << "\n"; } } while (false);
        DI.MightFreeUnknownObjects = true;
        continue;
      }

      AllocationInfo *AI = AllocationInfos.lookup(ObjCB);
      if (!AI) {
        LLVM_DEBUG(dbgs() << "[H2S] Free of a non-allocation object: " << *Objdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Free of a non-allocation object: "
 << *Obj << "\n"; } } while (false)
                          << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Free of a non-allocation object: "
 << *Obj << "\n"; } } while (false);
        DI.MightFreeUnknownObjects = true;
        continue;
      }

      DI.PotentialAllocationCalls.insert(ObjCB);
    }
  }
};

auto FreeCheck = [&](AllocationInfo &AI) {
  // If the stack is not accessible by other threads, the "must-free" logic
  // doesn't apply as the pointer could be shared and needs to be places in
  // "shareable" memory.
  if (!StackIsAccessibleByOtherThreads) {
    auto &NoSyncAA =
        A.getAAFor<AANoSync>(*this, getIRPosition(), DepClassTy::OPTIONAL);
    if (!NoSyncAA.isAssumedNoSync()) {
      LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] found an escaping use, stack is not accessible by "
 "other threads and function is not nosync:\n"; } } while (false
)
          dbgs() << "[H2S] found an escaping use, stack is not accessible by "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] found an escaping use, stack is not accessible by "
 "other threads and function is not nosync:\n"; } } while (false
)
                    "other threads and function is not nosync:\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] found an escaping use, stack is not accessible by "
 "other threads and function is not nosync:\n"; } } while (false
);
      return false;
    }
  }
  if (!HasUpdatedFrees)
    UpdateFrees();

  // TODO: Allow multi exit functions that have different free calls.
  if (AI.PotentialFreeCalls.size() != 1) {
    LLVM_DEBUG(dbgs() << "[H2S] did not find one free call but "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] did not find one free call but "
 << AI.PotentialFreeCalls.size() << "\n"; } } while
 (false)
                      << AI.PotentialFreeCalls.size() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] did not find one free call but "
 << AI.PotentialFreeCalls.size() << "\n"; } } while
 (false);
    return false;
  }
  CallBase *UniqueFree = *AI.PotentialFreeCalls.begin();
  DeallocationInfo *DI = DeallocationInfos.lookup(UniqueFree);
  if (!DI) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call was not known as deallocation call "
 << *UniqueFree << "\n"; } } while (false)
        dbgs() << "[H2S] unique free call was not known as deallocation call "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call was not known as deallocation call "
 << *UniqueFree << "\n"; } } while (false)
               << *UniqueFree << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call was not known as deallocation call "
 << *UniqueFree << "\n"; } } while (false);
    return false;
  }
  if (DI->MightFreeUnknownObjects) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might free unknown allocations\n"
; } } while (false)
        dbgs() << "[H2S] unique free call might free unknown allocations\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might free unknown allocations\n"
; } } while (false);
    return false;
  }
  if (DI->PotentialAllocationCalls.size() > 1) {
    LLVM_DEBUG(dbgs() << "[H2S] unique free call might free "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might free "
 << DI->PotentialAllocationCalls.size() << " different allocations\n"
; } } while (false)
                      << DI->PotentialAllocationCalls.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might free "
 << DI->PotentialAllocationCalls.size() << " different allocations\n"
; } } while (false)
                      << " different allocations\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might free "
 << DI->PotentialAllocationCalls.size() << " different allocations\n"
; } } while (false);
    return false;
  }
  if (*DI->PotentialAllocationCalls.begin() != AI.CB) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call not known to free this allocation but "
 << **DI->PotentialAllocationCalls.begin() << "\n"
; } } while (false)
        dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call not known to free this allocation but "
 << **DI->PotentialAllocationCalls.begin() << "\n"
; } } while (false)
        << "[H2S] unique free call not known to free this allocation but "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call not known to free this allocation but "
 << **DI->PotentialAllocationCalls.begin() << "\n"
; } } while (false)
        << **DI->PotentialAllocationCalls.begin() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call not known to free this allocation but "
 << **DI->PotentialAllocationCalls.begin() << "\n"
; } } while (false);
    return false;
  }
  Instruction *CtxI = isa<InvokeInst>(AI.CB) ? AI.CB : AI.CB->getNextNode();
  if (!Explorer.findInContextOf(UniqueFree, CtxI)) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might not be executed with the allocation "
 << *UniqueFree << "\n"; } } while (false)
        dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might not be executed with the allocation "
 << *UniqueFree << "\n"; } } while (false)
        << "[H2S] unique free call might not be executed with the allocation "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might not be executed with the allocation "
 << *UniqueFree << "\n"; } } while (false)
        << *UniqueFree << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] unique free call might not be executed with the allocation "
 << *UniqueFree << "\n"; } } while (false);
    return false;
  }
  return true;
};

auto UsesCheck = [&](AllocationInfo &AI) {
  bool ValidUsesOnly = true;

  auto Pred = [&](const Use &U, bool &Follow) -> bool {
    Instruction *UserI = cast<Instruction>(U.getUser());
    if (isa<LoadInst>(UserI))
      return true;
    if (auto *SI = dyn_cast<StoreInst>(UserI)) {
      if (SI->getValueOperand() == U.get()) {
        LLVM_DEBUG(dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] escaping store to memory: "
 << *UserI << "\n"; } } while (false)
                   << "[H2S] escaping store to memory: " << *UserI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] escaping store to memory: "
 << *UserI << "\n"; } } while (false);
        ValidUsesOnly = false;
      } else {
        // A store into the malloc'ed memory is fine.
      }
      return true;
    }
    if (auto *CB = dyn_cast<CallBase>(UserI)) {
      if (!CB->isArgOperand(&U) || CB->isLifetimeStartOrEnd())
        return true;
      if (DeallocationInfos.count(CB)) {
        AI.PotentialFreeCalls.insert(CB);
        return true;
      }

      unsigned ArgNo = CB->getArgOperandNo(&U);

      const auto &NoCaptureAA = A.getAAFor<AANoCapture>(
          *this, IRPosition::callsite_argument(*CB, ArgNo),
          DepClassTy::OPTIONAL);

      // If a call site argument use is nofree, we are fine.
      const auto &ArgNoFreeAA = A.getAAFor<AANoFree>(
          *this, IRPosition::callsite_argument(*CB, ArgNo),
          DepClassTy::OPTIONAL);

      bool MaybeCaptured = !NoCaptureAA.isAssumedNoCapture();
      bool MaybeFreed = !ArgNoFreeAA.isAssumedNoFree();
      if (MaybeCaptured ||
          (AI.LibraryFunctionId != LibFunc___kmpc_alloc_shared &&
           MaybeFreed)) {
        AI.HasPotentiallyFreeingUnknownUses |= MaybeFreed;

        // Emit a missed remark if this is missed OpenMP globalization.
        auto Remark = [&](OptimizationRemarkMissed ORM) {
          return ORM
                 << "Could not move globalized variable to the stack. "
                    "Variable is potentially captured in call. Mark "
                    "parameter as `__attribute__((noescape))` to override.";
        };

        if (ValidUsesOnly &&
            AI.LibraryFunctionId == LibFunc___kmpc_alloc_shared)
          A.emitRemark<OptimizationRemarkMissed>(CB, "OMP113", Remark);

        LLVM_DEBUG(dbgs() << "[H2S] Bad user: " << *UserI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Bad user: " <<
 *UserI << "\n"; } } while (false);
        ValidUsesOnly = false;
      }
      return true;
    }

    if (isa<GetElementPtrInst>(UserI) || isa<BitCastInst>(UserI) ||
        isa<PHINode>(UserI) || isa<SelectInst>(UserI)) {
      Follow = true;
      return true;
    }
    // Unknown user for which we can not track uses further (in a way that
    // makes sense).
    LLVM_DEBUG(dbgs() << "[H2S] Unknown user: " << *UserI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unknown user: " <<
 *UserI << "\n"; } } while (false);
    ValidUsesOnly = false;
    return true;
  };
  if (!A.checkForAllUses(Pred, *this, *AI.CB))
    return false;
  return ValidUsesOnly;
};

// The actual update starts here. We look at all allocations and depending on
// their status perform the appropriate check(s).
for (auto &It : AllocationInfos) {
  AllocationInfo &AI = *It.second;
  if (AI.Status == AllocationInfo::INVALID)
    continue;

  if (Value *Align = getAllocAlignment(AI.CB, TLI)) {
    Optional<APInt> APAlign = getAPInt(A, *this, *Align);
    if (!APAlign) {
      // Can't generate an alloca which respects the required alignment
      // on the allocation.
      LLVM_DEBUG(dbgs() << "[H2S] Unknown allocation alignment: " << *AI.CBdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unknown allocation alignment: "
 << *AI.CB << "\n"; } } while (false)
                        << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Unknown allocation alignment: "
 << *AI.CB << "\n"; } } while (false);
      AI.Status = AllocationInfo::INVALID;
      Changed = ChangeStatus::CHANGED;
      continue;
    } else {
      if (APAlign->ugt(llvm::Value::MaximumAlignment) || !APAlign->isPowerOf2()) {
        LLVM_DEBUG(dbgs() << "[H2S] Invalid allocation alignment: " << APAlign << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] Invalid allocation alignment: "
 << APAlign << "\n"; } } while (false);
        AI.Status = AllocationInfo::INVALID;
        Changed = ChangeStatus::CHANGED;
        continue;
      }
    }
  }

  if (MaxHeapToStackSize != -1) {
    Optional<APInt> Size = getSize(A, *this, AI);
    if (!Size.hasValue() || Size.getValue().ugt(MaxHeapToStackSize)) {
      LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
        if (!Size.hasValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
          dbgs() << "[H2S] Unknown allocation size: " << *AI.CB << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
        elsedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
          dbgs() << "[H2S] Allocation size too large: " << *AI.CB << " vs. "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
                 << MaxHeapToStackSize << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false)
      })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: "
 << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: "
 << *AI.CB << " vs. " << MaxHeapToStackSize
 << "\n"; }; } } while (false);

      AI.Status = AllocationInfo::INVALID;
      Changed = ChangeStatus::CHANGED;
      continue;
    }
  }

  switch (AI.Status) {
  case AllocationInfo::STACK_DUE_TO_USE:
    if (UsesCheck(AI))
      continue;
    AI.Status = AllocationInfo::STACK_DUE_TO_FREE;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];
  case AllocationInfo::STACK_DUE_TO_FREE:
    if (FreeCheck(AI))
      continue;
    AI.Status = AllocationInfo::INVALID;
    Changed = ChangeStatus::CHANGED;
    continue;
  case AllocationInfo::INVALID:
    llvm_unreachable("Invalid allocations should never reach this point!")::llvm::llvm_unreachable_internal("Invalid allocations should never reach this point!"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6410);
  };
}

return Changed;
6415}

6417/// ----------------------- Privatizable Pointers ------------------------------
6418struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
AAPrivatizablePtrImpl(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtr(IRP, A), PrivatizableType(llvm::None) {}

ChangeStatus indicatePessimisticFixpoint() override {
  AAPrivatizablePtr::indicatePessimisticFixpoint();
  PrivatizableType = nullptr;
  return ChangeStatus::CHANGED;
}

/// Identify the type we can chose for a private copy of the underlying
/// argument. None means it is not clear yet, nullptr means there is none.
virtual Optional<Type *> identifyPrivatizableType(Attributor &A) = 0;

/// Return a privatizable type that encloses both T0 and T1.
/// TODO: This is merely a stub for now as we should manage a mapping as well.
Optional<Type *> combineTypes(Optional<Type *> T0, Optional<Type *> T1) {
  if (!T0.hasValue())
    return T1;
  if (!T1.hasValue())
    return T0;
  if (T0 == T1)
    return T0;
  return nullptr;
}

Optional<Type *> getPrivatizableType() const override {
  return PrivatizableType;
}

const std::string getAsStr() const override {
  return isAssumedPrivatizablePtr() ? "[priv]" : "[no-priv]";
}

6452protected:
Optional<Type *> PrivatizableType;
6454};

6456// TODO: Do this for call site arguments (probably also other values) as well.

6458struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
AAPrivatizablePtrArgument(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtrImpl(IRP, A) {}

/// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
Optional<Type *> identifyPrivatizableType(Attributor &A) override {
  // If this is a byval argument and we know all the call sites (so we can
  // rewrite them), there is no need to check them explicitly.
  bool UsedAssumedInformation = false;
  if (getIRPosition().hasAttr(Attribute::ByVal) &&
      A.checkForAllCallSites([](AbstractCallSite ACS) { return true; }, *this,
                             true, UsedAssumedInformation))
    return getAssociatedValue().getType()->getPointerElementType();

  Optional<Type *> Ty;
  unsigned ArgNo = getIRPosition().getCallSiteArgNo();

  // Make sure the associated call site argument has the same type at all call
  // sites and it is an allocation we know is safe to privatize, for now that
  // means we only allow alloca instructions.
  // TODO: We can additionally analyze the accesses in the callee to  create
  //       the type from that information instead. That is a little more
  //       involved and will be done in a follow up patch.
  auto CallSiteCheck = [&](AbstractCallSite ACS) {
    IRPosition ACSArgPos = IRPosition::callsite_argument(ACS, ArgNo);
    // Check if a coresponding argument was found or if it is one not
    // associated (which can happen for callback calls).
    if (ACSArgPos.getPositionKind() == IRPosition::IRP_INVALID)
      return false;

    // Check that all call sites agree on a type.
    auto &PrivCSArgAA =
        A.getAAFor<AAPrivatizablePtr>(*this, ACSArgPos, DepClassTy::REQUIRED);
    Optional<Type *> CSTy = PrivCSArgAA.getPrivatizableType();

    LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
      dbgs() << "[AAPrivatizablePtr] ACSPos: " << ACSArgPos << ", CSTy: ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
      if (CSTy.hasValue() && CSTy.getValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
        CSTy.getValue()->print(dbgs());do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
      else if (CSTy.hasValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
        dbgs() << "<nullptr>";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
      elsedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
        dbgs() << "<none>";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false)
    })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] ACSPos: "
 << ACSArgPos << ", CSTy: "; if (CSTy.hasValue() &&
 CSTy.getValue()) CSTy.getValue()->print(dbgs()); else if (
CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs
() << "<none>"; }; } } while (false);

    Ty = combineTypes(Ty, CSTy);

    LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
      dbgs() << " : New Type: ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
      if (Ty.hasValue() && Ty.getValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
        Ty.getValue()->print(dbgs());do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
      else if (Ty.hasValue())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
        dbgs() << "<nullptr>";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
      elsedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
        dbgs() << "<none>";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
      dbgs() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false)
    })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << " : New Type: "; if (Ty.hasValue
() && Ty.getValue()) Ty.getValue()->print(dbgs());
 else if (Ty.hasValue()) dbgs() << "<nullptr>"; else
 dbgs() << "<none>"; dbgs() << "\n"; }; } }
 while (false);

    return !Ty.hasValue() || Ty.getValue();
  };

  if (!A.checkForAllCallSites(CallSiteCheck, *this, true,
                              UsedAssumedInformation))
    return nullptr;
  return Ty;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  PrivatizableType = identifyPrivatizableType(A);
  if (!PrivatizableType.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!PrivatizableType.getValue())
    return indicatePessimisticFixpoint();

  // The dependence is optional so we don't give up once we give up on the
  // alignment.
  A.getAAFor<AAAlign>(*this, IRPosition::value(getAssociatedValue()),
                      DepClassTy::OPTIONAL);

  // Avoid arguments with padding for now.
  if (!getIRPosition().hasAttr(Attribute::ByVal) &&
      !ArgumentPromotionPass::isDenselyPacked(PrivatizableType.getValue(),
                                              A.getInfoCache().getDL())) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Padding detected\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Padding detected\n"
; } } while (false);
    return indicatePessimisticFixpoint();
  }

  // Collect the types that will replace the privatizable type in the function
  // signature.
  SmallVector<Type *, 16> ReplacementTypes;
  identifyReplacementTypes(PrivatizableType.getValue(), ReplacementTypes);

  // Verify callee and caller agree on how the promoted argument would be
  // passed.
  Function &Fn = *getIRPosition().getAnchorScope();
  const auto *TTI =
      A.getInfoCache().getAnalysisResultForFunction<TargetIRAnalysis>(Fn);
  if (!TTI) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Missing TTI for function "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Missing TTI for function "
 << Fn.getName() << "\n"; } } while (false)
                      << Fn.getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Missing TTI for function "
 << Fn.getName() << "\n"; } } while (false);
    return indicatePessimisticFixpoint();
  }

  auto CallSiteCheck = [&](AbstractCallSite ACS) {
    CallBase *CB = ACS.getInstruction();
    return TTI->areTypesABICompatible(
        CB->getCaller(), CB->getCalledFunction(), ReplacementTypes);
  };
  bool UsedAssumedInformation = false;
  if (!A.checkForAllCallSites(CallSiteCheck, *this, true,
                              UsedAssumedInformation)) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] ABI incompatibility detected for "
 << Fn.getName() << "\n"; } } while (false)
        dbgs() << "[AAPrivatizablePtr] ABI incompatibility detected for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] ABI incompatibility detected for "
 << Fn.getName() << "\n"; } } while (false)
               << Fn.getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] ABI incompatibility detected for "
 << Fn.getName() << "\n"; } } while (false);
    return indicatePessimisticFixpoint();
  }

  // Register a rewrite of the argument.
  Argument *Arg = getAssociatedArgument();
  if (!A.isValidFunctionSignatureRewrite(*Arg, ReplacementTypes)) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Rewrite not valid\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Rewrite not valid\n"
; } } while (false);
    return indicatePessimisticFixpoint();
  }

  unsigned ArgNo = Arg->getArgNo();

  // Helper to check if for the given call site the associated argument is
  // passed to a callback where the privatization would be different.
  auto IsCompatiblePrivArgOfCallback = [&](CallBase &CB) {
    SmallVector<const Use *, 4> CallbackUses;
    AbstractCallSite::getCallbackUses(CB, CallbackUses);
    for (const Use *U : CallbackUses) {
      AbstractCallSite CBACS(U);
      assert(CBACS && CBACS.isCallbackCall())(static_cast <bool> (CBACS && CBACS.isCallbackCall
()) ? void (0) : __assert_fail ("CBACS && CBACS.isCallbackCall()"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6592, __extension__
 __PRETTY_FUNCTION__));
      for (Argument &CBArg : CBACS.getCalledFunction()->args()) {
        int CBArgNo = CBACS.getCallArgOperandNo(CBArg);

        LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
          dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << "[AAPrivatizablePtr] Argument " << *Argdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << "check if can be privatized in the context of its parent ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << Arg->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << ")\n[AAPrivatizablePtr] because it is an argument in a "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
                 "callback ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << CBArgNo << "@" << CBACS.getCalledFunction()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << ")\n[AAPrivatizablePtr] " << CBArg << " : "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << CBACS.getCallArgOperand(CBArg) << " vs "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << CB.getArgOperand(ArgNo) << "\n"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << "[AAPrivatizablePtr] " << CBArg << " : "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
        })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << "check if can be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ")\n[AAPrivatizablePtr] " << CBArg
 << " : " << CBACS.getCallArgOperand(CBArg) <<
 " vs " << CB.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false);

        if (CBArgNo != int(ArgNo))
          continue;
        const auto &CBArgPrivAA = A.getAAFor<AAPrivatizablePtr>(
            *this, IRPosition::argument(CBArg), DepClassTy::REQUIRED);
        if (CBArgPrivAA.isValidState()) {
          auto CBArgPrivTy = CBArgPrivAA.getPrivatizableType();
          if (!CBArgPrivTy.hasValue())
            continue;
          if (CBArgPrivTy.getValue() == PrivatizableType)
            continue;
        }

        LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
          dbgs() << "[AAPrivatizablePtr] Argument " << *Argdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                 << " cannot be privatized in the context of its parent ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                 << Arg->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                 << ")\n[AAPrivatizablePtr] because it is an argument in a "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                    "callback ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                 << CBArgNo << "@" << CBACS.getCalledFunction()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                 << ").\n[AAPrivatizablePtr] for which the argument "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                    "privatization is not compatible.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
        })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "callback (" << CBArgNo << "@" << CBACS.getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false);
        return false;
      }
    }
    return true;
  };

  // Helper to check if for the given call site the associated argument is
  // passed to a direct call where the privatization would be different.
  auto IsCompatiblePrivArgOfDirectCS = [&](AbstractCallSite ACS) {
    CallBase *DC = cast<CallBase>(ACS.getInstruction());
    int DCArgNo = ACS.getCallArgOperandNo(ArgNo);
    assert(DCArgNo >= 0 && unsigned(DCArgNo) < DC->arg_size() &&(static_cast <bool> (DCArgNo >= 0 && unsigned
(DCArgNo) < DC->arg_size() && "Expected a direct call operand for callback call operand"
) ? void (0) : __assert_fail ("DCArgNo >= 0 && unsigned(DCArgNo) < DC->arg_size() && \"Expected a direct call operand for callback call operand\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6645, __extension__
 __PRETTY_FUNCTION__))
           "Expected a direct call operand for callback call operand")(static_cast <bool> (DCArgNo >= 0 && unsigned
(DCArgNo) < DC->arg_size() && "Expected a direct call operand for callback call operand"
) ? void (0) : __assert_fail ("DCArgNo >= 0 && unsigned(DCArgNo) < DC->arg_size() && \"Expected a direct call operand for callback call operand\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6645, __extension__
 __PRETTY_FUNCTION__));

    LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
      dbgs() << "[AAPrivatizablePtr] Argument " << *Argdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
             << " check if be privatized in the context of its parent ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
             << Arg->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
             << ")\n[AAPrivatizablePtr] because it is an argument in a "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
                "direct call of ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
             << DCArgNo << "@" << DC->getCalledFunction()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
             << ").\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false)
    })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " check if be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << DCArgNo << "@" << DC
->getCalledFunction()->getName() << ").\n"; }; } }
 while (false);

    Function *DCCallee = DC->getCalledFunction();
    if (unsigned(DCArgNo) < DCCallee->arg_size()) {
      const auto &DCArgPrivAA = A.getAAFor<AAPrivatizablePtr>(
          *this, IRPosition::argument(*DCCallee->getArg(DCArgNo)),
          DepClassTy::REQUIRED);
      if (DCArgPrivAA.isValidState()) {
        auto DCArgPrivTy = DCArgPrivAA.getPrivatizableType();
        if (!DCArgPrivTy.hasValue())
          return true;
        if (DCArgPrivTy.getValue() == PrivatizableType)
          return true;
      }
    }

    LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
      dbgs() << "[AAPrivatizablePtr] Argument " << *Argdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << " cannot be privatized in the context of its parent ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << Arg->getParent()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << ")\n[AAPrivatizablePtr] because it is an argument in a "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                "direct call of ("do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << ACS.getInstruction()->getCalledFunction()->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << ").\n[AAPrivatizablePtr] for which the argument "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
                "privatization is not compatible.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
    })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { dbgs() << "[AAPrivatizablePtr] Argument "
 << *Arg << " cannot be privatized in the context of its parent ("
 << Arg->getParent()->getName() << ")\n[AAPrivatizablePtr] because it is an argument in a "
 "direct call of (" << ACS.getInstruction()->getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false);
    return false;
  };

  // Helper to check if the associated argument is used at the given abstract
  // call site in a way that is incompatible with the privatization assumed
  // here.
  auto IsCompatiblePrivArgOfOtherCallSite = [&](AbstractCallSite ACS) {
    if (ACS.isDirectCall())
      return IsCompatiblePrivArgOfCallback(*ACS.getInstruction());
    if (ACS.isCallbackCall())
      return IsCompatiblePrivArgOfDirectCS(ACS);
    return false;
  };

  if (!A.checkForAllCallSites(IsCompatiblePrivArgOfOtherCallSite, *this, true,
                              UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}

/// Given a type to private \p PrivType, collect the constituates (which are
/// used) in \p ReplacementTypes.
static void
identifyReplacementTypes(Type *PrivType,
                         SmallVectorImpl<Type *> &ReplacementTypes) {
  // TODO: For now we expand the privatization type to the fullest which can
  //       lead to dead arguments that need to be removed later.
  assert(PrivType && "Expected privatizable type!")(static_cast <bool> (PrivType && "Expected privatizable type!"
) ? void (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6709, __extension__
 __PRETTY_FUNCTION__));

  // Traverse the type, extract constituate types on the outermost level.
  if (auto *PrivStructType = dyn_cast<StructType>(PrivType)) {
    for (unsigned u = 0, e = PrivStructType->getNumElements(); u < e; u++)
      ReplacementTypes.push_back(PrivStructType->getElementType(u));
  } else if (auto *PrivArrayType = dyn_cast<ArrayType>(PrivType)) {
    ReplacementTypes.append(PrivArrayType->getNumElements(),
                            PrivArrayType->getElementType());
  } else {
    ReplacementTypes.push_back(PrivType);
  }
}

/// Initialize \p Base according to the type \p PrivType at position \p IP.
/// The values needed are taken from the arguments of \p F starting at
/// position \p ArgNo.
static void createInitialization(Type *PrivType, Value &Base, Function &F,
                                 unsigned ArgNo, Instruction &IP) {
  assert(PrivType && "Expected privatizable type!")(static_cast <bool> (PrivType && "Expected privatizable type!"
) ? void (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6728, __extension__
 __PRETTY_FUNCTION__));

  IRBuilder<NoFolder> IRB(&IP);
  const DataLayout &DL = F.getParent()->getDataLayout();

  // Traverse the type, build GEPs and stores.
  if (auto *PrivStructType = dyn_cast<StructType>(PrivType)) {
    const StructLayout *PrivStructLayout = DL.getStructLayout(PrivStructType);
    for (unsigned u = 0, e = PrivStructType->getNumElements(); u < e; u++) {
      Type *PointeeTy = PrivStructType->getElementType(u)->getPointerTo();
      Value *Ptr =
          constructPointer(PointeeTy, PrivType, &Base,
                           PrivStructLayout->getElementOffset(u), IRB, DL);
      new StoreInst(F.getArg(ArgNo + u), Ptr, &IP);
    }
  } else if (auto *PrivArrayType = dyn_cast<ArrayType>(PrivType)) {
    Type *PointeeTy = PrivArrayType->getElementType();
    Type *PointeePtrTy = PointeeTy->getPointerTo();
    uint64_t PointeeTySize = DL.getTypeStoreSize(PointeeTy);
    for (unsigned u = 0, e = PrivArrayType->getNumElements(); u < e; u++) {
      Value *Ptr = constructPointer(PointeePtrTy, PrivType, &Base,
                                    u * PointeeTySize, IRB, DL);
      new StoreInst(F.getArg(ArgNo + u), Ptr, &IP);
    }
  } else {
    new StoreInst(F.getArg(ArgNo), &Base, &IP);
  }
}

/// Extract values from \p Base according to the type \p PrivType at the
/// call position \p ACS. The values are appended to \p ReplacementValues.
void createReplacementValues(Align Alignment, Type *PrivType,
                             AbstractCallSite ACS, Value *Base,
                             SmallVectorImpl<Value *> &ReplacementValues) {
  assert(Base && "Expected base value!")(static_cast <bool> (Base && "Expected base value!"
) ? void (0) : __assert_fail ("Base && \"Expected base value!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6762, __extension__
 __PRETTY_FUNCTION__));
  assert(PrivType && "Expected privatizable type!")(static_cast <bool> (PrivType && "Expected privatizable type!"
) ? void (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6763, __extension__
 __PRETTY_FUNCTION__));
  Instruction *IP = ACS.getInstruction();

  IRBuilder<NoFolder> IRB(IP);
  const DataLayout &DL = IP->getModule()->getDataLayout();

  Type *PrivPtrType = PrivType->getPointerTo();
  if (Base->getType() != PrivPtrType)
    Base = BitCastInst::CreatePointerBitCastOrAddrSpaceCast(
        Base, PrivPtrType, "", ACS.getInstruction());

  // Traverse the type, build GEPs and loads.
  if (auto *PrivStructType = dyn_cast<StructType>(PrivType)) {
    const StructLayout *PrivStructLayout = DL.getStructLayout(PrivStructType);
    for (unsigned u = 0, e = PrivStructType->getNumElements(); u < e; u++) {
      Type *PointeeTy = PrivStructType->getElementType(u);
      Value *Ptr =
          constructPointer(PointeeTy->getPointerTo(), PrivType, Base,
                           PrivStructLayout->getElementOffset(u), IRB, DL);
      LoadInst *L = new LoadInst(PointeeTy, Ptr, "", IP);
      L->setAlignment(Alignment);
      ReplacementValues.push_back(L);
    }
  } else if (auto *PrivArrayType = dyn_cast<ArrayType>(PrivType)) {
    Type *PointeeTy = PrivArrayType->getElementType();
    uint64_t PointeeTySize = DL.getTypeStoreSize(PointeeTy);
    Type *PointeePtrTy = PointeeTy->getPointerTo();
    for (unsigned u = 0, e = PrivArrayType->getNumElements(); u < e; u++) {
      Value *Ptr = constructPointer(PointeePtrTy, PrivType, Base,
                                    u * PointeeTySize, IRB, DL);
      LoadInst *L = new LoadInst(PointeeTy, Ptr, "", IP);
      L->setAlignment(Alignment);
      ReplacementValues.push_back(L);
    }
  } else {
    LoadInst *L = new LoadInst(PrivType, Base, "", IP);
    L->setAlignment(Alignment);
    ReplacementValues.push_back(L);
  }
}

/// See AbstractAttribute::manifest(...)
ChangeStatus manifest(Attributor &A) override {
  if (!PrivatizableType.hasValue())
    return ChangeStatus::UNCHANGED;
  assert(PrivatizableType.getValue() && "Expected privatizable type!")(static_cast <bool> (PrivatizableType.getValue() &&
 "Expected privatizable type!") ? void (0) : __assert_fail ("PrivatizableType.getValue() && \"Expected privatizable type!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 6808, __extension__
 __PRETTY_FUNCTION__));

  // Collect all tail calls in the function as we cannot allow new allocas to
  // escape into tail recursion.
  // TODO: Be smarter about new allocas escaping into tail calls.
  SmallVector<CallInst *, 16> TailCalls;
  bool UsedAssumedInformation = false;
  if (!A.checkForAllInstructions(
          [&](Instruction &I) {
            CallInst &CI = cast<CallInst>(I);
            if (CI.isTailCall())
              TailCalls.push_back(&CI);
            return true;
          },
          *this, {Instruction::Call}, UsedAssumedInformation))
    return ChangeStatus::UNCHANGED;

  Argument *Arg = getAssociatedArgument();
  // Query AAAlign attribute for alignment of associated argument to
  // determine the best alignment of loads.
  const auto &AlignAA =
      A.getAAFor<AAAlign>(*this, IRPosition::value(*Arg), DepClassTy::NONE);

  // Callback to repair the associated function. A new alloca is placed at the
  // beginning and initialized with the values passed through arguments. The
  // new alloca replaces the use of the old pointer argument.
  Attributor::ArgumentReplacementInfo::CalleeRepairCBTy FnRepairCB =
      [=](const Attributor::ArgumentReplacementInfo &ARI,
          Function &ReplacementFn, Function::arg_iterator ArgIt) {
        BasicBlock &EntryBB = ReplacementFn.getEntryBlock();
        Instruction *IP = &*EntryBB.getFirstInsertionPt();
        const DataLayout &DL = IP->getModule()->getDataLayout();
        unsigned AS = DL.getAllocaAddrSpace();
        Instruction *AI = new AllocaInst(PrivatizableType.getValue(), AS,
                                         Arg->getName() + ".priv", IP);
        createInitialization(PrivatizableType.getValue(), *AI, ReplacementFn,
                             ArgIt->getArgNo(), *IP);

        if (AI->getType() != Arg->getType())
          AI = BitCastInst::CreatePointerBitCastOrAddrSpaceCast(
              AI, Arg->getType(), "", IP);
        Arg->replaceAllUsesWith(AI);

        for (CallInst *CI : TailCalls)
          CI->setTailCall(false);
      };

  // Callback to repair a call site of the associated function. The elements
  // of the privatizable type are loaded prior to the call and passed to the
  // new function version.
  Attributor::ArgumentReplacementInfo::ACSRepairCBTy ACSRepairCB =
      [=, &AlignAA](const Attributor::ArgumentReplacementInfo &ARI,
                    AbstractCallSite ACS,
                    SmallVectorImpl<Value *> &NewArgOperands) {
        // When no alignment is specified for the load instruction,
        // natural alignment is assumed.
        createReplacementValues(
            assumeAligned(AlignAA.getAssumedAlign()),
            PrivatizableType.getValue(), ACS,
            ACS.getCallArgOperand(ARI.getReplacedArg().getArgNo()),
            NewArgOperands);
      };

  // Collect the types that will replace the privatizable type in the function
  // signature.
  SmallVector<Type *, 16> ReplacementTypes;
  identifyReplacementTypes(PrivatizableType.getValue(), ReplacementTypes);

  // Register a rewrite of the argument.
  if (A.registerFunctionSignatureRewrite(*Arg, ReplacementTypes,
                                         std::move(FnRepairCB),
                                         std::move(ACSRepairCB)))
    return ChangeStatus::CHANGED;
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_ARG_ATTR(privatizable_ptr){ static llvm::Statistic NumIRArguments_privatizable_ptr = {"attributor"
, "NumIRArguments_privatizable_ptr", ("Number of " "arguments"
 " marked '" "privatizable_ptr" "'")};; ++(NumIRArguments_privatizable_ptr
); };
}
6888};

6890struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
AAPrivatizablePtrFloating(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtrImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
virtual void initialize(Attributor &A) override {
  // TODO: We can privatize more than arguments.
  indicatePessimisticFixpoint();
}

ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable("AAPrivatizablePtr(Floating|Returned|CallSiteReturned)::"::llvm::llvm_unreachable_internal("AAPrivatizablePtr(Floating|Returned|CallSiteReturned)::"
 "updateImpl will not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 6902)
                   "updateImpl will not be called")::llvm::llvm_unreachable_internal("AAPrivatizablePtr(Floating|Returned|CallSiteReturned)::"
 "updateImpl will not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 6902);
}

/// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
Optional<Type *> identifyPrivatizableType(Attributor &A) override {
  Value *Obj = getUnderlyingObject(&getAssociatedValue());
  if (!Obj) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] No underlying object found!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] No underlying object found!\n"
; } } while (false);
    return nullptr;
  }

  if (auto *AI = dyn_cast<AllocaInst>(Obj))
    if (auto *CI = dyn_cast<ConstantInt>(AI->getArraySize()))
      if (CI->isOne())
        return AI->getAllocatedType();
  if (auto *Arg = dyn_cast<Argument>(Obj)) {
    auto &PrivArgAA = A.getAAFor<AAPrivatizablePtr>(
        *this, IRPosition::argument(*Arg), DepClassTy::REQUIRED);
    if (PrivArgAA.isAssumedPrivatizablePtr())
      return Obj->getType()->getPointerElementType();
  }

  LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] Underlying object neither valid "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Underlying object neither valid "
 "alloca nor privatizable argument: " << *Obj << "!\n"
; } } while (false)
                       "alloca nor privatizable argument: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Underlying object neither valid "
 "alloca nor privatizable argument: " << *Obj << "!\n"
; } } while (false)
                    << *Obj << "!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] Underlying object neither valid "
 "alloca nor privatizable argument: " << *Obj << "!\n"
; } } while (false);
  return nullptr;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(privatizable_ptr){ static llvm::Statistic NumIRFloating_privatizable_ptr = {"attributor"
, "NumIRFloating_privatizable_ptr", ("Number of floating values known to be '"
 "privatizable_ptr" "'")};; ++(NumIRFloating_privatizable_ptr
); };
}
6934};

6936struct AAPrivatizablePtrCallSiteArgument final
  : public AAPrivatizablePtrFloating {
AAPrivatizablePtrCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtrFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (getIRPosition().hasAttr(Attribute::ByVal))
    indicateOptimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  PrivatizableType = identifyPrivatizableType(A);
  if (!PrivatizableType.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!PrivatizableType.getValue())
    return indicatePessimisticFixpoint();

  const IRPosition &IRP = getIRPosition();
  auto &NoCaptureAA =
      A.getAAFor<AANoCapture>(*this, IRP, DepClassTy::REQUIRED);
  if (!NoCaptureAA.isAssumedNoCapture()) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] pointer might be captured!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] pointer might be captured!\n"
; } } while (false);
    return indicatePessimisticFixpoint();
  }

  auto &NoAliasAA = A.getAAFor<AANoAlias>(*this, IRP, DepClassTy::REQUIRED);
  if (!NoAliasAA.isAssumedNoAlias()) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] pointer might alias!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] pointer might alias!\n"
; } } while (false);
    return indicatePessimisticFixpoint();
  }

  bool IsKnown;
  if (!AA::isAssumedReadOnly(A, IRP, *this, IsKnown)) {
    LLVM_DEBUG(dbgs() << "[AAPrivatizablePtr] pointer is written!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPrivatizablePtr] pointer is written!\n"
; } } while (false);
    return indicatePessimisticFixpoint();
  }

  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSARG_ATTR(privatizable_ptr){ static llvm::Statistic NumIRCSArguments_privatizable_ptr = {
"attributor", "NumIRCSArguments_privatizable_ptr", ("Number of "
 "call site arguments" " marked '" "privatizable_ptr" "'")};;
 ++(NumIRCSArguments_privatizable_ptr); };
}
6982};

6984struct AAPrivatizablePtrCallSiteReturned final
  : public AAPrivatizablePtrFloating {
AAPrivatizablePtrCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtrFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // TODO: We can privatize more than arguments.
  indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSRET_ATTR(privatizable_ptr){ static llvm::Statistic NumIRCSReturn_privatizable_ptr = {"attributor"
, "NumIRCSReturn_privatizable_ptr", ("Number of " "call site returns"
 " marked '" "privatizable_ptr" "'")};; ++(NumIRCSReturn_privatizable_ptr
); };
}
6999};

7001struct AAPrivatizablePtrReturned final : public AAPrivatizablePtrFloating {
AAPrivatizablePtrReturned(const IRPosition &IRP, Attributor &A)
    : AAPrivatizablePtrFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // TODO: We can privatize more than arguments.
  indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FNRET_ATTR(privatizable_ptr){ static llvm::Statistic NumIRFunctionReturn_privatizable_ptr
 = {"attributor", "NumIRFunctionReturn_privatizable_ptr", ("Number of "
 "function returns" " marked '" "privatizable_ptr" "'")};; ++
(NumIRFunctionReturn_privatizable_ptr); };
}
7015};

7017/// -------------------- Memory Behavior Attributes ----------------------------
7018/// Includes read-none, read-only, and write-only.
7019/// ----------------------------------------------------------------------------
7020struct AAMemoryBehaviorImpl : public AAMemoryBehavior {
AAMemoryBehaviorImpl(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehavior(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  intersectAssumedBits(BEST_STATE);
  getKnownStateFromValue(getIRPosition(), getState());
  AAMemoryBehavior::initialize(A);
}

/// Return the memory behavior information encoded in the IR for \p IRP.
static void getKnownStateFromValue(const IRPosition &IRP,
                                   BitIntegerState &State,
                                   bool IgnoreSubsumingPositions = false) {
  SmallVector<Attribute, 2> Attrs;
  IRP.getAttrs(AttrKinds, Attrs, IgnoreSubsumingPositions);
  for (const Attribute &Attr : Attrs) {
    switch (Attr.getKindAsEnum()) {
    case Attribute::ReadNone:
      State.addKnownBits(NO_ACCESSES);
      break;
    case Attribute::ReadOnly:
      State.addKnownBits(NO_WRITES);
      break;
    case Attribute::WriteOnly:
      State.addKnownBits(NO_READS);
      break;
    default:
      llvm_unreachable("Unexpected attribute!")::llvm::llvm_unreachable_internal("Unexpected attribute!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7049);
    }
  }

  if (auto *I = dyn_cast<Instruction>(&IRP.getAnchorValue())) {
    if (!I->mayReadFromMemory())
      State.addKnownBits(NO_READS);
    if (!I->mayWriteToMemory())
      State.addKnownBits(NO_WRITES);
  }
}

/// See AbstractAttribute::getDeducedAttributes(...).
void getDeducedAttributes(LLVMContext &Ctx,
                          SmallVectorImpl<Attribute> &Attrs) const override {
  assert(Attrs.size() == 0)(static_cast <bool> (Attrs.size() == 0) ? void (0) : __assert_fail
 ("Attrs.size() == 0", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7064, __extension__ __PRETTY_FUNCTION__));
  if (isAssumedReadNone())
    Attrs.push_back(Attribute::get(Ctx, Attribute::ReadNone));
  else if (isAssumedReadOnly())
    Attrs.push_back(Attribute::get(Ctx, Attribute::ReadOnly));
  else if (isAssumedWriteOnly())
    Attrs.push_back(Attribute::get(Ctx, Attribute::WriteOnly));
  assert(Attrs.size() <= 1)(static_cast <bool> (Attrs.size() <= 1) ? void (0) :
 __assert_fail ("Attrs.size() <= 1", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7071, __extension__ __PRETTY_FUNCTION__));
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  if (hasAttr(Attribute::ReadNone, /* IgnoreSubsumingPositions */ true))
    return ChangeStatus::UNCHANGED;

  const IRPosition &IRP = getIRPosition();

  // Check if we would improve the existing attributes first.
  SmallVector<Attribute, 4> DeducedAttrs;
  getDeducedAttributes(IRP.getAnchorValue().getContext(), DeducedAttrs);
  if (llvm::all_of(DeducedAttrs, [&](const Attribute &Attr) {
        return IRP.hasAttr(Attr.getKindAsEnum(),
                           /* IgnoreSubsumingPositions */ true);
      }))
    return ChangeStatus::UNCHANGED;

  // Clear existing attributes.
  IRP.removeAttrs(AttrKinds);

  // Use the generic manifest method.
  return IRAttribute::manifest(A);
}

/// See AbstractState::getAsStr().
const std::string getAsStr() const override {
  if (isAssumedReadNone())
    return "readnone";
  if (isAssumedReadOnly())
    return "readonly";
  if (isAssumedWriteOnly())
    return "writeonly";
  return "may-read/write";
}

/// The set of IR attributes AAMemoryBehavior deals with.
static const Attribute::AttrKind AttrKinds[3];
7110};

7112const Attribute::AttrKind AAMemoryBehaviorImpl::AttrKinds[] = {
  Attribute::ReadNone, Attribute::ReadOnly, Attribute::WriteOnly};

7115/// Memory behavior attribute for a floating value.
7116struct AAMemoryBehaviorFloating : AAMemoryBehaviorImpl {
AAMemoryBehaviorFloating(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override;

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_FLOATING_ATTR(readnone){ static llvm::Statistic NumIRFloating_readnone = {"attributor"
, "NumIRFloating_readnone", ("Number of floating values known to be '"
 "readnone" "'")};; ++(NumIRFloating_readnone); }
  else if (isAssumedReadOnly())
    STATS_DECLTRACK_FLOATING_ATTR(readonly){ static llvm::Statistic NumIRFloating_readonly = {"attributor"
, "NumIRFloating_readonly", ("Number of floating values known to be '"
 "readonly" "'")};; ++(NumIRFloating_readonly); }
  else if (isAssumedWriteOnly())
    STATS_DECLTRACK_FLOATING_ATTR(writeonly){ static llvm::Statistic NumIRFloating_writeonly = {"attributor"
, "NumIRFloating_writeonly", ("Number of floating values known to be '"
 "writeonly" "'")};; ++(NumIRFloating_writeonly); }
}

7133private:
/// Return true if users of \p UserI might access the underlying
/// variable/location described by \p U and should therefore be analyzed.
bool followUsersOfUseIn(Attributor &A, const Use &U,
                        const Instruction *UserI);

/// Update the state according to the effect of use \p U in \p UserI.
void analyzeUseIn(Attributor &A, const Use &U, const Instruction *UserI);
7141};

7143/// Memory behavior attribute for function argument.
7144struct AAMemoryBehaviorArgument : AAMemoryBehaviorFloating {
AAMemoryBehaviorArgument(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  intersectAssumedBits(BEST_STATE);
  const IRPosition &IRP = getIRPosition();
  // TODO: Make IgnoreSubsumingPositions a property of an IRAttribute so we
  // can query it when we use has/getAttr. That would allow us to reuse the
  // initialize of the base class here.
  bool HasByVal =
      IRP.hasAttr({Attribute::ByVal}, /* IgnoreSubsumingPositions */ true);
  getKnownStateFromValue(IRP, getState(),
                         /* IgnoreSubsumingPositions */ HasByVal);

  // Initialize the use vector with all direct uses of the associated value.
  Argument *Arg = getAssociatedArgument();
  if (!Arg || !A.isFunctionIPOAmendable(*(Arg->getParent())))
    indicatePessimisticFixpoint();
}

ChangeStatus manifest(Attributor &A) override {
  // TODO: Pointer arguments are not supported on vectors of pointers yet.
  if (!getAssociatedValue().getType()->isPointerTy())
    return ChangeStatus::UNCHANGED;

  // TODO: From readattrs.ll: "inalloca parameters are always
  //                           considered written"
  if (hasAttr({Attribute::InAlloca, Attribute::Preallocated})) {
    removeKnownBits(NO_WRITES);
    removeAssumedBits(NO_WRITES);
  }
  return AAMemoryBehaviorFloating::manifest(A);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_ARG_ATTR(readnone){ static llvm::Statistic NumIRArguments_readnone = {"attributor"
, "NumIRArguments_readnone", ("Number of " "arguments" " marked '"
 "readnone" "'")};; ++(NumIRArguments_readnone); }
  else if (isAssumedReadOnly())
    STATS_DECLTRACK_ARG_ATTR(readonly){ static llvm::Statistic NumIRArguments_readonly = {"attributor"
, "NumIRArguments_readonly", ("Number of " "arguments" " marked '"
 "readonly" "'")};; ++(NumIRArguments_readonly); }
  else if (isAssumedWriteOnly())
    STATS_DECLTRACK_ARG_ATTR(writeonly){ static llvm::Statistic NumIRArguments_writeonly = {"attributor"
, "NumIRArguments_writeonly", ("Number of " "arguments" " marked '"
 "writeonly" "'")};; ++(NumIRArguments_writeonly); }
}
7189};

7191struct AAMemoryBehaviorCallSiteArgument final : AAMemoryBehaviorArgument {
AAMemoryBehaviorCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorArgument(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // If we don't have an associated attribute this is either a variadic call
  // or an indirect call, either way, nothing to do here.
  Argument *Arg = getAssociatedArgument();
  if (!Arg) {
    indicatePessimisticFixpoint();
    return;
  }
  if (Arg->hasByValAttr()) {
    addKnownBits(NO_WRITES);
    removeKnownBits(NO_READS);
    removeAssumedBits(NO_READS);
  }
  AAMemoryBehaviorArgument::initialize(A);
  if (getAssociatedFunction()->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Argument *Arg = getAssociatedArgument();
  const IRPosition &ArgPos = IRPosition::argument(*Arg);
  auto &ArgAA =
      A.getAAFor<AAMemoryBehavior>(*this, ArgPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), ArgAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_CSARG_ATTR(readnone){ static llvm::Statistic NumIRCSArguments_readnone = {"attributor"
, "NumIRCSArguments_readnone", ("Number of " "call site arguments"
 " marked '" "readnone" "'")};; ++(NumIRCSArguments_readnone)
; }
  else if (isAssumedReadOnly())
    STATS_DECLTRACK_CSARG_ATTR(readonly){ static llvm::Statistic NumIRCSArguments_readonly = {"attributor"
, "NumIRCSArguments_readonly", ("Number of " "call site arguments"
 " marked '" "readonly" "'")};; ++(NumIRCSArguments_readonly)
; }
  else if (isAssumedWriteOnly())
    STATS_DECLTRACK_CSARG_ATTR(writeonly){ static llvm::Statistic NumIRCSArguments_writeonly = {"attributor"
, "NumIRCSArguments_writeonly", ("Number of " "call site arguments"
 " marked '" "writeonly" "'")};; ++(NumIRCSArguments_writeonly
); }
}
7236};

7238/// Memory behavior attribute for a call site return position.
7239struct AAMemoryBehaviorCallSiteReturned final : AAMemoryBehaviorFloating {
AAMemoryBehaviorCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorFloating(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryBehaviorImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // We do not annotate returned values.
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}
7259};

7261/// An AA to represent the memory behavior function attributes.
7262struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
AAMemoryBehaviorFunction(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(Attributor &A).
virtual ChangeStatus updateImpl(Attributor &A) override;

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  Function &F = cast<Function>(getAnchorValue());
  if (isAssumedReadNone()) {
    F.removeFnAttr(Attribute::ArgMemOnly);
    F.removeFnAttr(Attribute::InaccessibleMemOnly);
    F.removeFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
  }
  return AAMemoryBehaviorImpl::manifest(A);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_FN_ATTR(readnone){ static llvm::Statistic NumIRFunction_readnone = {"attributor"
, "NumIRFunction_readnone", ("Number of " "functions" " marked '"
 "readnone" "'")};; ++(NumIRFunction_readnone); }
  else if (isAssumedReadOnly())
    STATS_DECLTRACK_FN_ATTR(readonly){ static llvm::Statistic NumIRFunction_readonly = {"attributor"
, "NumIRFunction_readonly", ("Number of " "functions" " marked '"
 "readonly" "'")};; ++(NumIRFunction_readonly); }
  else if (isAssumedWriteOnly())
    STATS_DECLTRACK_FN_ATTR(writeonly){ static llvm::Statistic NumIRFunction_writeonly = {"attributor"
, "NumIRFunction_writeonly", ("Number of " "functions" " marked '"
 "writeonly" "'")};; ++(NumIRFunction_writeonly); }
}
7289};

7291/// AAMemoryBehavior attribute for call sites.
7292struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
AAMemoryBehaviorCallSite(const IRPosition &IRP, Attributor &A)
    : AAMemoryBehaviorImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryBehaviorImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA =
      A.getAAFor<AAMemoryBehavior>(*this, FnPos, DepClassTy::REQUIRED);
  return clampStateAndIndicateChange(getState(), FnAA.getState());
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_CS_ATTR(readnone){ static llvm::Statistic NumIRCS_readnone = {"attributor", "NumIRCS_readnone"
, ("Number of " "call site" " marked '" "readnone" "'")};; ++
(NumIRCS_readnone); }
  else if (isAssumedReadOnly())
    STATS_DECLTRACK_CS_ATTR(readonly){ static llvm::Statistic NumIRCS_readonly = {"attributor", "NumIRCS_readonly"
, ("Number of " "call site" " marked '" "readonly" "'")};; ++
(NumIRCS_readonly); }
  else if (isAssumedWriteOnly())
    STATS_DECLTRACK_CS_ATTR(writeonly){ static llvm::Statistic NumIRCS_writeonly = {"attributor", "NumIRCS_writeonly"
, ("Number of " "call site" " marked '" "writeonly" "'")};; ++
(NumIRCS_writeonly); }
}
7326};

7328ChangeStatus AAMemoryBehaviorFunction::updateImpl(Attributor &A) {

// The current assumed state used to determine a change.
auto AssumedState = getAssumed();

auto CheckRWInst = [&](Instruction &I) {
  // If the instruction has an own memory behavior state, use it to restrict
  // the local state. No further analysis is required as the other memory
  // state is as optimistic as it gets.
  if (const auto *CB = dyn_cast<CallBase>(&I)) {
    const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
        *this, IRPosition::callsite_function(*CB), DepClassTy::REQUIRED);
    intersectAssumedBits(MemBehaviorAA.getAssumed());
    return !isAtFixpoint();
  }

  // Remove access kind modifiers if necessary.
  if (I.mayReadFromMemory())
    removeAssumedBits(NO_READS);
  if (I.mayWriteToMemory())
    removeAssumedBits(NO_WRITES);
  return !isAtFixpoint();
};

bool UsedAssumedInformation = false;
if (!A.checkForAllReadWriteInstructions(CheckRWInst, *this,
                                        UsedAssumedInformation))
  return indicatePessimisticFixpoint();

return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
                                      : ChangeStatus::UNCHANGED;
7359}

7361ChangeStatus AAMemoryBehaviorFloating::updateImpl(Attributor &A) {

const IRPosition &IRP = getIRPosition();
const IRPosition &FnPos = IRPosition::function_scope(IRP);
AAMemoryBehavior::StateType &S = getState();

// First, check the function scope. We take the known information and we avoid
// work if the assumed information implies the current assumed information for
// this attribute. This is a valid for all but byval arguments.
Argument *Arg = IRP.getAssociatedArgument();
AAMemoryBehavior::base_t FnMemAssumedState =
    AAMemoryBehavior::StateType::getWorstState();
if (!Arg || !Arg->hasByValAttr()) {
  const auto &FnMemAA =
      A.getAAFor<AAMemoryBehavior>(*this, FnPos, DepClassTy::OPTIONAL);
  FnMemAssumedState = FnMemAA.getAssumed();
  S.addKnownBits(FnMemAA.getKnown());
  if ((S.getAssumed() & FnMemAA.getAssumed()) == S.getAssumed())
    return ChangeStatus::UNCHANGED;
}

// The current assumed state used to determine a change.
auto AssumedState = S.getAssumed();

// Make sure the value is not captured (except through "return"), if
// it is, any information derived would be irrelevant anyway as we cannot
// check the potential aliases introduced by the capture. However, no need
// to fall back to anythign less optimistic than the function state.
const auto &ArgNoCaptureAA =
    A.getAAFor<AANoCapture>(*this, IRP, DepClassTy::OPTIONAL);
if (!ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
  S.intersectAssumedBits(FnMemAssumedState);
  return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
                                        : ChangeStatus::UNCHANGED;
}

// Visit and expand uses until all are analyzed or a fixpoint is reached.
auto UsePred = [&](const Use &U, bool &Follow) -> bool {
  Instruction *UserI = cast<Instruction>(U.getUser());
  LLVM_DEBUG(dbgs() << "[AAMemoryBehavior] Use: " << *U << " in " << *UserIdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryBehavior] Use: " <<
 *U << " in " << *UserI << " \n"; } } while
 (false)
                    << " \n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryBehavior] Use: " <<
 *U << " in " << *UserI << " \n"; } } while
 (false);

  // Droppable users, e.g., llvm::assume does not actually perform any action.
  if (UserI->isDroppable())
    return true;

  // Check if the users of UserI should also be visited.
  Follow = followUsersOfUseIn(A, U, UserI);

  // If UserI might touch memory we analyze the use in detail.
  if (UserI->mayReadOrWriteMemory())
    analyzeUseIn(A, U, UserI);

  return !isAtFixpoint();
};

if (!A.checkForAllUses(UsePred, *this, getAssociatedValue()))
  return indicatePessimisticFixpoint();

return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
                                      : ChangeStatus::UNCHANGED;
7422}

7424bool AAMemoryBehaviorFloating::followUsersOfUseIn(Attributor &A, const Use &U,
                                                const Instruction *UserI) {
// The loaded value is unrelated to the pointer argument, no need to
// follow the users of the load.
if (isa<LoadInst>(UserI))
  return false;

// By default we follow all uses assuming UserI might leak information on U,
// we have special handling for call sites operands though.
const auto *CB = dyn_cast<CallBase>(UserI);
if (!CB || !CB->isArgOperand(&U))
  return true;

// If the use is a call argument known not to be captured, the users of
// the call do not need to be visited because they have to be unrelated to
// the input. Note that this check is not trivial even though we disallow
// general capturing of the underlying argument. The reason is that the
// call might the argument "through return", which we allow and for which we
// need to check call users.
if (U.get()->getType()->isPointerTy()) {
  unsigned ArgNo = CB->getArgOperandNo(&U);
  const auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(
      *this, IRPosition::callsite_argument(*CB, ArgNo), DepClassTy::OPTIONAL);
  return !ArgNoCaptureAA.isAssumedNoCapture();
}

return true;
7451}

7453void AAMemoryBehaviorFloating::analyzeUseIn(Attributor &A, const Use &U,
                                          const Instruction *UserI) {
assert(UserI->mayReadOrWriteMemory())(static_cast <bool> (UserI->mayReadOrWriteMemory()) ?
 void (0) : __assert_fail ("UserI->mayReadOrWriteMemory()"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 7455, __extension__
 __PRETTY_FUNCTION__));

switch (UserI->getOpcode()) {
default:
  // TODO: Handle all atomics and other side-effect operations we know of.
  break;
case Instruction::Load:
  // Loads cause the NO_READS property to disappear.
  removeAssumedBits(NO_READS);
  return;

case Instruction::Store:
  // Stores cause the NO_WRITES property to disappear if the use is the
  // pointer operand. Note that while capturing was taken care of somewhere
  // else we need to deal with stores of the value that is not looked through.
  if (cast<StoreInst>(UserI)->getPointerOperand() == U.get())
    removeAssumedBits(NO_WRITES);
  else
    indicatePessimisticFixpoint();
  return;

case Instruction::Call:
case Instruction::CallBr:
case Instruction::Invoke: {
  // For call sites we look at the argument memory behavior attribute (this
  // could be recursive!) in order to restrict our own state.
  const auto *CB = cast<CallBase>(UserI);

  // Give up on operand bundles.
  if (CB->isBundleOperand(&U)) {
    indicatePessimisticFixpoint();
    return;
  }

  // Calling a function does read the function pointer, maybe write it if the
  // function is self-modifying.
  if (CB->isCallee(&U)) {
    removeAssumedBits(NO_READS);
    break;
  }

  // Adjust the possible access behavior based on the information on the
  // argument.
  IRPosition Pos;
  if (U.get()->getType()->isPointerTy())
    Pos = IRPosition::callsite_argument(*CB, CB->getArgOperandNo(&U));
  else
    Pos = IRPosition::callsite_function(*CB);
  const auto &MemBehaviorAA =
      A.getAAFor<AAMemoryBehavior>(*this, Pos, DepClassTy::OPTIONAL);
  // "assumed" has at most the same bits as the MemBehaviorAA assumed
  // and at least "known".
  intersectAssumedBits(MemBehaviorAA.getAssumed());
  return;
}
};

// Generally, look at the "may-properties" and adjust the assumed state if we
// did not trigger special handling before.
if (UserI->mayReadFromMemory())
  removeAssumedBits(NO_READS);
if (UserI->mayWriteToMemory())
  removeAssumedBits(NO_WRITES);
7518}

7520/// -------------------- Memory Locations Attributes ---------------------------
7521/// Includes read-none, argmemonly, inaccessiblememonly,
7522/// inaccessiblememorargmemonly
7523/// ----------------------------------------------------------------------------

7525std::string AAMemoryLocation::getMemoryLocationsAsStr(
  AAMemoryLocation::MemoryLocationsKind MLK) {
if (0 == (MLK & AAMemoryLocation::NO_LOCATIONS))
  return "all memory";
if (MLK == AAMemoryLocation::NO_LOCATIONS)
  return "no memory";
std::string S = "memory:";
if (0 == (MLK & AAMemoryLocation::NO_LOCAL_MEM))
  S += "stack,";
if (0 == (MLK & AAMemoryLocation::NO_CONST_MEM))
  S += "constant,";
if (0 == (MLK & AAMemoryLocation::NO_GLOBAL_INTERNAL_MEM))
  S += "internal global,";
if (0 == (MLK & AAMemoryLocation::NO_GLOBAL_EXTERNAL_MEM))
  S += "external global,";
if (0 == (MLK & AAMemoryLocation::NO_ARGUMENT_MEM))
  S += "argument,";
if (0 == (MLK & AAMemoryLocation::NO_INACCESSIBLE_MEM))
  S += "inaccessible,";
if (0 == (MLK & AAMemoryLocation::NO_MALLOCED_MEM))
  S += "malloced,";
if (0 == (MLK & AAMemoryLocation::NO_UNKOWN_MEM))
  S += "unknown,";
S.pop_back();
return S;
7550}

7552struct AAMemoryLocationImpl : public AAMemoryLocation {

AAMemoryLocationImpl(const IRPosition &IRP, Attributor &A)
    : AAMemoryLocation(IRP, A), Allocator(A.Allocator) {
  for (unsigned u = 0; u < llvm::CTLog2<VALID_STATE>(); ++u)
    AccessKind2Accesses[u] = nullptr;
}

~AAMemoryLocationImpl() {
  // The AccessSets are allocated via a BumpPtrAllocator, we call
  // the destructor manually.
  for (unsigned u = 0; u < llvm::CTLog2<VALID_STATE>(); ++u)
    if (AccessKind2Accesses[u])
      AccessKind2Accesses[u]->~AccessSet();
}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  intersectAssumedBits(BEST_STATE);
  getKnownStateFromValue(A, getIRPosition(), getState());
  AAMemoryLocation::initialize(A);
}

/// Return the memory behavior information encoded in the IR for \p IRP.
static void getKnownStateFromValue(Attributor &A, const IRPosition &IRP,
                                   BitIntegerState &State,
                                   bool IgnoreSubsumingPositions = false) {
  // For internal functions we ignore `argmemonly` and
  // `inaccessiblememorargmemonly` as we might break it via interprocedural
  // constant propagation. It is unclear if this is the best way but it is
  // unlikely this will cause real performance problems. If we are deriving
  // attributes for the anchor function we even remove the attribute in
  // addition to ignoring it.
  bool UseArgMemOnly = true;
  Function *AnchorFn = IRP.getAnchorScope();
  if (AnchorFn && A.isRunOn(*AnchorFn))
    UseArgMemOnly = !AnchorFn->hasLocalLinkage();

  SmallVector<Attribute, 2> Attrs;
  IRP.getAttrs(AttrKinds, Attrs, IgnoreSubsumingPositions);
  for (const Attribute &Attr : Attrs) {
    switch (Attr.getKindAsEnum()) {
    case Attribute::ReadNone:
      State.addKnownBits(NO_LOCAL_MEM | NO_CONST_MEM);
      break;
    case Attribute::InaccessibleMemOnly:
      State.addKnownBits(inverseLocation(NO_INACCESSIBLE_MEM, true, true));
      break;
    case Attribute::ArgMemOnly:
      if (UseArgMemOnly)
        State.addKnownBits(inverseLocation(NO_ARGUMENT_MEM, true, true));
      else
        IRP.removeAttrs({Attribute::ArgMemOnly});
      break;
    case Attribute::InaccessibleMemOrArgMemOnly:
      if (UseArgMemOnly)
        State.addKnownBits(inverseLocation(
            NO_INACCESSIBLE_MEM | NO_ARGUMENT_MEM, true, true));
      else
        IRP.removeAttrs({Attribute::InaccessibleMemOrArgMemOnly});
      break;
    default:
      llvm_unreachable("Unexpected attribute!")::llvm::llvm_unreachable_internal("Unexpected attribute!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7614);
    }
  }
}

/// See AbstractAttribute::getDeducedAttributes(...).
void getDeducedAttributes(LLVMContext &Ctx,
                          SmallVectorImpl<Attribute> &Attrs) const override {
  assert(Attrs.size() == 0)(static_cast <bool> (Attrs.size() == 0) ? void (0) : __assert_fail
 ("Attrs.size() == 0", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7622, __extension__ __PRETTY_FUNCTION__));
  if (isAssumedReadNone()) {
    Attrs.push_back(Attribute::get(Ctx, Attribute::ReadNone));
  } else if (getIRPosition().getPositionKind() == IRPosition::IRP_FUNCTION) {
    if (isAssumedInaccessibleMemOnly())
      Attrs.push_back(Attribute::get(Ctx, Attribute::InaccessibleMemOnly));
    else if (isAssumedArgMemOnly())
      Attrs.push_back(Attribute::get(Ctx, Attribute::ArgMemOnly));
    else if (isAssumedInaccessibleOrArgMemOnly())
      Attrs.push_back(
          Attribute::get(Ctx, Attribute::InaccessibleMemOrArgMemOnly));
  }
  assert(Attrs.size() <= 1)(static_cast <bool> (Attrs.size() <= 1) ? void (0) :
 __assert_fail ("Attrs.size() <= 1", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 7634, __extension__ __PRETTY_FUNCTION__));
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  const IRPosition &IRP = getIRPosition();

  // Check if we would improve the existing attributes first.
  SmallVector<Attribute, 4> DeducedAttrs;
  getDeducedAttributes(IRP.getAnchorValue().getContext(), DeducedAttrs);
  if (llvm::all_of(DeducedAttrs, [&](const Attribute &Attr) {
        return IRP.hasAttr(Attr.getKindAsEnum(),
                           /* IgnoreSubsumingPositions */ true);
      }))
    return ChangeStatus::UNCHANGED;

  // Clear existing attributes.
  IRP.removeAttrs(AttrKinds);
  if (isAssumedReadNone())
    IRP.removeAttrs(AAMemoryBehaviorImpl::AttrKinds);

  // Use the generic manifest method.
  return IRAttribute::manifest(A);
}

/// See AAMemoryLocation::checkForAllAccessesToMemoryKind(...).
bool checkForAllAccessesToMemoryKind(
    function_ref<bool(const Instruction *, const Value *, AccessKind,
                      MemoryLocationsKind)>
        Pred,
    MemoryLocationsKind RequestedMLK) const override {
  if (!isValidState())
    return false;

  MemoryLocationsKind AssumedMLK = getAssumedNotAccessedLocation();
  if (AssumedMLK == NO_LOCATIONS)
    return true;

  unsigned Idx = 0;
  for (MemoryLocationsKind CurMLK = 1; CurMLK < NO_LOCATIONS;
       CurMLK *= 2, ++Idx) {
    if (CurMLK & RequestedMLK)
      continue;

    if (const AccessSet *Accesses = AccessKind2Accesses[Idx])
      for (const AccessInfo &AI : *Accesses)
        if (!Pred(AI.I, AI.Ptr, AI.Kind, CurMLK))
          return false;
  }

  return true;
}

ChangeStatus indicatePessimisticFixpoint() override {
  // If we give up and indicate a pessimistic fixpoint this instruction will
  // become an access for all potential access kinds:
  // TODO: Add pointers for argmemonly and globals to improve the results of
  //       checkForAllAccessesToMemoryKind.
  bool Changed = false;
  MemoryLocationsKind KnownMLK = getKnown();
  Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
  for (MemoryLocationsKind CurMLK = 1; CurMLK < NO_LOCATIONS; CurMLK *= 2)
    if (!(CurMLK & KnownMLK))
      updateStateAndAccessesMap(getState(), CurMLK, I, nullptr, Changed,
                                getAccessKindFromInst(I));
  return AAMemoryLocation::indicatePessimisticFixpoint();
}

7702protected:
/// Helper struct to tie together an instruction that has a read or write
/// effect with the pointer it accesses (if any).
struct AccessInfo {

  /// The instruction that caused the access.
  const Instruction *I;

  /// The base pointer that is accessed, or null if unknown.
  const Value *Ptr;

  /// The kind of access (read/write/read+write).
  AccessKind Kind;

  bool operator==(const AccessInfo &RHS) const {
    return I == RHS.I && Ptr == RHS.Ptr && Kind == RHS.Kind;
  }
  bool operator()(const AccessInfo &LHS, const AccessInfo &RHS) const {
    if (LHS.I != RHS.I)
      return LHS.I < RHS.I;
    if (LHS.Ptr != RHS.Ptr)
      return LHS.Ptr < RHS.Ptr;
    if (LHS.Kind != RHS.Kind)
      return LHS.Kind < RHS.Kind;
    return false;
  }
};

/// Mapping from *single* memory location kinds, e.g., LOCAL_MEM with the
/// value of NO_LOCAL_MEM, to the accesses encountered for this memory kind.
using AccessSet = SmallSet<AccessInfo, 2, AccessInfo>;
AccessSet *AccessKind2Accesses[llvm::CTLog2<VALID_STATE>()];

/// Categorize the pointer arguments of CB that might access memory in
/// AccessedLoc and update the state and access map accordingly.
void
categorizeArgumentPointerLocations(Attributor &A, CallBase &CB,
                                   AAMemoryLocation::StateType &AccessedLocs,
                                   bool &Changed);

/// Return the kind(s) of location that may be accessed by \p V.
AAMemoryLocation::MemoryLocationsKind
categorizeAccessedLocations(Attributor &A, Instruction &I, bool &Changed);

/// Return the access kind as determined by \p I.
AccessKind getAccessKindFromInst(const Instruction *I) {
  AccessKind AK = READ_WRITE;
  if (I) {
    AK = I->mayReadFromMemory() ? READ : NONE;
    AK = AccessKind(AK | (I->mayWriteToMemory() ? WRITE : NONE));
  }
  return AK;
}

/// Update the state \p State and the AccessKind2Accesses given that \p I is
/// an access of kind \p AK to a \p MLK memory location with the access
/// pointer \p Ptr.
void updateStateAndAccessesMap(AAMemoryLocation::StateType &State,
                               MemoryLocationsKind MLK, const Instruction *I,
                               const Value *Ptr, bool &Changed,
                               AccessKind AK = READ_WRITE) {

  assert(isPowerOf2_32(MLK) && "Expected a single location set!")(static_cast <bool> (isPowerOf2_32(MLK) && "Expected a single location set!"
) ? void (0) : __assert_fail ("isPowerOf2_32(MLK) && \"Expected a single location set!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 7764, __extension__
 __PRETTY_FUNCTION__));
  auto *&Accesses = AccessKind2Accesses[llvm::Log2_32(MLK)];
  if (!Accesses)
    Accesses = new (Allocator) AccessSet();
  Changed |= Accesses->insert(AccessInfo{I, Ptr, AK}).second;
  State.removeAssumedBits(MLK);
}

/// Determine the underlying locations kinds for \p Ptr, e.g., globals or
/// arguments, and update the state and access map accordingly.
void categorizePtrValue(Attributor &A, const Instruction &I, const Value &Ptr,
                        AAMemoryLocation::StateType &State, bool &Changed);

/// Used to allocate access sets.
BumpPtrAllocator &Allocator;

/// The set of IR attributes AAMemoryLocation deals with.
static const Attribute::AttrKind AttrKinds[4];
7782};

7784const Attribute::AttrKind AAMemoryLocationImpl::AttrKinds[] = {
  Attribute::ReadNone, Attribute::InaccessibleMemOnly, Attribute::ArgMemOnly,
  Attribute::InaccessibleMemOrArgMemOnly};

7788void AAMemoryLocationImpl::categorizePtrValue(
  Attributor &A, const Instruction &I, const Value &Ptr,
  AAMemoryLocation::StateType &State, bool &Changed) {
LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize pointer locations for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize pointer locations for "
 << Ptr << " [" << getMemoryLocationsAsStr(
State.getAssumed()) << "]\n"; } } while (false)
                  << Ptr << " ["do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize pointer locations for "
 << Ptr << " [" << getMemoryLocationsAsStr(
State.getAssumed()) << "]\n"; } } while (false)
                  << getMemoryLocationsAsStr(State.getAssumed()) << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize pointer locations for "
 << Ptr << " [" << getMemoryLocationsAsStr(
State.getAssumed()) << "]\n"; } } while (false);

SmallVector<Value *, 8> Objects;
bool UsedAssumedInformation = false;
if (!AA::getAssumedUnderlyingObjects(A, Ptr, Objects, *this, &I,
                                     UsedAssumedInformation,
                                     /* Intraprocedural */ true)) {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Pointer locations not categorized\n"
; } } while (false)
      dbgs() << "[AAMemoryLocation] Pointer locations not categorized\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Pointer locations not categorized\n"
; } } while (false);
  updateStateAndAccessesMap(State, NO_UNKOWN_MEM, &I, nullptr, Changed,
                            getAccessKindFromInst(&I));
  return;
}

for (Value *Obj : Objects) {
  // TODO: recognize the TBAA used for constant accesses.
  MemoryLocationsKind MLK = NO_LOCATIONS;
  if (isa<UndefValue>(Obj))
    continue;
  if (isa<Argument>(Obj)) {
    // TODO: For now we do not treat byval arguments as local copies performed
    // on the call edge, though, we should. To make that happen we need to
    // teach various passes, e.g., DSE, about the copy effect of a byval. That
    // would also allow us to mark functions only accessing byval arguments as
    // readnone again, atguably their acceses have no effect outside of the
    // function, like accesses to allocas.
    MLK = NO_ARGUMENT_MEM;
  } else if (auto *GV = dyn_cast<GlobalValue>(Obj)) {
    // Reading constant memory is not treated as a read "effect" by the
    // function attr pass so we won't neither. Constants defined by TBAA are
    // similar. (We know we do not write it because it is constant.)
    if (auto *GVar = dyn_cast<GlobalVariable>(GV))
      if (GVar->isConstant())
        continue;

    if (GV->hasLocalLinkage())
      MLK = NO_GLOBAL_INTERNAL_MEM;
    else
      MLK = NO_GLOBAL_EXTERNAL_MEM;
  } else if (isa<ConstantPointerNull>(Obj) &&
             !NullPointerIsDefined(getAssociatedFunction(),
                                   Ptr.getType()->getPointerAddressSpace())) {
    continue;
  } else if (isa<AllocaInst>(Obj)) {
    MLK = NO_LOCAL_MEM;
  } else if (const auto *CB = dyn_cast<CallBase>(Obj)) {
    const auto &NoAliasAA = A.getAAFor<AANoAlias>(
        *this, IRPosition::callsite_returned(*CB), DepClassTy::OPTIONAL);
    if (NoAliasAA.isAssumedNoAlias())
      MLK = NO_MALLOCED_MEM;
    else
      MLK = NO_UNKOWN_MEM;
  } else {
    MLK = NO_UNKOWN_MEM;
  }

  assert(MLK != NO_LOCATIONS && "No location specified!")(static_cast <bool> (MLK != NO_LOCATIONS && "No location specified!"
) ? void (0) : __assert_fail ("MLK != NO_LOCATIONS && \"No location specified!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 7849, __extension__
 __PRETTY_FUNCTION__));
  LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Ptr value can be categorized: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value can be categorized: "
 << *Obj << " -> " << getMemoryLocationsAsStr
(MLK) << "\n"; } } while (false)
                    << *Obj << " -> " << getMemoryLocationsAsStr(MLK)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value can be categorized: "
 << *Obj << " -> " << getMemoryLocationsAsStr
(MLK) << "\n"; } } while (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value can be categorized: "
 << *Obj << " -> " << getMemoryLocationsAsStr
(MLK) << "\n"; } } while (false);
  updateStateAndAccessesMap(getState(), MLK, &I, Obj, Changed,
                            getAccessKindFromInst(&I));
}

LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "
 << getMemoryLocationsAsStr(State.getAssumed()) <<
 "\n"; } } while (false)
    dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "
 << getMemoryLocationsAsStr(State.getAssumed()) <<
 "\n"; } } while (false)
           << getMemoryLocationsAsStr(State.getAssumed()) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "
 << getMemoryLocationsAsStr(State.getAssumed()) <<
 "\n"; } } while (false);
7860}

7862void AAMemoryLocationImpl::categorizeArgumentPointerLocations(
  Attributor &A, CallBase &CB, AAMemoryLocation::StateType &AccessedLocs,
  bool &Changed) {
for (unsigned ArgNo = 0, E = CB.arg_size(); ArgNo < E; ++ArgNo) {

  // Skip non-pointer arguments.
  const Value *ArgOp = CB.getArgOperand(ArgNo);
  if (!ArgOp->getType()->isPtrOrPtrVectorTy())
    continue;

  // Skip readnone arguments.
  const IRPosition &ArgOpIRP = IRPosition::callsite_argument(CB, ArgNo);
  const auto &ArgOpMemLocationAA =
      A.getAAFor<AAMemoryBehavior>(*this, ArgOpIRP, DepClassTy::OPTIONAL);

  if (ArgOpMemLocationAA.isAssumedReadNone())
    continue;

  // Categorize potentially accessed pointer arguments as if there was an
  // access instruction with them as pointer.
  categorizePtrValue(A, CB, *ArgOp, AccessedLocs, Changed);
}
7884}

7886AAMemoryLocation::MemoryLocationsKind
7887AAMemoryLocationImpl::categorizeAccessedLocations(Attributor &A, Instruction &I,
                                                bool &Changed) {
LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize accessed locations for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize accessed locations for "
 << I << "\n"; } } while (false)
                  << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize accessed locations for "
 << I << "\n"; } } while (false);

AAMemoryLocation::StateType AccessedLocs;
AccessedLocs.intersectAssumedBits(NO_LOCATIONS);

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

  // First check if we assume any memory is access is visible.
  const auto &CBMemLocationAA = A.getAAFor<AAMemoryLocation>(
      *this, IRPosition::callsite_function(*CB), DepClassTy::OPTIONAL);
  LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize call site: " << Ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize call site: "
 << I << " [" << CBMemLocationAA << "]\n"
; } } while (false)
                    << " [" << CBMemLocationAA << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize call site: "
 << I << " [" << CBMemLocationAA << "]\n"
; } } while (false);

  if (CBMemLocationAA.isAssumedReadNone())
    return NO_LOCATIONS;

  if (CBMemLocationAA.isAssumedInaccessibleMemOnly()) {
    updateStateAndAccessesMap(AccessedLocs, NO_INACCESSIBLE_MEM, &I, nullptr,
                              Changed, getAccessKindFromInst(&I));
    return AccessedLocs.getAssumed();
  }

  uint32_t CBAssumedNotAccessedLocs =
      CBMemLocationAA.getAssumedNotAccessedLocation();

  // Set the argmemonly and global bit as we handle them separately below.
  uint32_t CBAssumedNotAccessedLocsNoArgMem =
      CBAssumedNotAccessedLocs | NO_ARGUMENT_MEM | NO_GLOBAL_MEM;

  for (MemoryLocationsKind CurMLK = 1; CurMLK < NO_LOCATIONS; CurMLK *= 2) {
    if (CBAssumedNotAccessedLocsNoArgMem & CurMLK)
      continue;
    updateStateAndAccessesMap(AccessedLocs, CurMLK, &I, nullptr, Changed,
                              getAccessKindFromInst(&I));
  }

  // Now handle global memory if it might be accessed. This is slightly tricky
  // as NO_GLOBAL_MEM has multiple bits set.
  bool HasGlobalAccesses = ((~CBAssumedNotAccessedLocs) & NO_GLOBAL_MEM);
  if (HasGlobalAccesses) {
    auto AccessPred = [&](const Instruction *, const Value *Ptr,
                          AccessKind Kind, MemoryLocationsKind MLK) {
      updateStateAndAccessesMap(AccessedLocs, MLK, &I, Ptr, Changed,
                                getAccessKindFromInst(&I));
      return true;
    };
    if (!CBMemLocationAA.checkForAllAccessesToMemoryKind(
            AccessPred, inverseLocation(NO_GLOBAL_MEM, false, false)))
      return AccessedLocs.getWorstState();
  }

  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state before argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false)
      dbgs() << "[AAMemoryLocation] Accessed state before argument handling: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state before argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false)
             << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state before argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false);

  // Now handle argument memory if it might be accessed.
  bool HasArgAccesses = ((~CBAssumedNotAccessedLocs) & NO_ARGUMENT_MEM);
  if (HasArgAccesses)
    categorizeArgumentPointerLocations(A, *CB, AccessedLocs, Changed);

  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state after argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false)
      dbgs() << "[AAMemoryLocation] Accessed state after argument handling: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state after argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false)
             << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed state after argument handling: "
 << getMemoryLocationsAsStr(AccessedLocs.getAssumed()) <<
 "\n"; } } while (false);

  return AccessedLocs.getAssumed();
}

if (const Value *Ptr = getPointerOperand(&I, /* AllowVolatile */ true)) {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize memory access with pointer: "
 << I << " [" << *Ptr << "]\n"; } } while
 (false)
      dbgs() << "[AAMemoryLocation] Categorize memory access with pointer: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize memory access with pointer: "
 << I << " [" << *Ptr << "]\n"; } } while
 (false)
             << I << " [" << *Ptr << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize memory access with pointer: "
 << I << " [" << *Ptr << "]\n"; } } while
 (false);
  categorizePtrValue(A, I, *Ptr, AccessedLocs, Changed);
  return AccessedLocs.getAssumed();
}

LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Failed to categorize instruction: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Failed to categorize instruction: "
 << I << "\n"; } } while (false)
                  << I << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Failed to categorize instruction: "
 << I << "\n"; } } while (false);
updateStateAndAccessesMap(AccessedLocs, NO_UNKOWN_MEM, &I, nullptr, Changed,
                          getAccessKindFromInst(&I));
return AccessedLocs.getAssumed();
7970}

7972/// An AA to represent the memory behavior function attributes.
7973struct AAMemoryLocationFunction final : public AAMemoryLocationImpl {
AAMemoryLocationFunction(const IRPosition &IRP, Attributor &A)
    : AAMemoryLocationImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(Attributor &A).
virtual ChangeStatus updateImpl(Attributor &A) override {

  const auto &MemBehaviorAA =
      A.getAAFor<AAMemoryBehavior>(*this, getIRPosition(), DepClassTy::NONE);
  if (MemBehaviorAA.isAssumedReadNone()) {
    if (MemBehaviorAA.isKnownReadNone())
      return indicateOptimisticFixpoint();
    assert(isAssumedReadNone() &&(static_cast <bool> (isAssumedReadNone() && "AAMemoryLocation was not read-none but AAMemoryBehavior was!"
) ? void (0) : __assert_fail ("isAssumedReadNone() && \"AAMemoryLocation was not read-none but AAMemoryBehavior was!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 7986, __extension__
 __PRETTY_FUNCTION__))
           "AAMemoryLocation was not read-none but AAMemoryBehavior was!")(static_cast <bool> (isAssumedReadNone() && "AAMemoryLocation was not read-none but AAMemoryBehavior was!"
) ? void (0) : __assert_fail ("isAssumedReadNone() && \"AAMemoryLocation was not read-none but AAMemoryBehavior was!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 7986, __extension__
 __PRETTY_FUNCTION__));
    A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
    return ChangeStatus::UNCHANGED;
  }

  // The current assumed state used to determine a change.
  auto AssumedState = getAssumed();
  bool Changed = false;

  auto CheckRWInst = [&](Instruction &I) {
    MemoryLocationsKind MLK = categorizeAccessedLocations(A, I, Changed);
    LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Accessed locations for " << Ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations for "
 << I << ": " << getMemoryLocationsAsStr(MLK
) << "\n"; } } while (false)
                      << ": " << getMemoryLocationsAsStr(MLK) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations for "
 << I << ": " << getMemoryLocationsAsStr(MLK
) << "\n"; } } while (false);
    removeAssumedBits(inverseLocation(MLK, false, false));
    // Stop once only the valid bit set in the *not assumed location*, thus
    // once we don't actually exclude any memory locations in the state.
    return getAssumedNotAccessedLocation() != VALID_STATE;
  };

  bool UsedAssumedInformation = false;
  if (!A.checkForAllReadWriteInstructions(CheckRWInst, *this,
                                          UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  Changed |= AssumedState != getAssumed();
  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_FN_ATTR(readnone){ static llvm::Statistic NumIRFunction_readnone = {"attributor"
, "NumIRFunction_readnone", ("Number of " "functions" " marked '"
 "readnone" "'")};; ++(NumIRFunction_readnone); }
  else if (isAssumedArgMemOnly())
    STATS_DECLTRACK_FN_ATTR(argmemonly){ static llvm::Statistic NumIRFunction_argmemonly = {"attributor"
, "NumIRFunction_argmemonly", ("Number of " "functions" " marked '"
 "argmemonly" "'")};; ++(NumIRFunction_argmemonly); }
  else if (isAssumedInaccessibleMemOnly())
    STATS_DECLTRACK_FN_ATTR(inaccessiblememonly){ static llvm::Statistic NumIRFunction_inaccessiblememonly = {
"attributor", "NumIRFunction_inaccessiblememonly", ("Number of "
 "functions" " marked '" "inaccessiblememonly" "'")};; ++(NumIRFunction_inaccessiblememonly
); }
  else if (isAssumedInaccessibleOrArgMemOnly())
    STATS_DECLTRACK_FN_ATTR(inaccessiblememorargmemonly){ static llvm::Statistic NumIRFunction_inaccessiblememorargmemonly
 = {"attributor", "NumIRFunction_inaccessiblememorargmemonly"
, ("Number of " "functions" " marked '" "inaccessiblememorargmemonly"
 "'")};; ++(NumIRFunction_inaccessiblememorargmemonly); }
}
8025};

8027/// AAMemoryLocation attribute for call sites.
8028struct AAMemoryLocationCallSite final : AAMemoryLocationImpl {
AAMemoryLocationCallSite(const IRPosition &IRP, Attributor &A)
    : AAMemoryLocationImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryLocationImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || F->isDeclaration())
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  // TODO: Once we have call site specific value information we can provide
  //       call site specific liveness liveness information and then it makes
  //       sense to specialize attributes for call sites arguments instead of
  //       redirecting requests to the callee argument.
  Function *F = getAssociatedFunction();
  const IRPosition &FnPos = IRPosition::function(*F);
  auto &FnAA =
      A.getAAFor<AAMemoryLocation>(*this, FnPos, DepClassTy::REQUIRED);
  bool Changed = false;
  auto AccessPred = [&](const Instruction *I, const Value *Ptr,
                        AccessKind Kind, MemoryLocationsKind MLK) {
    updateStateAndAccessesMap(getState(), MLK, I, Ptr, Changed,
                              getAccessKindFromInst(I));
    return true;
  };
  if (!FnAA.checkForAllAccessesToMemoryKind(AccessPred, ALL_LOCATIONS))
    return indicatePessimisticFixpoint();
  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  if (isAssumedReadNone())
    STATS_DECLTRACK_CS_ATTR(readnone){ static llvm::Statistic NumIRCS_readnone = {"attributor", "NumIRCS_readnone"
, ("Number of " "call site" " marked '" "readnone" "'")};; ++
(NumIRCS_readnone); }
}
8067};

8069/// ------------------ Value Constant Range Attribute -------------------------

8071struct AAValueConstantRangeImpl : AAValueConstantRange {
using StateType = IntegerRangeState;
AAValueConstantRangeImpl(const IRPosition &IRP, Attributor &A)
    : AAValueConstantRange(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  if (A.hasSimplificationCallback(getIRPosition())) {
    indicatePessimisticFixpoint();
    return;
  }

  // Intersect a range given by SCEV.
  intersectKnown(getConstantRangeFromSCEV(A, getCtxI()));

  // Intersect a range given by LVI.
  intersectKnown(getConstantRangeFromLVI(A, getCtxI()));
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  std::string Str;
  llvm::raw_string_ostream OS(Str);
  OS << "range(" << getBitWidth() << ")<";
  getKnown().print(OS);
  OS << " / ";
  getAssumed().print(OS);
  OS << ">";
  return OS.str();
}

/// Helper function to get a SCEV expr for the associated value at program
/// point \p I.
const SCEV *getSCEV(Attributor &A, const Instruction *I = nullptr) const {
  if (!getAnchorScope())
    return nullptr;

  ScalarEvolution *SE =
      A.getInfoCache().getAnalysisResultForFunction<ScalarEvolutionAnalysis>(
          *getAnchorScope());

  LoopInfo *LI = A.getInfoCache().getAnalysisResultForFunction<LoopAnalysis>(
      *getAnchorScope());

  if (!SE || !LI)
    return nullptr;

  const SCEV *S = SE->getSCEV(&getAssociatedValue());
  if (!I)
    return S;

  return SE->getSCEVAtScope(S, LI->getLoopFor(I->getParent()));
}

/// Helper function to get a range from SCEV for the associated value at
/// program point \p I.
ConstantRange getConstantRangeFromSCEV(Attributor &A,
                                       const Instruction *I = nullptr) const {
  if (!getAnchorScope())
    return getWorstState(getBitWidth());

  ScalarEvolution *SE =
      A.getInfoCache().getAnalysisResultForFunction<ScalarEvolutionAnalysis>(
          *getAnchorScope());

  const SCEV *S = getSCEV(A, I);
  if (!SE || !S)
    return getWorstState(getBitWidth());

  return SE->getUnsignedRange(S);
}

/// Helper function to get a range from LVI for the associated value at
/// program point \p I.
ConstantRange
getConstantRangeFromLVI(Attributor &A,
                        const Instruction *CtxI = nullptr) const {
  if (!getAnchorScope())
    return getWorstState(getBitWidth());

  LazyValueInfo *LVI =
      A.getInfoCache().getAnalysisResultForFunction<LazyValueAnalysis>(
          *getAnchorScope());

  if (!LVI || !CtxI)
    return getWorstState(getBitWidth());
  return LVI->getConstantRange(&getAssociatedValue(),
                               const_cast<Instruction *>(CtxI));
}

/// Return true if \p CtxI is valid for querying outside analyses.
/// This basically makes sure we do not ask intra-procedural analysis
/// about a context in the wrong function or a context that violates
/// dominance assumptions they might have. The \p AllowAACtxI flag indicates
/// if the original context of this AA is OK or should be considered invalid.
bool isValidCtxInstructionForOutsideAnalysis(Attributor &A,
                                             const Instruction *CtxI,
                                             bool AllowAACtxI) const {
  if (!CtxI || (!AllowAACtxI && CtxI == getCtxI()))
    return false;

  // Our context might be in a different function, neither intra-procedural
  // analysis (ScalarEvolution nor LazyValueInfo) can handle that.
  if (!AA::isValidInScope(getAssociatedValue(), CtxI->getFunction()))
    return false;

  // If the context is not dominated by the value there are paths to the
  // context that do not define the value. This cannot be handled by
  // LazyValueInfo so we need to bail.
  if (auto *I = dyn_cast<Instruction>(&getAssociatedValue())) {
    InformationCache &InfoCache = A.getInfoCache();
    const DominatorTree *DT =
        InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(
            *I->getFunction());
    return DT && DT->dominates(I, CtxI);
  }

  return true;
}

/// See AAValueConstantRange::getKnownConstantRange(..).
ConstantRange
getKnownConstantRange(Attributor &A,
                      const Instruction *CtxI = nullptr) const override {
  if (!isValidCtxInstructionForOutsideAnalysis(A, CtxI,
                                               /* AllowAACtxI */ false))
    return getKnown();

  ConstantRange LVIR = getConstantRangeFromLVI(A, CtxI);
  ConstantRange SCEVR = getConstantRangeFromSCEV(A, CtxI);
  return getKnown().intersectWith(SCEVR).intersectWith(LVIR);
}

/// See AAValueConstantRange::getAssumedConstantRange(..).
ConstantRange
getAssumedConstantRange(Attributor &A,
                        const Instruction *CtxI = nullptr) const override {
  // TODO: Make SCEV use Attributor assumption.
  //       We may be able to bound a variable range via assumptions in
  //       Attributor. ex.) If x is assumed to be in [1, 3] and y is known to
  //       evolve to x^2 + x, then we can say that y is in [2, 12].
  if (!isValidCtxInstructionForOutsideAnalysis(A, CtxI,
                                               /* AllowAACtxI */ false))
    return getAssumed();

  ConstantRange LVIR = getConstantRangeFromLVI(A, CtxI);
  ConstantRange SCEVR = getConstantRangeFromSCEV(A, CtxI);
  return getAssumed().intersectWith(SCEVR).intersectWith(LVIR);
}

/// Helper function to create MDNode for range metadata.
static MDNode *
getMDNodeForConstantRange(Type *Ty, LLVMContext &Ctx,
                          const ConstantRange &AssumedConstantRange) {
  Metadata *LowAndHigh[] = {ConstantAsMetadata::get(ConstantInt::get(
                                Ty, AssumedConstantRange.getLower())),
                            ConstantAsMetadata::get(ConstantInt::get(
                                Ty, AssumedConstantRange.getUpper()))};
  return MDNode::get(Ctx, LowAndHigh);
}

/// Return true if \p Assumed is included in \p KnownRanges.
static bool isBetterRange(const ConstantRange &Assumed, MDNode *KnownRanges) {

  if (Assumed.isFullSet())
    return false;

  if (!KnownRanges)
    return true;

  // If multiple ranges are annotated in IR, we give up to annotate assumed
  // range for now.

  // TODO:  If there exists a known range which containts assumed range, we
  // can say assumed range is better.
  if (KnownRanges->getNumOperands() > 2)
    return false;

  ConstantInt *Lower =
      mdconst::extract<ConstantInt>(KnownRanges->getOperand(0));
  ConstantInt *Upper =
      mdconst::extract<ConstantInt>(KnownRanges->getOperand(1));

  ConstantRange Known(Lower->getValue(), Upper->getValue());
  return Known.contains(Assumed) && Known != Assumed;
}

/// Helper function to set range metadata.
static bool
setRangeMetadataIfisBetterRange(Instruction *I,
                                const ConstantRange &AssumedConstantRange) {
  auto *OldRangeMD = I->getMetadata(LLVMContext::MD_range);
  if (isBetterRange(AssumedConstantRange, OldRangeMD)) {
    if (!AssumedConstantRange.isEmptySet()) {
      I->setMetadata(LLVMContext::MD_range,
                     getMDNodeForConstantRange(I->getType(), I->getContext(),
                                               AssumedConstantRange));
      return true;
    }
  }
  return false;
}

/// See AbstractAttribute::manifest()
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = ChangeStatus::UNCHANGED;
  ConstantRange AssumedConstantRange = getAssumedConstantRange(A);
  assert(!AssumedConstantRange.isFullSet() && "Invalid state")(static_cast <bool> (!AssumedConstantRange.isFullSet() &&
 "Invalid state") ? void (0) : __assert_fail ("!AssumedConstantRange.isFullSet() && \"Invalid state\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8278, __extension__
 __PRETTY_FUNCTION__));

  auto &V = getAssociatedValue();
  if (!AssumedConstantRange.isEmptySet() &&
      !AssumedConstantRange.isSingleElement()) {
    if (Instruction *I = dyn_cast<Instruction>(&V)) {
      assert(I == getCtxI() && "Should not annotate an instruction which is "(static_cast <bool> (I == getCtxI() && "Should not annotate an instruction which is "
 "not the context instruction") ? void (0) : __assert_fail ("I == getCtxI() && \"Should not annotate an instruction which is \" \"not the context instruction\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8285, __extension__
 __PRETTY_FUNCTION__))
                               "not the context instruction")(static_cast <bool> (I == getCtxI() && "Should not annotate an instruction which is "
 "not the context instruction") ? void (0) : __assert_fail ("I == getCtxI() && \"Should not annotate an instruction which is \" \"not the context instruction\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8285, __extension__
 __PRETTY_FUNCTION__));
      if (isa<CallInst>(I) || isa<LoadInst>(I))
        if (setRangeMetadataIfisBetterRange(I, AssumedConstantRange))
          Changed = ChangeStatus::CHANGED;
    }
  }

  return Changed;
}
8294};

8296struct AAValueConstantRangeArgument final
  : AAArgumentFromCallSiteArguments<
        AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState,
        true /* BridgeCallBaseContext */> {
using Base = AAArgumentFromCallSiteArguments<
    AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState,
    true /* BridgeCallBaseContext */>;
AAValueConstantRangeArgument(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  if (!getAnchorScope() || getAnchorScope()->isDeclaration()) {
    indicatePessimisticFixpoint();
  } else {
    Base::initialize(A);
  }
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_ARG_ATTR(value_range){ static llvm::Statistic NumIRArguments_value_range = {"attributor"
, "NumIRArguments_value_range", ("Number of " "arguments" " marked '"
 "value_range" "'")};; ++(NumIRArguments_value_range); }
}
8319};

8321struct AAValueConstantRangeReturned
  : AAReturnedFromReturnedValues<AAValueConstantRange,
                                 AAValueConstantRangeImpl,
                                 AAValueConstantRangeImpl::StateType,
                                 /* PropogateCallBaseContext */ true> {
using Base =
    AAReturnedFromReturnedValues<AAValueConstantRange,
                                 AAValueConstantRangeImpl,
                                 AAValueConstantRangeImpl::StateType,
                                 /* PropogateCallBaseContext */ true>;
AAValueConstantRangeReturned(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FNRET_ATTR(value_range){ static llvm::Statistic NumIRFunctionReturn_value_range = {"attributor"
, "NumIRFunctionReturn_value_range", ("Number of " "function returns"
 " marked '" "value_range" "'")};; ++(NumIRFunctionReturn_value_range
); }
}
8341};

8343struct AAValueConstantRangeFloating : AAValueConstantRangeImpl {
AAValueConstantRangeFloating(const IRPosition &IRP, Attributor &A)
    : AAValueConstantRangeImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAValueConstantRangeImpl::initialize(A);
  if (isAtFixpoint())
    return;

  Value &V = getAssociatedValue();

  if (auto *C = dyn_cast<ConstantInt>(&V)) {
    unionAssumed(ConstantRange(C->getValue()));
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<UndefValue>(&V)) {
    // Collapse the undef state to 0.
    unionAssumed(ConstantRange(APInt(getBitWidth(), 0)));
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<CallBase>(&V))
    return;

  if (isa<BinaryOperator>(&V) || isa<CmpInst>(&V) || isa<CastInst>(&V))
    return;

  // If it is a load instruction with range metadata, use it.
  if (LoadInst *LI = dyn_cast<LoadInst>(&V))
    if (auto *RangeMD = LI->getMetadata(LLVMContext::MD_range)) {
      intersectKnown(getConstantRangeFromMetadata(*RangeMD));
      return;
    }

  // We can work with PHI and select instruction as we traverse their operands
  // during update.
  if (isa<SelectInst>(V) || isa<PHINode>(V))
    return;

  // Otherwise we give up.
  indicatePessimisticFixpoint();

  LLVM_DEBUG(dbgs() << "[AAValueConstantRange] We give up: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] We give up: "
 << getAssociatedValue() << "\n"; } } while (false
)
                    << getAssociatedValue() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] We give up: "
 << getAssociatedValue() << "\n"; } } while (false
);
}

bool calculateBinaryOperator(
    Attributor &A, BinaryOperator *BinOp, IntegerRangeState &T,
    const Instruction *CtxI,
    SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  Value *LHS = BinOp->getOperand(0);
  Value *RHS = BinOp->getOperand(1);

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return true;
  if (!SimplifiedLHS.getValue())
    return false;
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return true;
  if (!SimplifiedRHS.getValue())
    return false;
  RHS = *SimplifiedRHS;

  // TODO: Allow non integers as well.
  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return false;

  auto &LHSAA = A.getAAFor<AAValueConstantRange>(
      *this, IRPosition::value(*LHS, getCallBaseContext()),
      DepClassTy::REQUIRED);
  QuerriedAAs.push_back(&LHSAA);
  auto LHSAARange = LHSAA.getAssumedConstantRange(A, CtxI);

  auto &RHSAA = A.getAAFor<AAValueConstantRange>(
      *this, IRPosition::value(*RHS, getCallBaseContext()),
      DepClassTy::REQUIRED);
  QuerriedAAs.push_back(&RHSAA);
  auto RHSAARange = RHSAA.getAssumedConstantRange(A, CtxI);

  auto AssumedRange = LHSAARange.binaryOp(BinOp->getOpcode(), RHSAARange);

  T.unionAssumed(AssumedRange);

  // TODO: Track a known state too.

  return T.isValidState();
}

bool calculateCastInst(
    Attributor &A, CastInst *CastI, IntegerRangeState &T,
    const Instruction *CtxI,
    SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  assert(CastI->getNumOperands() == 1 && "Expected cast to be unary!")(static_cast <bool> (CastI->getNumOperands() == 1 &&
 "Expected cast to be unary!") ? void (0) : __assert_fail ("CastI->getNumOperands() == 1 && \"Expected cast to be unary!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8449, __extension__
 __PRETTY_FUNCTION__));
  // TODO: Allow non integers as well.
  Value *OpV = CastI->getOperand(0);

  // Simplify the operand first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedOpV =
      A.getAssumedSimplified(IRPosition::value(*OpV, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedOpV.hasValue())
    return true;
  if (!SimplifiedOpV.getValue())
    return false;
  OpV = *SimplifiedOpV;

  if (!OpV->getType()->isIntegerTy())
    return false;

  auto &OpAA = A.getAAFor<AAValueConstantRange>(
      *this, IRPosition::value(*OpV, getCallBaseContext()),
      DepClassTy::REQUIRED);
  QuerriedAAs.push_back(&OpAA);
  T.unionAssumed(
      OpAA.getAssumed().castOp(CastI->getOpcode(), getState().getBitWidth()));
  return T.isValidState();
}

bool
calculateCmpInst(Attributor &A, CmpInst *CmpI, IntegerRangeState &T,
                 const Instruction *CtxI,
                 SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  Value *LHS = CmpI->getOperand(0);
  Value *RHS = CmpI->getOperand(1);

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return true;
  if (!SimplifiedLHS.getValue())
    return false;
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return true;
  if (!SimplifiedRHS.getValue())
    return false;
  RHS = *SimplifiedRHS;

  // TODO: Allow non integers as well.
  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return false;

  auto &LHSAA = A.getAAFor<AAValueConstantRange>(
      *this, IRPosition::value(*LHS, getCallBaseContext()),
      DepClassTy::REQUIRED);
  QuerriedAAs.push_back(&LHSAA);
  auto &RHSAA = A.getAAFor<AAValueConstantRange>(
      *this, IRPosition::value(*RHS, getCallBaseContext()),
      DepClassTy::REQUIRED);
  QuerriedAAs.push_back(&RHSAA);
  auto LHSAARange = LHSAA.getAssumedConstantRange(A, CtxI);
  auto RHSAARange = RHSAA.getAssumedConstantRange(A, CtxI);

  // If one of them is empty set, we can't decide.
  if (LHSAARange.isEmptySet() || RHSAARange.isEmptySet())
    return true;

  bool MustTrue = false, MustFalse = false;

  auto AllowedRegion =
      ConstantRange::makeAllowedICmpRegion(CmpI->getPredicate(), RHSAARange);

  if (AllowedRegion.intersectWith(LHSAARange).isEmptySet())
    MustFalse = true;

  if (LHSAARange.icmp(CmpI->getPredicate(), RHSAARange))
    MustTrue = true;

  assert((!MustTrue || !MustFalse) &&(static_cast <bool> ((!MustTrue || !MustFalse) &&
 "Either MustTrue or MustFalse should be false!") ? void (0) :
 __assert_fail ("(!MustTrue || !MustFalse) && \"Either MustTrue or MustFalse should be false!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8534, __extension__
 __PRETTY_FUNCTION__))
         "Either MustTrue or MustFalse should be false!")(static_cast <bool> ((!MustTrue || !MustFalse) &&
 "Either MustTrue or MustFalse should be false!") ? void (0) :
 __assert_fail ("(!MustTrue || !MustFalse) && \"Either MustTrue or MustFalse should be false!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8534, __extension__
 __PRETTY_FUNCTION__));

  if (MustTrue)
    T.unionAssumed(ConstantRange(APInt(/* numBits */ 1, /* val */ 1)));
  else if (MustFalse)
    T.unionAssumed(ConstantRange(APInt(/* numBits */ 1, /* val */ 0)));
  else
    T.unionAssumed(ConstantRange(/* BitWidth */ 1, /* isFullSet */ true));

  LLVM_DEBUG(dbgs() << "[AAValueConstantRange] " << *CmpI << " " << LHSAAdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] " <<
 *CmpI << " " << LHSAA << " " << RHSAA
 << "\n"; } } while (false)
                    << " " << RHSAA << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] " <<
 *CmpI << " " << LHSAA << " " << RHSAA
 << "\n"; } } while (false);

  // TODO: Track a known state too.
  return T.isValidState();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto VisitValueCB = [&](Value &V, const Instruction *CtxI,
                          IntegerRangeState &T, bool Stripped) -> bool {
    Instruction *I = dyn_cast<Instruction>(&V);
    if (!I || isa<CallBase>(I)) {

      // Simplify the operand first.
      bool UsedAssumedInformation = false;
      const auto &SimplifiedOpV =
          A.getAssumedSimplified(IRPosition::value(V, getCallBaseContext()),
                                 *this, UsedAssumedInformation);
      if (!SimplifiedOpV.hasValue())
        return true;
      if (!SimplifiedOpV.getValue())
        return false;
      Value *VPtr = *SimplifiedOpV;

      // If the value is not instruction, we query AA to Attributor.
      const auto &AA = A.getAAFor<AAValueConstantRange>(
          *this, IRPosition::value(*VPtr, getCallBaseContext()),
          DepClassTy::REQUIRED);

      // Clamp operator is not used to utilize a program point CtxI.
      T.unionAssumed(AA.getAssumedConstantRange(A, CtxI));

      return T.isValidState();
    }

    SmallVector<const AAValueConstantRange *, 4> QuerriedAAs;
    if (auto *BinOp = dyn_cast<BinaryOperator>(I)) {
      if (!calculateBinaryOperator(A, BinOp, T, CtxI, QuerriedAAs))
        return false;
    } else if (auto *CmpI = dyn_cast<CmpInst>(I)) {
      if (!calculateCmpInst(A, CmpI, T, CtxI, QuerriedAAs))
        return false;
    } else if (auto *CastI = dyn_cast<CastInst>(I)) {
      if (!calculateCastInst(A, CastI, T, CtxI, QuerriedAAs))
        return false;
    } else {
      // Give up with other instructions.
      // TODO: Add other instructions

      T.indicatePessimisticFixpoint();
      return false;
    }

    // Catch circular reasoning in a pessimistic way for now.
    // TODO: Check how the range evolves and if we stripped anything, see also
    //       AADereferenceable or AAAlign for similar situations.
    for (const AAValueConstantRange *QueriedAA : QuerriedAAs) {
      if (QueriedAA != this)
        continue;
      // If we are in a stady state we do not need to worry.
      if (T.getAssumed() == getState().getAssumed())
        continue;
      T.indicatePessimisticFixpoint();
    }

    return T.isValidState();
  };

  IntegerRangeState T(getBitWidth());

  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<IntegerRangeState>(A, getIRPosition(), *this, T,
                                                VisitValueCB, getCtxI(),
                                                UsedAssumedInformation,
                                                /* UseValueSimplify */ false))
    return indicatePessimisticFixpoint();

  // Ensure that long def-use chains can't cause circular reasoning either by
  // introducing a cutoff below.
  if (clampStateAndIndicateChange(getState(), T) == ChangeStatus::UNCHANGED)
    return ChangeStatus::UNCHANGED;
  if (++NumChanges > MaxNumChanges) {
    LLVM_DEBUG(dbgs() << "[AAValueConstantRange] performed " << NumChangesdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] performed "
 << NumChanges << " but only " << MaxNumChanges
 << " are allowed to avoid cyclic reasoning."; } } while
 (false)
                      << " but only " << MaxNumChangesdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] performed "
 << NumChanges << " but only " << MaxNumChanges
 << " are allowed to avoid cyclic reasoning."; } } while
 (false)
                      << " are allowed to avoid cyclic reasoning.")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAValueConstantRange] performed "
 << NumChanges << " but only " << MaxNumChanges
 << " are allowed to avoid cyclic reasoning."; } } while
 (false);
    return indicatePessimisticFixpoint();
  }
  return ChangeStatus::CHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(value_range){ static llvm::Statistic NumIRFloating_value_range = {"attributor"
, "NumIRFloating_value_range", ("Number of floating values known to be '"
 "value_range" "'")};; ++(NumIRFloating_value_range); }
}

/// Tracker to bail after too many widening steps of the constant range.
int NumChanges = 0;

/// Upper bound for the number of allowed changes (=widening steps) for the
/// constant range before we give up.
static constexpr int MaxNumChanges = 5;
8645};

8647struct AAValueConstantRangeFunction : AAValueConstantRangeImpl {
AAValueConstantRangeFunction(const IRPosition &IRP, Attributor &A)
    : AAValueConstantRangeImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable("AAValueConstantRange(Function|CallSite)::updateImpl will "::llvm::llvm_unreachable_internal("AAValueConstantRange(Function|CallSite)::updateImpl will "
 "not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 8654)
                   "not be called")::llvm::llvm_unreachable_internal("AAValueConstantRange(Function|CallSite)::updateImpl will "
 "not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 8654);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FN_ATTR(value_range){ static llvm::Statistic NumIRFunction_value_range = {"attributor"
, "NumIRFunction_value_range", ("Number of " "functions" " marked '"
 "value_range" "'")};; ++(NumIRFunction_value_range); } }
8659};

8661struct AAValueConstantRangeCallSite : AAValueConstantRangeFunction {
AAValueConstantRangeCallSite(const IRPosition &IRP, Attributor &A)
    : AAValueConstantRangeFunction(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CS_ATTR(value_range){ static llvm::Statistic NumIRCS_value_range = {"attributor",
 "NumIRCS_value_range", ("Number of " "call site" " marked '"
 "value_range" "'")};; ++(NumIRCS_value_range); } }
8667};

8669struct AAValueConstantRangeCallSiteReturned
  : AACallSiteReturnedFromReturned<AAValueConstantRange,
                                   AAValueConstantRangeImpl,
                                   AAValueConstantRangeImpl::StateType,
                                   /* IntroduceCallBaseContext */ true> {
AAValueConstantRangeCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AACallSiteReturnedFromReturned<AAValueConstantRange,
                                     AAValueConstantRangeImpl,
                                     AAValueConstantRangeImpl::StateType,
                                     /* IntroduceCallBaseContext */ true>(IRP,
                                                                          A) {
}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // If it is a load instruction with range metadata, use the metadata.
  if (CallInst *CI = dyn_cast<CallInst>(&getAssociatedValue()))
    if (auto *RangeMD = CI->getMetadata(LLVMContext::MD_range))
      intersectKnown(getConstantRangeFromMetadata(*RangeMD));

  AAValueConstantRangeImpl::initialize(A);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSRET_ATTR(value_range){ static llvm::Statistic NumIRCSReturn_value_range = {"attributor"
, "NumIRCSReturn_value_range", ("Number of " "call site returns"
 " marked '" "value_range" "'")};; ++(NumIRCSReturn_value_range
); }
}
8696};
8697struct AAValueConstantRangeCallSiteArgument : AAValueConstantRangeFloating {
AAValueConstantRangeCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAValueConstantRangeFloating(IRP, A) {}

/// See AbstractAttribute::manifest()
ChangeStatus manifest(Attributor &A) override {
  return ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSARG_ATTR(value_range){ static llvm::Statistic NumIRCSArguments_value_range = {"attributor"
, "NumIRCSArguments_value_range", ("Number of " "call site arguments"
 " marked '" "value_range" "'")};; ++(NumIRCSArguments_value_range
); }
}
8710};

8712/// ------------------ Potential Values Attribute -------------------------

8714struct AAPotentialValuesImpl : AAPotentialValues {
using StateType = PotentialConstantIntValuesState;

AAPotentialValuesImpl(const IRPosition &IRP, Attributor &A)
    : AAPotentialValues(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  if (A.hasSimplificationCallback(getIRPosition()))
    indicatePessimisticFixpoint();
  else
    AAPotentialValues::initialize(A);
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  std::string Str;
  llvm::raw_string_ostream OS(Str);
  OS << getState();
  return OS.str();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  return indicatePessimisticFixpoint();
}
8740};

8742struct AAPotentialValuesArgument final
  : AAArgumentFromCallSiteArguments<AAPotentialValues, AAPotentialValuesImpl,
                                    PotentialConstantIntValuesState> {
using Base =
    AAArgumentFromCallSiteArguments<AAPotentialValues, AAPotentialValuesImpl,
                                    PotentialConstantIntValuesState>;
AAPotentialValuesArgument(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  if (!getAnchorScope() || getAnchorScope()->isDeclaration()) {
    indicatePessimisticFixpoint();
  } else {
    Base::initialize(A);
  }
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_ARG_ATTR(potential_values){ static llvm::Statistic NumIRArguments_potential_values = {"attributor"
, "NumIRArguments_potential_values", ("Number of " "arguments"
 " marked '" "potential_values" "'")};; ++(NumIRArguments_potential_values
); }
}
8764};

8766struct AAPotentialValuesReturned
  : AAReturnedFromReturnedValues<AAPotentialValues, AAPotentialValuesImpl> {
using Base =
    AAReturnedFromReturnedValues<AAPotentialValues, AAPotentialValuesImpl>;
AAPotentialValuesReturned(const IRPosition &IRP, Attributor &A)
    : Base(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FNRET_ATTR(potential_values){ static llvm::Statistic NumIRFunctionReturn_potential_values
 = {"attributor", "NumIRFunctionReturn_potential_values", ("Number of "
 "function returns" " marked '" "potential_values" "'")};; ++
(NumIRFunctionReturn_potential_values); }
}
8777};

8779struct AAPotentialValuesFloating : AAPotentialValuesImpl {
AAPotentialValuesFloating(const IRPosition &IRP, Attributor &A)
    : AAPotentialValuesImpl(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  AAPotentialValuesImpl::initialize(A);
  if (isAtFixpoint())
    return;

  Value &V = getAssociatedValue();

  if (auto *C = dyn_cast<ConstantInt>(&V)) {
    unionAssumed(C->getValue());
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<UndefValue>(&V)) {
    unionAssumedWithUndef();
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<BinaryOperator>(&V) || isa<ICmpInst>(&V) || isa<CastInst>(&V))
    return;

  if (isa<SelectInst>(V) || isa<PHINode>(V) || isa<LoadInst>(V))
    return;

  indicatePessimisticFixpoint();

  LLVM_DEBUG(dbgs() << "[AAPotentialValues] We give up: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPotentialValues] We give up: "
 << getAssociatedValue() << "\n"; } } while (false
)
                    << getAssociatedValue() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAPotentialValues] We give up: "
 << getAssociatedValue() << "\n"; } } while (false
);
}

static bool calculateICmpInst(const ICmpInst *ICI, const APInt &LHS,
                              const APInt &RHS) {
  return ICmpInst::compare(LHS, RHS, ICI->getPredicate());
}

static APInt calculateCastInst(const CastInst *CI, const APInt &Src,
                               uint32_t ResultBitWidth) {
  Instruction::CastOps CastOp = CI->getOpcode();
  switch (CastOp) {
  default:
    llvm_unreachable("unsupported or not integer cast")::llvm::llvm_unreachable_internal("unsupported or not integer cast"
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 8825);
  case Instruction::Trunc:
    return Src.trunc(ResultBitWidth);
  case Instruction::SExt:
    return Src.sext(ResultBitWidth);
  case Instruction::ZExt:
    return Src.zext(ResultBitWidth);
  case Instruction::BitCast:
    return Src;
  }
}

static APInt calculateBinaryOperator(const BinaryOperator *BinOp,
                                     const APInt &LHS, const APInt &RHS,
                                     bool &SkipOperation, bool &Unsupported) {
  Instruction::BinaryOps BinOpcode = BinOp->getOpcode();
  // Unsupported is set to true when the binary operator is not supported.
  // SkipOperation is set to true when UB occur with the given operand pair
  // (LHS, RHS).
  // TODO: we should look at nsw and nuw keywords to handle operations
  //       that create poison or undef value.
  switch (BinOpcode) {
  default:
    Unsupported = true;
    return LHS;
  case Instruction::Add:
    return LHS + RHS;
  case Instruction::Sub:
    return LHS - RHS;
  case Instruction::Mul:
    return LHS * RHS;
  case Instruction::UDiv:
    if (RHS.isZero()) {
      SkipOperation = true;
      return LHS;
    }
    return LHS.udiv(RHS);
  case Instruction::SDiv:
    if (RHS.isZero()) {
      SkipOperation = true;
      return LHS;
    }
    return LHS.sdiv(RHS);
  case Instruction::URem:
    if (RHS.isZero()) {
      SkipOperation = true;
      return LHS;
    }
    return LHS.urem(RHS);
  case Instruction::SRem:
    if (RHS.isZero()) {
      SkipOperation = true;
      return LHS;
    }
    return LHS.srem(RHS);
  case Instruction::Shl:
    return LHS.shl(RHS);
  case Instruction::LShr:
    return LHS.lshr(RHS);
  case Instruction::AShr:
    return LHS.ashr(RHS);
  case Instruction::And:
    return LHS & RHS;
  case Instruction::Or:
    return LHS | RHS;
  case Instruction::Xor:
    return LHS ^ RHS;
  }
}

bool calculateBinaryOperatorAndTakeUnion(const BinaryOperator *BinOp,
                                         const APInt &LHS, const APInt &RHS) {
  bool SkipOperation = false;
  bool Unsupported = false;
  APInt Result =
      calculateBinaryOperator(BinOp, LHS, RHS, SkipOperation, Unsupported);
  if (Unsupported)
    return false;
  // If SkipOperation is true, we can ignore this operand pair (L, R).
  if (!SkipOperation)
    unionAssumed(Result);
  return isValidState();
}

ChangeStatus updateWithICmpInst(Attributor &A, ICmpInst *ICI) {
  auto AssumedBefore = getAssumed();
  Value *LHS = ICI->getOperand(0);
  Value *RHS = ICI->getOperand(1);

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedLHS.getValue())
    return indicatePessimisticFixpoint();
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedRHS.getValue())
    return indicatePessimisticFixpoint();
  RHS = *SimplifiedRHS;

  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return indicatePessimisticFixpoint();

  auto &LHSAA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*LHS),
                                              DepClassTy::REQUIRED);
  if (!LHSAA.isValidState())
    return indicatePessimisticFixpoint();

  auto &RHSAA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*RHS),
                                              DepClassTy::REQUIRED);
  if (!RHSAA.isValidState())
    return indicatePessimisticFixpoint();

  const DenseSet<APInt> &LHSAAPVS = LHSAA.getAssumedSet();
  const DenseSet<APInt> &RHSAAPVS = RHSAA.getAssumedSet();

  // TODO: make use of undef flag to limit potential values aggressively.
  bool MaybeTrue = false, MaybeFalse = false;
  const APInt Zero(RHS->getType()->getIntegerBitWidth(), 0);
  if (LHSAA.undefIsContained() && RHSAA.undefIsContained()) {
    // The result of any comparison between undefs can be soundly replaced
    // with undef.
    unionAssumedWithUndef();
  } else if (LHSAA.undefIsContained()) {
    for (const APInt &R : RHSAAPVS) {
      bool CmpResult = calculateICmpInst(ICI, Zero, R);
      MaybeTrue |= CmpResult;
      MaybeFalse |= !CmpResult;
      if (MaybeTrue & MaybeFalse)
        return indicatePessimisticFixpoint();
    }
  } else if (RHSAA.undefIsContained()) {
    for (const APInt &L : LHSAAPVS) {
      bool CmpResult = calculateICmpInst(ICI, L, Zero);
      MaybeTrue |= CmpResult;
      MaybeFalse |= !CmpResult;
      if (MaybeTrue & MaybeFalse)
        return indicatePessimisticFixpoint();
    }
  } else {
    for (const APInt &L : LHSAAPVS) {
      for (const APInt &R : RHSAAPVS) {
        bool CmpResult = calculateICmpInst(ICI, L, R);
        MaybeTrue |= CmpResult;
        MaybeFalse |= !CmpResult;
        if (MaybeTrue & MaybeFalse)
          return indicatePessimisticFixpoint();
      }
    }
  }
  if (MaybeTrue)
    unionAssumed(APInt(/* numBits */ 1, /* val */ 1));
  if (MaybeFalse)
    unionAssumed(APInt(/* numBits */ 1, /* val */ 0));
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

ChangeStatus updateWithSelectInst(Attributor &A, SelectInst *SI) {
  auto AssumedBefore = getAssumed();
  Value *LHS = SI->getTrueValue();
  Value *RHS = SI->getFalseValue();

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedLHS.getValue())
    return indicatePessimisticFixpoint();
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedRHS.getValue())
    return indicatePessimisticFixpoint();
  RHS = *SimplifiedRHS;

  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return indicatePessimisticFixpoint();

  Optional<Constant *> C = A.getAssumedConstant(*SI->getCondition(), *this,
                                                UsedAssumedInformation);

  // Check if we only need one operand.
  bool OnlyLeft = false, OnlyRight = false;
  if (C.hasValue() && *C && (*C)->isOneValue())
    OnlyLeft = true;
  else if (C.hasValue() && *C && (*C)->isZeroValue())
    OnlyRight = true;

  const AAPotentialValues *LHSAA = nullptr, *RHSAA = nullptr;
  if (!OnlyRight) {
    LHSAA = &A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*LHS),
                                           DepClassTy::REQUIRED);
    if (!LHSAA->isValidState())
      return indicatePessimisticFixpoint();
  }
  if (!OnlyLeft) {
    RHSAA = &A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*RHS),
                                           DepClassTy::REQUIRED);
    if (!RHSAA->isValidState())
      return indicatePessimisticFixpoint();
  }

  if (!LHSAA || !RHSAA) {
    // select (true/false), lhs, rhs
    auto *OpAA = LHSAA ? LHSAA : RHSAA;

    if (OpAA->undefIsContained())
      unionAssumedWithUndef();
    else
      unionAssumed(*OpAA);

  } else if (LHSAA->undefIsContained() && RHSAA->undefIsContained()) {
    // select i1 *, undef , undef => undef
    unionAssumedWithUndef();
  } else {
    unionAssumed(*LHSAA);
    unionAssumed(*RHSAA);
  }
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

ChangeStatus updateWithCastInst(Attributor &A, CastInst *CI) {
  auto AssumedBefore = getAssumed();
  if (!CI->isIntegerCast())
    return indicatePessimisticFixpoint();
  assert(CI->getNumOperands() == 1 && "Expected cast to be unary!")(static_cast <bool> (CI->getNumOperands() == 1 &&
 "Expected cast to be unary!") ? void (0) : __assert_fail ("CI->getNumOperands() == 1 && \"Expected cast to be unary!\""
, "llvm/lib/Transforms/IPO/AttributorAttributes.cpp", 9068, __extension__
 __PRETTY_FUNCTION__));
  uint32_t ResultBitWidth = CI->getDestTy()->getIntegerBitWidth();
  Value *Src = CI->getOperand(0);

  // Simplify the operand first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedSrc =
      A.getAssumedSimplified(IRPosition::value(*Src, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedSrc.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedSrc.getValue())
    return indicatePessimisticFixpoint();
  Src = *SimplifiedSrc;

  auto &SrcAA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*Src),
                                              DepClassTy::REQUIRED);
  if (!SrcAA.isValidState())
    return indicatePessimisticFixpoint();
  const DenseSet<APInt> &SrcAAPVS = SrcAA.getAssumedSet();
  if (SrcAA.undefIsContained())
    unionAssumedWithUndef();
  else {
    for (const APInt &S : SrcAAPVS) {
      APInt T = calculateCastInst(CI, S, ResultBitWidth);
      unionAssumed(T);
    }
  }
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

ChangeStatus updateWithBinaryOperator(Attributor &A, BinaryOperator *BinOp) {
  auto AssumedBefore = getAssumed();
  Value *LHS = BinOp->getOperand(0);
  Value *RHS = BinOp->getOperand(1);

  // Simplify the operands first.
  bool UsedAssumedInformation = false;
  const auto &SimplifiedLHS =
      A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedLHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedLHS.getValue())
    return indicatePessimisticFixpoint();
  LHS = *SimplifiedLHS;

  const auto &SimplifiedRHS =
      A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()),
                             *this, UsedAssumedInformation);
  if (!SimplifiedRHS.hasValue())
    return ChangeStatus::UNCHANGED;
  if (!SimplifiedRHS.getValue())
    return indicatePessimisticFixpoint();
  RHS = *SimplifiedRHS;

  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return indicatePessimisticFixpoint();

  auto &LHSAA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*LHS),
                                              DepClassTy::REQUIRED);
  if (!LHSAA.isValidState())
    return indicatePessimisticFixpoint();

  auto &RHSAA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(*RHS),
                                              DepClassTy::REQUIRED);
  if (!RHSAA.isValidState())
    return indicatePessimisticFixpoint();

  const DenseSet<APInt> &LHSAAPVS = LHSAA.getAssumedSet();
  const DenseSet<APInt> &RHSAAPVS = RHSAA.getAssumedSet();
  const APInt Zero = APInt(LHS->getType()->getIntegerBitWidth(), 0);

  // TODO: make use of undef flag to limit potential values aggressively.
  if (LHSAA.undefIsContained() && RHSAA.undefIsContained()) {
    if (!calculateBinaryOperatorAndTakeUnion(BinOp, Zero, Zero))
      return indicatePessimisticFixpoint();
  } else if (LHSAA.undefIsContained()) {
    for (const APInt &R : RHSAAPVS) {
      if (!calculateBinaryOperatorAndTakeUnion(BinOp, Zero, R))
        return indicatePessimisticFixpoint();
    }
  } else if (RHSAA.undefIsContained()) {
    for (const APInt &L : LHSAAPVS) {
      if (!calculateBinaryOperatorAndTakeUnion(BinOp, L, Zero))
        return indicatePessimisticFixpoint();
    }
  } else {
    for (const APInt &L : LHSAAPVS) {
      for (const APInt &R : RHSAAPVS) {
        if (!calculateBinaryOperatorAndTakeUnion(BinOp, L, R))
          return indicatePessimisticFixpoint();
      }
    }
  }
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

ChangeStatus updateWithPHINode(Attributor &A, PHINode *PHI) {
  auto AssumedBefore = getAssumed();
  for (unsigned u = 0, e = PHI->getNumIncomingValues(); u < e; u++) {
    Value *IncomingValue = PHI->getIncomingValue(u);

    // Simplify the operand first.
    bool UsedAssumedInformation = false;
    const auto &SimplifiedIncomingValue = A.getAssumedSimplified(
        IRPosition::value(*IncomingValue, getCallBaseContext()), *this,
        UsedAssumedInformation);
    if (!SimplifiedIncomingValue.hasValue())
      continue;
    if (!SimplifiedIncomingValue.getValue())
      return indicatePessimisticFixpoint();
    IncomingValue = *SimplifiedIncomingValue;

    auto &PotentialValuesAA = A.getAAFor<AAPotentialValues>(
        *this, IRPosition::value(*IncomingValue), DepClassTy::REQUIRED);
    if (!PotentialValuesAA.isValidState())
      return indicatePessimisticFixpoint();
    if (PotentialValuesAA.undefIsContained())
      unionAssumedWithUndef();
    else
      unionAssumed(PotentialValuesAA.getAssumed());
  }
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

ChangeStatus updateWithLoad(Attributor &A, LoadInst &L) {
  if (!L.getType()->isIntegerTy())
    return indicatePessimisticFixpoint();

  auto Union = [&](Value &V) {
    if (isa<UndefValue>(V)) {
      unionAssumedWithUndef();
      return true;
    }
    if (ConstantInt *CI = dyn_cast<ConstantInt>(&V)) {
      unionAssumed(CI->getValue());
      return true;
    }
    return false;
  };
  auto AssumedBefore = getAssumed();

  if (!AAValueSimplifyImpl::handleLoad(A, *this, L, Union))
    return indicatePessimisticFixpoint();

  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  Value &V = getAssociatedValue();
  Instruction *I = dyn_cast<Instruction>(&V);

  if (auto *ICI = dyn_cast<ICmpInst>(I))
    return updateWithICmpInst(A, ICI);

  if (auto *SI = dyn_cast<SelectInst>(I))
    return updateWithSelectInst(A, SI);

  if (auto *CI = dyn_cast<CastInst>(I))
    return updateWithCastInst(A, CI);

  if (auto *BinOp = dyn_cast<BinaryOperator>(I))
    return updateWithBinaryOperator(A, BinOp);

  if (auto *PHI = dyn_cast<PHINode>(I))
    return updateWithPHINode(A, PHI);

  if (auto *L = dyn_cast<LoadInst>(I))
    return updateWithLoad(A, *L);

  return indicatePessimisticFixpoint();
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FLOATING_ATTR(potential_values){ static llvm::Statistic NumIRFloating_potential_values = {"attributor"
, "NumIRFloating_potential_values", ("Number of floating values known to be '"
 "potential_values" "'")};; ++(NumIRFloating_potential_values
); }
}
9251};

9253struct AAPotentialValuesFunction : AAPotentialValuesImpl {
AAPotentialValuesFunction(const IRPosition &IRP, Attributor &A)
    : AAPotentialValuesImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable("AAPotentialValues(Function|CallSite)::updateImpl will "::llvm::llvm_unreachable_internal("AAPotentialValues(Function|CallSite)::updateImpl will "
 "not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 9260)
                   "not be called")::llvm::llvm_unreachable_internal("AAPotentialValues(Function|CallSite)::updateImpl will "
 "not be called", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 9260);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_FN_ATTR(potential_values){ static llvm::Statistic NumIRFunction_potential_values = {"attributor"
, "NumIRFunction_potential_values", ("Number of " "functions"
 " marked '" "potential_values" "'")};; ++(NumIRFunction_potential_values
); }
}
9267};

9269struct AAPotentialValuesCallSite : AAPotentialValuesFunction {
AAPotentialValuesCallSite(const IRPosition &IRP, Attributor &A)
    : AAPotentialValuesFunction(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CS_ATTR(potential_values){ static llvm::Statistic NumIRCS_potential_values = {"attributor"
, "NumIRCS_potential_values", ("Number of " "call site" " marked '"
 "potential_values" "'")};; ++(NumIRCS_potential_values); }
}
9277};

9279struct AAPotentialValuesCallSiteReturned
  : AACallSiteReturnedFromReturned<AAPotentialValues, AAPotentialValuesImpl> {
AAPotentialValuesCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AACallSiteReturnedFromReturned<AAPotentialValues,
                                     AAPotentialValuesImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSRET_ATTR(potential_values){ static llvm::Statistic NumIRCSReturn_potential_values = {"attributor"
, "NumIRCSReturn_potential_values", ("Number of " "call site returns"
 " marked '" "potential_values" "'")};; ++(NumIRCSReturn_potential_values
); }
}
9289};

9291struct AAPotentialValuesCallSiteArgument : AAPotentialValuesFloating {
AAPotentialValuesCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AAPotentialValuesFloating(IRP, A) {}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  AAPotentialValuesImpl::initialize(A);
  if (isAtFixpoint())
    return;

  Value &V = getAssociatedValue();

  if (auto *C = dyn_cast<ConstantInt>(&V)) {
    unionAssumed(C->getValue());
    indicateOptimisticFixpoint();
    return;
  }

  if (isa<UndefValue>(&V)) {
    unionAssumedWithUndef();
    indicateOptimisticFixpoint();
    return;
  }
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  Value &V = getAssociatedValue();
  auto AssumedBefore = getAssumed();
  auto &AA = A.getAAFor<AAPotentialValues>(*this, IRPosition::value(V),
                                           DepClassTy::REQUIRED);
  const auto &S = AA.getAssumed();
  unionAssumed(S);
  return AssumedBefore == getAssumed() ? ChangeStatus::UNCHANGED
                                       : ChangeStatus::CHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECLTRACK_CSARG_ATTR(potential_values){ static llvm::Statistic NumIRCSArguments_potential_values = {
"attributor", "NumIRCSArguments_potential_values", ("Number of "
 "call site arguments" " marked '" "potential_values" "'")};;
 ++(NumIRCSArguments_potential_values); }
}
9332};

9334/// ------------------------ NoUndef Attribute ---------------------------------
9335struct AANoUndefImpl : AANoUndef {
AANoUndefImpl(const IRPosition &IRP, Attributor &A) : AANoUndef(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (getIRPosition().hasAttr({Attribute::NoUndef})) {
    indicateOptimisticFixpoint();
    return;
  }
  Value &V = getAssociatedValue();
  if (isa<UndefValue>(V))
    indicatePessimisticFixpoint();
  else if (isa<FreezeInst>(V))
    indicateOptimisticFixpoint();
  else if (getPositionKind() != IRPosition::IRP_RETURNED &&
           isGuaranteedNotToBeUndefOrPoison(&V))
    indicateOptimisticFixpoint();
  else
    AANoUndef::initialize(A);
}

/// See followUsesInMBEC
bool followUseInMBEC(Attributor &A, const Use *U, const Instruction *I,
                     AANoUndef::StateType &State) {
  const Value *UseV = U->get();
  const DominatorTree *DT = nullptr;
  AssumptionCache *AC = nullptr;
  InformationCache &InfoCache = A.getInfoCache();
  if (Function *F = getAnchorScope()) {
    DT = InfoCache.getAnalysisResultForFunction<DominatorTreeAnalysis>(*F);
    AC = InfoCache.getAnalysisResultForFunction<AssumptionAnalysis>(*F);
  }
  State.setKnown(isGuaranteedNotToBeUndefOrPoison(UseV, AC, I, DT));
  bool TrackUse = false;
  // Track use for instructions which must produce undef or poison bits when
  // at least one operand contains such bits.
  if (isa<CastInst>(*I) || isa<GetElementPtrInst>(*I))
    TrackUse = true;
  return TrackUse;
}

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? "noundef" : "may-undef-or-poison";
}

ChangeStatus manifest(Attributor &A) override {
  // We don't manifest noundef attribute for dead positions because the
  // associated values with dead positions would be replaced with undef
  // values.
  bool UsedAssumedInformation = false;
  if (A.isAssumedDead(getIRPosition(), nullptr, nullptr,
                      UsedAssumedInformation))
    return ChangeStatus::UNCHANGED;
  // A position whose simplified value does not have any value is
  // considered to be dead. We don't manifest noundef in such positions for
  // the same reason above.
  if (!A.getAssumedSimplified(getIRPosition(), *this, UsedAssumedInformation)
           .hasValue())
    return ChangeStatus::UNCHANGED;
  return AANoUndef::manifest(A);
}
9397};

9399struct AANoUndefFloating : public AANoUndefImpl {
AANoUndefFloating(const IRPosition &IRP, Attributor &A)
    : AANoUndefImpl(IRP, A) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoUndefImpl::initialize(A);
  if (!getState().isAtFixpoint())
    if (Instruction *CtxI = getCtxI())
      followUsesInMBEC(*this, A, getState(), *CtxI);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto VisitValueCB = [&](Value &V, const Instruction *CtxI,
                          AANoUndef::StateType &T, bool Stripped) -> bool {
    const auto &AA = A.getAAFor<AANoUndef>(*this, IRPosition::value(V),
                                           DepClassTy::REQUIRED);
    if (!Stripped && this == &AA) {
      T.indicatePessimisticFixpoint();
    } else {
      const AANoUndef::StateType &S =
          static_cast<const AANoUndef::StateType &>(AA.getState());
      T ^= S;
    }
    return T.isValidState();
  };

  StateType T;
  bool UsedAssumedInformation = false;
  if (!genericValueTraversal<StateType>(A, getIRPosition(), *this, T,
                                        VisitValueCB, getCtxI(),
                                        UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return clampStateAndIndicateChange(getState(), T);
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noundef){ static llvm::Statistic NumIRFunctionReturn_noundef = {"attributor"
, "NumIRFunctionReturn_noundef", ("Number of " "function returns"
 " marked '" "noundef" "'")};; ++(NumIRFunctionReturn_noundef
); } }
9439};

9441struct AANoUndefReturned final
  : AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl> {
AANoUndefReturned(const IRPosition &IRP, Attributor &A)
    : AAReturnedFromReturnedValues<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_FNRET_ATTR(noundef){ static llvm::Statistic NumIRFunctionReturn_noundef = {"attributor"
, "NumIRFunctionReturn_noundef", ("Number of " "function returns"
 " marked '" "noundef" "'")};; ++(NumIRFunctionReturn_noundef
); } }
9448};

9450struct AANoUndefArgument final
  : AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl> {
AANoUndefArgument(const IRPosition &IRP, Attributor &A)
    : AAArgumentFromCallSiteArguments<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_ARG_ATTR(noundef){ static llvm::Statistic NumIRArguments_noundef = {"attributor"
, "NumIRArguments_noundef", ("Number of " "arguments" " marked '"
 "noundef" "'")};; ++(NumIRArguments_noundef); } }
9457};

9459struct AANoUndefCallSiteArgument final : AANoUndefFloating {
AANoUndefCallSiteArgument(const IRPosition &IRP, Attributor &A)
    : AANoUndefFloating(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSARG_ATTR(noundef){ static llvm::Statistic NumIRCSArguments_noundef = {"attributor"
, "NumIRCSArguments_noundef", ("Number of " "call site arguments"
 " marked '" "noundef" "'")};; ++(NumIRCSArguments_noundef); } }
9465};

9467struct AANoUndefCallSiteReturned final
  : AACallSiteReturnedFromReturned<AANoUndef, AANoUndefImpl> {
AANoUndefCallSiteReturned(const IRPosition &IRP, Attributor &A)
    : AACallSiteReturnedFromReturned<AANoUndef, AANoUndefImpl>(IRP, A) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override { STATS_DECLTRACK_CSRET_ATTR(noundef){ static llvm::Statistic NumIRCSReturn_noundef = {"attributor"
, "NumIRCSReturn_noundef", ("Number of " "call site returns" " marked '"
 "noundef" "'")};; ++(NumIRCSReturn_noundef); } }
9474};

9476struct AACallEdgesImpl : public AACallEdges {
AACallEdgesImpl(const IRPosition &IRP, Attributor &A) : AACallEdges(IRP, A) {}

virtual const SetVector<Function *> &getOptimisticEdges() const override {
  return CalledFunctions;
}

virtual bool hasUnknownCallee() const override { return HasUnknownCallee; }

virtual bool hasNonAsmUnknownCallee() const override {
  return HasUnknownCalleeNonAsm;
}

const std::string getAsStr() const override {
  return "CallEdges[" + std::to_string(HasUnknownCallee) + "," +
         std::to_string(CalledFunctions.size()) + "]";
}

void trackStatistics() const override {}

9496protected:
void addCalledFunction(Function *Fn, ChangeStatus &Change) {
  if (CalledFunctions.insert(Fn)) {
    Change = ChangeStatus::CHANGED;
    LLVM_DEBUG(dbgs() << "[AACallEdges] New call edge: " << Fn->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AACallEdges] New call edge: "
 << Fn->getName() << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AACallEdges] New call edge: "
 << Fn->getName() << "\n"; } } while (false);
  }
}

void setHasUnknownCallee(bool NonAsm, ChangeStatus &Change) {
  if (!HasUnknownCallee)
    Change = ChangeStatus::CHANGED;
  if (NonAsm && !HasUnknownCalleeNonAsm)
    Change = ChangeStatus::CHANGED;
  HasUnknownCalleeNonAsm |= NonAsm;
  HasUnknownCallee = true;
}

9514private:
/// Optimistic set of functions that might be called by this position.
SetVector<Function *> CalledFunctions;

/// Is there any call with a unknown callee.
bool HasUnknownCallee = false;

/// Is there any call with a unknown callee, excluding any inline asm.
bool HasUnknownCalleeNonAsm = false;
9523};

9525struct AACallEdgesCallSite : public AACallEdgesImpl {
AACallEdgesCallSite(const IRPosition &IRP, Attributor &A)
    : AACallEdgesImpl(IRP, A) {}
/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Change = ChangeStatus::UNCHANGED;

  auto VisitValue = [&](Value &V, const Instruction *CtxI, bool &HasUnknown,
                        bool Stripped) -> bool {
    if (Function *Fn = dyn_cast<Function>(&V)) {
      addCalledFunction(Fn, Change);
    } else {
      LLVM_DEBUG(dbgs() << "[AACallEdges] Unrecognized value: " << V << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AACallEdges] Unrecognized value: "
 << V << "\n"; } } while (false);
      setHasUnknownCallee(true, Change);
    }

    // Explore all values.
    return true;
  };

  // Process any value that we might call.
  auto ProcessCalledOperand = [&](Value *V) {
    bool DummyValue = false;
    bool UsedAssumedInformation = false;
    if (!genericValueTraversal<bool>(A, IRPosition::value(*V), *this,
                                     DummyValue, VisitValue, nullptr,
                                     UsedAssumedInformation, false)) {
      // If we haven't gone through all values, assume that there are unknown
      // callees.
      setHasUnknownCallee(true, Change);
    }
  };

  CallBase *CB = cast<CallBase>(getCtxI());

  if (CB->isInlineAsm()) {
    setHasUnknownCallee(false, Change);
    return Change;
  }

  // Process callee metadata if available.
  if (auto *MD = getCtxI()->getMetadata(LLVMContext::MD_callees)) {
    for (auto &Op : MD->operands()) {
      Function *Callee = mdconst::dyn_extract_or_null<Function>(Op);
      if (Callee)
        addCalledFunction(Callee, Change);
    }
    return Change;
  }

  // The most simple case.
  ProcessCalledOperand(CB->getCalledOperand());

  // Process callback functions.
  SmallVector<const Use *, 4u> CallbackUses;
  AbstractCallSite::getCallbackUses(*CB, CallbackUses);
  for (const Use *U : CallbackUses)
    ProcessCalledOperand(U->get());

  return Change;
}
9586};

9588struct AACallEdgesFunction : public AACallEdgesImpl {
AACallEdgesFunction(const IRPosition &IRP, Attributor &A)
    : AACallEdgesImpl(IRP, A) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Change = ChangeStatus::UNCHANGED;

  auto ProcessCallInst = [&](Instruction &Inst) {
    CallBase &CB = cast<CallBase>(Inst);

    auto &CBEdges = A.getAAFor<AACallEdges>(
        *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);
    if (CBEdges.hasNonAsmUnknownCallee())
      setHasUnknownCallee(true, Change);
    if (CBEdges.hasUnknownCallee())
      setHasUnknownCallee(false, Change);

    for (Function *F : CBEdges.getOptimisticEdges())
      addCalledFunction(F, Change);

    return true;
  };

  // Visit all callable instructions.
  bool UsedAssumedInformation = false;
  if (!A.checkForAllCallLikeInstructions(ProcessCallInst, *this,
                                         UsedAssumedInformation,
                                         /* CheckBBLivenessOnly */ true)) {
    // If we haven't looked at all call like instructions, assume that there
    // are unknown callees.
    setHasUnknownCallee(true, Change);
  }

  return Change;
}
9624};

9626struct AAFunctionReachabilityFunction : public AAFunctionReachability {
9627private:
struct QuerySet {
  void markReachable(const Function &Fn) {
    Reachable.insert(&Fn);
    Unreachable.erase(&Fn);
  }

  /// If there is no information about the function None is returned.
  Optional<bool> isCachedReachable(const Function &Fn) {
    // Assume that we can reach the function.
    // TODO: Be more specific with the unknown callee.
    if (CanReachUnknownCallee)
      return true;

    if (Reachable.count(&Fn))
      return true;

    if (Unreachable.count(&Fn))
      return false;

    return llvm::None;
  }

  /// Set of functions that we know for sure is reachable.
  DenseSet<const Function *> Reachable;

  /// Set of functions that are unreachable, but might become reachable.
  DenseSet<const Function *> Unreachable;

  /// If we can reach a function with a call to a unknown function we assume
  /// that we can reach any function.
  bool CanReachUnknownCallee = false;
};

struct QueryResolver : public QuerySet {
  ChangeStatus update(Attributor &A, const AAFunctionReachability &AA,
                      ArrayRef<const AACallEdges *> AAEdgesList) {
    ChangeStatus Change = ChangeStatus::UNCHANGED;

    for (auto *AAEdges : AAEdgesList) {
      if (AAEdges->hasUnknownCallee()) {
        if (!CanReachUnknownCallee)
          Change = ChangeStatus::CHANGED;
        CanReachUnknownCallee = true;
        return Change;
      }
    }

    for (const Function *Fn : make_early_inc_range(Unreachable)) {
      if (checkIfReachable(A, AA, AAEdgesList, *Fn)) {
        Change = ChangeStatus::CHANGED;
        markReachable(*Fn);
      }
    }
    return Change;
  }

  bool isReachable(Attributor &A, AAFunctionReachability &AA,
                   ArrayRef<const AACallEdges *> AAEdgesList,
                   const Function &Fn) {
    Optional<bool> Cached = isCachedReachable(Fn);
    if (Cached.hasValue())
      return Cached.getValue();

    // The query was not cached, thus it is new. We need to request an update
    // explicitly to make sure this the information is properly run to a
    // fixpoint.
    A.registerForUpdate(AA);

    // We need to assume that this function can't reach Fn to prevent
    // an infinite loop if this function is recursive.
    Unreachable.insert(&Fn);

    bool Result = checkIfReachable(A, AA, AAEdgesList, Fn);
    if (Result)
      markReachable(Fn);
    return Result;
  }

  bool checkIfReachable(Attributor &A, const AAFunctionReachability &AA,
                        ArrayRef<const AACallEdges *> AAEdgesList,
                        const Function &Fn) const {

    // Handle the most trivial case first.
    for (auto *AAEdges : AAEdgesList) {
      const SetVector<Function *> &Edges = AAEdges->getOptimisticEdges();

      if (Edges.count(const_cast<Function *>(&Fn)))
        return true;
    }

    SmallVector<const AAFunctionReachability *, 8> Deps;
    for (auto &AAEdges : AAEdgesList) {
      const SetVector<Function *> &Edges = AAEdges->getOptimisticEdges();

      for (Function *Edge : Edges) {
        // We don't need a dependency if the result is reachable.
        const AAFunctionReachability &EdgeReachability =
            A.getAAFor<AAFunctionReachability>(
                AA, IRPosition::function(*Edge), DepClassTy::NONE);
        Deps.push_back(&EdgeReachability);

        if (EdgeReachability.canReach(A, Fn))
          return true;
      }
    }

    // The result is false for now, set dependencies and leave.
    for (auto *Dep : Deps)
      A.recordDependence(*Dep, AA, DepClassTy::REQUIRED);

    return false;
  }
};

/// Get call edges that can be reached by this instruction.
bool getReachableCallEdges(Attributor &A, const AAReachability &Reachability,
                           const Instruction &Inst,
                           SmallVector<const AACallEdges *> &Result) const {
  // Determine call like instructions that we can reach from the inst.
  auto CheckCallBase = [&](Instruction &CBInst) {
    if (!Reachability.isAssumedReachable(A, Inst, CBInst))
      return true;

    auto &CB = cast<CallBase>(CBInst);
    const AACallEdges &AAEdges = A.getAAFor<AACallEdges>(
        *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);

    Result.push_back(&AAEdges);
    return true;
  };

  bool UsedAssumedInformation = false;
  return A.checkForAllCallLikeInstructions(CheckCallBase, *this,
                                           UsedAssumedInformation,
                                           /* CheckBBLivenessOnly */ true);
}

9765public:
AAFunctionReachabilityFunction(const IRPosition &IRP, Attributor &A)
    : AAFunctionReachability(IRP, A) {}

bool canReach(Attributor &A, const Function &Fn) const override {
  if (!isValidState())
    return true;

  const AACallEdges &AAEdges =
      A.getAAFor<AACallEdges>(*this, getIRPosition(), DepClassTy::REQUIRED);

  // Attributor returns attributes as const, so this function has to be
  // const for users of this attribute to use it without having to do
  // a const_cast.
  // This is a hack for us to be able to cache queries.
  auto *NonConstThis = const_cast<AAFunctionReachabilityFunction *>(this);
  bool Result = NonConstThis->WholeFunction.isReachable(A, *NonConstThis,
                                                        {&AAEdges}, Fn);

  return Result;
}

/// Can \p CB reach \p Fn
bool canReach(Attributor &A, CallBase &CB,
              const Function &Fn) const override {
  if (!isValidState())
    return true;

  const AACallEdges &AAEdges = A.getAAFor<AACallEdges>(
      *this, IRPosition::callsite_function(CB), DepClassTy::REQUIRED);

  // Attributor returns attributes as const, so this function has to be
  // const for users of this attribute to use it without having to do
  // a const_cast.
  // This is a hack for us to be able to cache queries.
  auto *NonConstThis = const_cast<AAFunctionReachabilityFunction *>(this);
  QueryResolver &CBQuery = NonConstThis->CBQueries[&CB];

  bool Result = CBQuery.isReachable(A, *NonConstThis, {&AAEdges}, Fn);

  return Result;
}

bool instructionCanReach(Attributor &A, const Instruction &Inst,
                         const Function &Fn,
                         bool UseBackwards) const override {
  if (!isValidState())
    return true;

  if (UseBackwards)
    return AA::isPotentiallyReachable(A, Inst, Fn, *this, nullptr);

  const auto &Reachability = A.getAAFor<AAReachability>(
      *this, IRPosition::function(*getAssociatedFunction()),
      DepClassTy::REQUIRED);

  SmallVector<const AACallEdges *> CallEdges;
  bool AllKnown = getReachableCallEdges(A, Reachability, Inst, CallEdges);
  // Attributor returns attributes as const, so this function has to be
  // const for users of this attribute to use it without having to do
  // a const_cast.
  // This is a hack for us to be able to cache queries.
  auto *NonConstThis = const_cast<AAFunctionReachabilityFunction *>(this);
  QueryResolver &InstQSet = NonConstThis->InstQueries[&Inst];
  if (!AllKnown)
    InstQSet.CanReachUnknownCallee = true;

  return InstQSet.isReachable(A, *NonConstThis, CallEdges, Fn);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const AACallEdges &AAEdges =
      A.getAAFor<AACallEdges>(*this, getIRPosition(), DepClassTy::REQUIRED);
  ChangeStatus Change = ChangeStatus::UNCHANGED;

  Change |= WholeFunction.update(A, *this, {&AAEdges});

  for (auto &CBPair : CBQueries) {
    const AACallEdges &AAEdges = A.getAAFor<AACallEdges>(
        *this, IRPosition::callsite_function(*CBPair.first),
        DepClassTy::REQUIRED);

    Change |= CBPair.second.update(A, *this, {&AAEdges});
  }

  // Update the Instruction queries.
  if (!InstQueries.empty()) {
    const AAReachability *Reachability = &A.getAAFor<AAReachability>(
        *this, IRPosition::function(*getAssociatedFunction()),
        DepClassTy::REQUIRED);

    // Check for local callbases first.
    for (auto &InstPair : InstQueries) {
      SmallVector<const AACallEdges *> CallEdges;
      bool AllKnown =
          getReachableCallEdges(A, *Reachability, *InstPair.first, CallEdges);
      // Update will return change if we this effects any queries.
      if (!AllKnown)
        InstPair.second.CanReachUnknownCallee = true;
      Change |= InstPair.second.update(A, *this, CallEdges);
    }
  }

  return Change;
}

const std::string getAsStr() const override {
  size_t QueryCount =
      WholeFunction.Reachable.size() + WholeFunction.Unreachable.size();

  return "FunctionReachability [" +
         std::to_string(WholeFunction.Reachable.size()) + "," +
         std::to_string(QueryCount) + "]";
}

void trackStatistics() const override {}

9883private:
bool canReachUnknownCallee() const override {
  return WholeFunction.CanReachUnknownCallee;
}

/// Used to answer if a the whole function can reacha a specific function.
QueryResolver WholeFunction;

/// Used to answer if a call base inside this function can reach a specific
/// function.
DenseMap<const CallBase *, QueryResolver> CBQueries;

/// This is for instruction queries than scan "forward".
DenseMap<const Instruction *, QueryResolver> InstQueries;
9897};

9899/// ---------------------- Assumption Propagation ------------------------------
9900struct AAAssumptionInfoImpl : public AAAssumptionInfo {
AAAssumptionInfoImpl(const IRPosition &IRP, Attributor &A,
                     const DenseSet<StringRef> &Known)
    : AAAssumptionInfo(IRP, A, Known) {}

bool hasAssumption(const StringRef Assumption) const override {
  return isValidState() && setContains(Assumption);
}

/// See AbstractAttribute::getAsStr()
const std::string getAsStr() const override {
  const SetContents &Known = getKnown();
  const SetContents &Assumed = getAssumed();

  const std::string KnownStr =
      llvm::join(Known.getSet().begin(), Known.getSet().end(), ",");
  const std::string AssumedStr =
      (Assumed.isUniversal())
          ? "Universal"
          : llvm::join(Assumed.getSet().begin(), Assumed.getSet().end(), ",");

  return "Known [" + KnownStr + "]," + " Assumed [" + AssumedStr + "]";
}
9923};

9925/// Propagates assumption information from parent functions to all of their
9926/// successors. An assumption can be propagated if the containing function
9927/// dominates the called function.
9928///
9929/// We start with a "known" set of assumptions already valid for the associated
9930/// function and an "assumed" set that initially contains all possible
9931/// assumptions. The assumed set is inter-procedurally updated by narrowing its
9932/// contents as concrete values are known. The concrete values are seeded by the
9933/// first nodes that are either entries into the call graph, or contains no
9934/// assumptions. Each node is updated as the intersection of the assumed state
9935/// with all of its predecessors.
9936struct AAAssumptionInfoFunction final : AAAssumptionInfoImpl {
AAAssumptionInfoFunction(const IRPosition &IRP, Attributor &A)
    : AAAssumptionInfoImpl(IRP, A,
                           getAssumptions(*IRP.getAssociatedFunction())) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  const auto &Assumptions = getKnown();

  // Don't manifest a universal set if it somehow made it here.
  if (Assumptions.isUniversal())
    return ChangeStatus::UNCHANGED;

  Function *AssociatedFunction = getAssociatedFunction();

  bool Changed = addAssumptions(*AssociatedFunction, Assumptions.getSet());

  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  bool Changed = false;

  auto CallSitePred = [&](AbstractCallSite ACS) {
    const auto &AssumptionAA = A.getAAFor<AAAssumptionInfo>(
        *this, IRPosition::callsite_function(*ACS.getInstruction()),
        DepClassTy::REQUIRED);
    // Get the set of assumptions shared by all of this function's callers.
    Changed |= getIntersection(AssumptionAA.getAssumed());
    return !getAssumed().empty() || !getKnown().empty();
  };

  bool UsedAssumedInformation = false;
  // Get the intersection of all assumptions held by this node's predecessors.
  // If we don't know all the call sites then this is either an entry into the
  // call graph or an empty node. This node is known to only contain its own
  // assumptions and can be propagated to its successors.
  if (!A.checkForAllCallSites(CallSitePred, *this, true,
                              UsedAssumedInformation))
    return indicatePessimisticFixpoint();

  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

void trackStatistics() const override {}
9982};

9984/// Assumption Info defined for call sites.
9985struct AAAssumptionInfoCallSite final : AAAssumptionInfoImpl {

AAAssumptionInfoCallSite(const IRPosition &IRP, Attributor &A)
    : AAAssumptionInfoImpl(IRP, A, getInitialAssumptions(IRP)) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  const IRPosition &FnPos = IRPosition::function(*getAnchorScope());
  A.getAAFor<AAAssumptionInfo>(*this, FnPos, DepClassTy::REQUIRED);
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // Don't manifest a universal set if it somehow made it here.
  if (getKnown().isUniversal())
    return ChangeStatus::UNCHANGED;

  CallBase &AssociatedCall = cast<CallBase>(getAssociatedValue());
  bool Changed = addAssumptions(AssociatedCall, getAssumed().getSet());

  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  const IRPosition &FnPos = IRPosition::function(*getAnchorScope());
  auto &AssumptionAA =
      A.getAAFor<AAAssumptionInfo>(*this, FnPos, DepClassTy::REQUIRED);
  bool Changed = getIntersection(AssumptionAA.getAssumed());
  return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {}

10020private:
/// Helper to initialized the known set as all the assumptions this call and
/// the callee contain.
DenseSet<StringRef> getInitialAssumptions(const IRPosition &IRP) {
  const CallBase &CB = cast<CallBase>(IRP.getAssociatedValue());
  auto Assumptions = getAssumptions(CB);
  if (Function *F = IRP.getAssociatedFunction())
    set_union(Assumptions, getAssumptions(*F));
  if (Function *F = IRP.getAssociatedFunction())
    set_union(Assumptions, getAssumptions(*F));
  return Assumptions;
}
10032};

10034AACallGraphNode *AACallEdgeIterator::operator*() const {
return static_cast<AACallGraphNode *>(const_cast<AACallEdges *>(
    &A.getOrCreateAAFor<AACallEdges>(IRPosition::function(**I))));
10037}

10039void AttributorCallGraph::print() { llvm::WriteGraph(outs(), this); }

10041const char AAReturnedValues::ID = 0;
10042const char AANoUnwind::ID = 0;
10043const char AANoSync::ID = 0;
10044const char AANoFree::ID = 0;
10045const char AANonNull::ID = 0;
10046const char AANoRecurse::ID = 0;
10047const char AAWillReturn::ID = 0;
10048const char AAUndefinedBehavior::ID = 0;
10049const char AANoAlias::ID = 0;
10050const char AAReachability::ID = 0;
10051const char AANoReturn::ID = 0;
10052const char AAIsDead::ID = 0;
10053const char AADereferenceable::ID = 0;
10054const char AAAlign::ID = 0;
10055const char AANoCapture::ID = 0;
10056const char AAValueSimplify::ID = 0;
10057const char AAHeapToStack::ID = 0;
10058const char AAPrivatizablePtr::ID = 0;
10059const char AAMemoryBehavior::ID = 0;
10060const char AAMemoryLocation::ID = 0;
10061const char AAValueConstantRange::ID = 0;
10062const char AAPotentialValues::ID = 0;
10063const char AANoUndef::ID = 0;
10064const char AACallEdges::ID = 0;
10065const char AAFunctionReachability::ID = 0;
10066const char AAPointerInfo::ID = 0;
10067const char AAAssumptionInfo::ID = 0;

10069// Macro magic to create the static generator function for attributes that
10070// follow the naming scheme.

10072#define SWITCH_PK_INV(CLASS, PK, POS_NAME)                                     \
case IRPosition::PK:                                                         \
  llvm_unreachable("Cannot create " #CLASS " for a " POS_NAME " position!")::llvm::llvm_unreachable_internal("Cannot create " #CLASS " for a "
 POS_NAME " position!", "llvm/lib/Transforms/IPO/AttributorAttributes.cpp"
, 10074);

10076#define SWITCH_PK_CREATE(CLASS, IRP, PK, SUFFIX)                               \
case IRPosition::PK:                                                         \
  AA = new (A.Allocator) CLASS##SUFFIX(IRP, A);                              \
  ++NumAAs;                                                                  \
  break;

10082#define CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                 \
CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
  CLASS *AA = nullptr;                                                       \
  switch (IRP.getPositionKind()) {                                           \
    SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
    SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
    SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
    SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
  }                                                                          \
  return *AA;                                                                \
}

10098#define CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                    \
CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
  CLASS *AA = nullptr;                                                       \
  switch (IRP.getPositionKind()) {                                           \
    SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
    SWITCH_PK_INV(CLASS, IRP_FUNCTION, "function")                           \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
  }                                                                          \
  return *AA;                                                                \
}

10114#define CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                      \
CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
  CLASS *AA = nullptr;                                                       \
  switch (IRP.getPositionKind()) {                                           \
    SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_RETURNED, Returned)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
  }                                                                          \
  return *AA;                                                                \
}

10130#define CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)            \
CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
  CLASS *AA = nullptr;                                                       \
  switch (IRP.getPositionKind()) {                                           \
    SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
    SWITCH_PK_INV(CLASS, IRP_ARGUMENT, "argument")                           \
    SWITCH_PK_INV(CLASS, IRP_FLOAT, "floating")                              \
    SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE_RETURNED, "call site returned")       \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE_ARGUMENT, "call site argument")       \
    SWITCH_PK_INV(CLASS, IRP_CALL_SITE, "call site")                         \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
  }                                                                          \
  return *AA;                                                                \
}

10146#define CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(CLASS)                  \
CLASS &CLASS::createForPosition(const IRPosition &IRP, Attributor &A) {      \
  CLASS *AA = nullptr;                                                       \
  switch (IRP.getPositionKind()) {                                           \
    SWITCH_PK_INV(CLASS, IRP_INVALID, "invalid")                             \
    SWITCH_PK_INV(CLASS, IRP_RETURNED, "returned")                           \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FUNCTION, Function)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE, CallSite)                    \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_FLOAT, Floating)                        \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_ARGUMENT, Argument)                     \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_RETURNED, CallSiteReturned)   \
    SWITCH_PK_CREATE(CLASS, IRP, IRP_CALL_SITE_ARGUMENT, CallSiteArgument)   \
  }                                                                          \
  return *AA;                                                                \
}

10162CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUnwind)
10163CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync)
10164CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse)
10165CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn)
10166CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoReturn)
10167CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReturnedValues)
10168CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryLocation)
10169CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AACallEdges)
10170CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAssumptionInfo)

10172CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull)
10173CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias)
10174CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPrivatizablePtr)
10175CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable)
10176CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign)
10177CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture)
10178CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueConstantRange)
10179CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPotentialValues)
10180CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUndef)
10181CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPointerInfo)

10183CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueSimplify)
10184CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIsDead)
10185CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFree)

10187CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAHeapToStack)
10188CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReachability)
10189CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUndefinedBehavior)
10190CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAFunctionReachability)

10192CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryBehavior)

10194#undef CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION
10195#undef CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION
10196#undef CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION
10197#undef CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION
10198#undef CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION
10199#undef SWITCH_PK_CREATE
10200#undef SWITCH_PK_INV