/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp

Bug Summary

File:	llvm/lib/Transforms/IPO/Attributor.cpp
Warning:	line 4971, column 27 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Attributor.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 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-11/lib/clang/11.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/Transforms/IPO -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/include -I /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-11/lib/clang/11.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/build-llvm/lib/Transforms/IPO -fdebug-prefix-map=/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-03-09-184146-41876-1 -x c++ /build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp
1//===- Attributor.cpp - Module-wide attribute 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// This file implements an inter procedural pass that deduces and/or propagating
10// attributes. This is done in an abstract interpretation style fixpoint
11// iteration. See the Attributor.h file comment and the class descriptions in
12// that file for more information.
13//
14//===----------------------------------------------------------------------===//

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

18#include "llvm/ADT/DepthFirstIterator.h"
19#include "llvm/ADT/STLExtras.h"
20#include "llvm/ADT/SmallPtrSet.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/Statistic.h"
23#include "llvm/Analysis/CallGraph.h"
24#include "llvm/Analysis/CallGraphSCCPass.h"
25#include "llvm/Analysis/CaptureTracking.h"
26#include "llvm/Analysis/EHPersonalities.h"
27#include "llvm/Analysis/GlobalsModRef.h"
28#include "llvm/Analysis/LazyValueInfo.h"
29#include "llvm/Analysis/Loads.h"
30#include "llvm/Analysis/MemoryBuiltins.h"
31#include "llvm/Analysis/ScalarEvolution.h"
32#include "llvm/Analysis/ValueTracking.h"
33#include "llvm/IR/Argument.h"
34#include "llvm/IR/Attributes.h"
35#include "llvm/IR/CFG.h"
36#include "llvm/IR/IRBuilder.h"
37#include "llvm/IR/InstIterator.h"
38#include "llvm/IR/IntrinsicInst.h"
39#include "llvm/IR/Verifier.h"
40#include "llvm/InitializePasses.h"
41#include "llvm/IR/NoFolder.h"
42#include "llvm/Support/CommandLine.h"
43#include "llvm/Support/Debug.h"
44#include "llvm/Support/raw_ostream.h"
45#include "llvm/Transforms/IPO/ArgumentPromotion.h"
46#include "llvm/Transforms/Utils/BasicBlockUtils.h"
47#include "llvm/Transforms/Utils/Local.h"

49#include <cassert>

51using namespace llvm;

53#define DEBUG_TYPE"attributor" "attributor"

55STATISTIC(NumFnWithExactDefinition,static llvm::Statistic NumFnWithExactDefinition = {"attributor"
, "NumFnWithExactDefinition", "Number of function with exact definitions"
}
        "Number of function with exact definitions")static llvm::Statistic NumFnWithExactDefinition = {"attributor"
, "NumFnWithExactDefinition", "Number of function with exact definitions"
};
57STATISTIC(NumFnWithoutExactDefinition,static llvm::Statistic NumFnWithoutExactDefinition = {"attributor"
, "NumFnWithoutExactDefinition", "Number of function without exact definitions"
}
        "Number of function without exact definitions")static llvm::Statistic NumFnWithoutExactDefinition = {"attributor"
, "NumFnWithoutExactDefinition", "Number of function without exact definitions"
};
59STATISTIC(NumAttributesTimedOut,static llvm::Statistic NumAttributesTimedOut = {"attributor",
 "NumAttributesTimedOut", "Number of abstract attributes timed out before fixpoint"
}
        "Number of abstract attributes timed out before fixpoint")static llvm::Statistic NumAttributesTimedOut = {"attributor",
 "NumAttributesTimedOut", "Number of abstract attributes timed out before fixpoint"
};
61STATISTIC(NumAttributesValidFixpoint,static llvm::Statistic NumAttributesValidFixpoint = {"attributor"
, "NumAttributesValidFixpoint", "Number of abstract attributes in a valid fixpoint state"
}
        "Number of abstract attributes in a valid fixpoint state")static llvm::Statistic NumAttributesValidFixpoint = {"attributor"
, "NumAttributesValidFixpoint", "Number of abstract attributes in a valid fixpoint state"
};
63STATISTIC(NumAttributesManifested,static llvm::Statistic NumAttributesManifested = {"attributor"
, "NumAttributesManifested", "Number of abstract attributes manifested in IR"
}
        "Number of abstract attributes manifested in IR")static llvm::Statistic NumAttributesManifested = {"attributor"
, "NumAttributesManifested", "Number of abstract attributes manifested in IR"
};
65STATISTIC(NumAttributesFixedDueToRequiredDependences,static llvm::Statistic NumAttributesFixedDueToRequiredDependences
 = {"attributor", "NumAttributesFixedDueToRequiredDependences"
, "Number of abstract attributes fixed due to required dependences"
}
        "Number of abstract attributes fixed due to required dependences")static llvm::Statistic NumAttributesFixedDueToRequiredDependences
 = {"attributor", "NumAttributesFixedDueToRequiredDependences"
, "Number of abstract attributes fixed due to required dependences"
};

68// Some helper macros to deal with statistics tracking.
69//
70// Usage:
71// For simple IR attribute tracking overload trackStatistics in the abstract
72// attribute and choose the right STATS_DECLTRACK_********* macro,
73// e.g.,:
74//  void trackStatistics() const override {
75//    STATS_DECLTRACK_ARG_ATTR(returned)
76//  }
77// If there is a single "increment" side one can use the macro
78// STATS_DECLTRACK with a custom message. If there are multiple increment
79// sides, STATS_DECL and STATS_TRACK can also be used separatly.
80//
81#define BUILD_STAT_MSG_IR_ATTR(TYPE, NAME)("Number of " "TYPE" " marked '" "NAME" "'")                                     \
("Number of " #TYPE " marked '" #NAME "'")
83#define BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME NumIR##TYPE##_##NAME
84#define STATS_DECL_(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG}; STATISTIC(NAME, MSG)static llvm::Statistic NAME = {"attributor", "NAME", MSG};
85#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};;
87#define STATS_TRACK(NAME, TYPE)++(NumIRTYPE_NAME); ++(BUILD_STAT_NAME(NAME, TYPE)NumIRTYPE_NAME);
88#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);                                                    \
}
93#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); }
95#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); }
98#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
); }
100#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
); }
102#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); }
105#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); }
108#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); }

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

120PIPE_OPERATOR(AAIsDead)
121PIPE_OPERATOR(AANoUnwind)
122PIPE_OPERATOR(AANoSync)
123PIPE_OPERATOR(AANoRecurse)
124PIPE_OPERATOR(AAWillReturn)
125PIPE_OPERATOR(AANoReturn)
126PIPE_OPERATOR(AAReturnedValues)
127PIPE_OPERATOR(AANonNull)
128PIPE_OPERATOR(AANoAlias)
129PIPE_OPERATOR(AADereferenceable)
130PIPE_OPERATOR(AAAlign)
131PIPE_OPERATOR(AANoCapture)
132PIPE_OPERATOR(AAValueSimplify)
133PIPE_OPERATOR(AANoFree)
134PIPE_OPERATOR(AAHeapToStack)
135PIPE_OPERATOR(AAReachability)
136PIPE_OPERATOR(AAMemoryBehavior)
137PIPE_OPERATOR(AAMemoryLocation)
138PIPE_OPERATOR(AAValueConstantRange)
139PIPE_OPERATOR(AAPrivatizablePtr)

141#undef PIPE_OPERATOR
142} // namespace llvm

144// TODO: Determine a good default value.
145//
146// In the LLVM-TS and SPEC2006, 32 seems to not induce compile time overheads
147// (when run with the first 5 abstract attributes). The results also indicate
148// that we never reach 32 iterations but always find a fixpoint sooner.
149//
150// This will become more evolved once we perform two interleaved fixpoint
151// iterations: bottom-up and top-down.
152static cl::opt<unsigned>
  MaxFixpointIterations("attributor-max-iterations", cl::Hidden,
                        cl::desc("Maximal number of fixpoint iterations."),
                        cl::init(32));
156static cl::opt<bool> VerifyMaxFixpointIterations(
  "attributor-max-iterations-verify", cl::Hidden,
  cl::desc("Verify that max-iterations is a tight bound for a fixpoint"),
  cl::init(false));

161static cl::opt<bool> DisableAttributor(
  "attributor-disable", cl::Hidden,
  cl::desc("Disable the attributor inter-procedural deduction pass."),
  cl::init(true));

166static cl::opt<bool> AnnotateDeclarationCallSites(
  "attributor-annotate-decl-cs", cl::Hidden,
  cl::desc("Annotate call sites of function declarations."), cl::init(false));

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

175static cl::opt<unsigned> DepRecInterval(
  "attributor-dependence-recompute-interval", cl::Hidden,
  cl::desc("Number of iterations until dependences are recomputed."),
  cl::init(4));

180static cl::opt<bool> EnableHeapToStack("enable-heap-to-stack-conversion",
                                     cl::init(true), cl::Hidden);

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

186/// Logic operators for the change status enum class.
187///
188///{
189ChangeStatus llvm::operator|(ChangeStatus l, ChangeStatus r) {
return l == ChangeStatus::CHANGED ? l : r;
191}
192ChangeStatus llvm::operator&(ChangeStatus l, ChangeStatus r) {
return l == ChangeStatus::UNCHANGED ? l : r;
194}
195///}

197Argument *IRPosition::getAssociatedArgument() const {
if (getPositionKind() == IRP_ARGUMENT)
  return cast<Argument>(&getAnchorValue());

// Not an Argument and no argument number means this is not a call site
// argument, thus we cannot find a callback argument to return.
int ArgNo = getArgNo();
if (ArgNo < 0)
  return nullptr;

// Use abstract call sites to make the connection between the call site
// values and the ones in callbacks. If a callback was found that makes use
// of the underlying call site operand, we want the corresponding callback
// callee argument and not the direct callee argument.
Optional<Argument *> CBCandidateArg;
SmallVector<const Use *, 4> CBUses;
ImmutableCallSite ICS(&getAnchorValue());
AbstractCallSite::getCallbackUses(ICS, CBUses);
for (const Use *U : CBUses) {
  AbstractCallSite ACS(U);
  assert(ACS && ACS.isCallbackCall())((ACS && ACS.isCallbackCall()) ? static_cast<void>
 (0) : __assert_fail ("ACS && ACS.isCallbackCall()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 217, __PRETTY_FUNCTION__));
  if (!ACS.getCalledFunction())
    continue;

  for (unsigned u = 0, e = ACS.getNumArgOperands(); u < e; u++) {

    // Test if the underlying call site operand is argument number u of the
    // callback callee.
    if (ACS.getCallArgOperandNo(u) != ArgNo)
      continue;

    assert(ACS.getCalledFunction()->arg_size() > u &&((ACS.getCalledFunction()->arg_size() > u && "ACS mapped into var-args arguments!"
) ? static_cast<void> (0) : __assert_fail ("ACS.getCalledFunction()->arg_size() > u && \"ACS mapped into var-args arguments!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 229, __PRETTY_FUNCTION__))
           "ACS mapped into var-args arguments!")((ACS.getCalledFunction()->arg_size() > u && "ACS mapped into var-args arguments!"
) ? static_cast<void> (0) : __assert_fail ("ACS.getCalledFunction()->arg_size() > u && \"ACS mapped into var-args arguments!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 229, __PRETTY_FUNCTION__));
    if (CBCandidateArg.hasValue()) {
      CBCandidateArg = nullptr;
      break;
    }
    CBCandidateArg = ACS.getCalledFunction()->getArg(u);
  }
}

// If we found a unique callback candidate argument, return it.
if (CBCandidateArg.hasValue() && CBCandidateArg.getValue())
  return CBCandidateArg.getValue();

// If no callbacks were found, or none used the underlying call site operand
// exclusively, use the direct callee argument if available.
const Function *Callee = ICS.getCalledFunction();
if (Callee && Callee->arg_size() > unsigned(ArgNo))
  return Callee->getArg(ArgNo);

return nullptr;
249}

251static Optional<Constant *> getAssumedConstant(Attributor &A, const Value &V,
                                             const AbstractAttribute &AA,
                                             bool &UsedAssumedInformation) {
const auto &ValueSimplifyAA = A.getAAFor<AAValueSimplify>(
    AA, IRPosition::value(V), /* TrackDependence */ false);
Optional<Value *> SimplifiedV = ValueSimplifyAA.getAssumedSimplifiedValue(A);
bool IsKnown = ValueSimplifyAA.isKnown();
UsedAssumedInformation |= !IsKnown;
if (!SimplifiedV.hasValue()) {
  A.recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL);
  return llvm::None;
}
if (isa_and_nonnull<UndefValue>(SimplifiedV.getValue())) {
  A.recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL);
  return llvm::None;
}
Constant *CI = dyn_cast_or_null<Constant>(SimplifiedV.getValue());
if (CI && CI->getType() != V.getType()) {
  // TODO: Check for a save conversion.
  return nullptr;
}
if (CI)
  A.recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL);
return CI;
275}

277static Optional<ConstantInt *>
278getAssumedConstantInt(Attributor &A, const Value &V,
                    const AbstractAttribute &AA,
                    bool &UsedAssumedInformation) {
Optional<Constant *> C = getAssumedConstant(A, V, AA, UsedAssumedInformation);
if (C.hasValue())
  return dyn_cast_or_null<ConstantInt>(C.getValue());
return llvm::None;
285}

287/// Get pointer operand of memory accessing instruction. If \p I is
288/// not a memory accessing instruction, return nullptr. If \p AllowVolatile,
289/// is set to false and the instruction is volatile, return nullptr.
290static const Value *getPointerOperand(const Instruction *I,
                                    bool AllowVolatile) {
if (auto *LI = dyn_cast<LoadInst>(I)) {
  if (!AllowVolatile && LI->isVolatile())
    return nullptr;
  return LI->getPointerOperand();
}

if (auto *SI = dyn_cast<StoreInst>(I)) {
  if (!AllowVolatile && SI->isVolatile())
    return nullptr;
  return SI->getPointerOperand();
}

if (auto *CXI = dyn_cast<AtomicCmpXchgInst>(I)) {
  if (!AllowVolatile && CXI->isVolatile())
    return nullptr;
  return CXI->getPointerOperand();
}

if (auto *RMWI = dyn_cast<AtomicRMWInst>(I)) {
  if (!AllowVolatile && RMWI->isVolatile())
    return nullptr;
  return RMWI->getPointerOperand();
}

return nullptr;
317}

319/// Helper function to create a pointer of type \p ResTy, based on \p Ptr, and
320/// advanced by \p Offset bytes. To aid later analysis the method tries to build
321/// getelement pointer instructions that traverse the natural type of \p Ptr if
322/// possible. If that fails, the remaining offset is adjusted byte-wise, hence
323/// through a cast to i8*.
324///
325/// TODO: This could probably live somewhere more prominantly if it doesn't
326///       already exist.
327static Value *constructPointer(Type *ResTy, Value *Ptr, int64_t Offset,
                             IRBuilder<NoFolder> &IRB, const DataLayout &DL) {
assert(Offset >= 0 && "Negative offset not supported yet!")((Offset >= 0 && "Negative offset not supported yet!"
) ? static_cast<void> (0) : __assert_fail ("Offset >= 0 && \"Negative offset not supported yet!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 329, __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);

// The initial type we are trying to traverse to get nice GEPs.
Type *Ty = Ptr->getType();

SmallVector<Value *, 4> Indices;
std::string GEPName = Ptr->getName().str();
while (Offset) {
  uint64_t Idx, Rem;

  if (auto *STy = dyn_cast<StructType>(Ty)) {
    const StructLayout *SL = DL.getStructLayout(STy);
    if (int64_t(SL->getSizeInBytes()) < Offset)
      break;
    Idx = SL->getElementContainingOffset(Offset);
    assert(Idx < STy->getNumElements() && "Offset calculation error!")((Idx < STy->getNumElements() && "Offset calculation error!"
) ? static_cast<void> (0) : __assert_fail ("Idx < STy->getNumElements() && \"Offset calculation error!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 346, __PRETTY_FUNCTION__));
    Rem = Offset - SL->getElementOffset(Idx);
    Ty = STy->getElementType(Idx);
  } else if (auto *PTy = dyn_cast<PointerType>(Ty)) {
    Ty = PTy->getElementType();
    if (!Ty->isSized())
      break;
    uint64_t ElementSize = DL.getTypeAllocSize(Ty);
    assert(ElementSize && "Expected type with size!")((ElementSize && "Expected type with size!") ? static_cast
<void> (0) : __assert_fail ("ElementSize && \"Expected type with size!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 354, __PRETTY_FUNCTION__));
    Idx = Offset / ElementSize;
    Rem = Offset % ElementSize;
  } else {
    // Non-aggregate type, we cast and make byte-wise progress now.
    break;
  }

  LLVM_DEBUG(errs() << "Ty: " << *Ty << " Offset: " << Offsetdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { errs() << "Ty: " << *Ty <<
 " Offset: " << Offset << " Idx: " << Idx <<
 " Rem: " << Rem << "\n"; } } while (false)
                    << " Idx: " << Idx << " Rem: " << Rem << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { errs() << "Ty: " << *Ty <<
 " Offset: " << Offset << " Idx: " << Idx <<
 " Rem: " << Rem << "\n"; } } while (false);

  GEPName += "." + std::to_string(Idx);
  Indices.push_back(ConstantInt::get(IRB.getInt32Ty(), Idx));
  Offset = Rem;
}

// Create a GEP if we collected indices above.
if (Indices.size())
  Ptr = IRB.CreateGEP(Ptr, Indices, GEPName);

// If an offset is left we use byte-wise adjustment.
if (Offset) {
  Ptr = IRB.CreateBitCast(Ptr, IRB.getInt8PtrTy());
  Ptr = IRB.CreateGEP(Ptr, IRB.getInt32(Offset),
                      GEPName + ".b" + Twine(Offset));
}

// Ensure the result has the requested type.
Ptr = IRB.CreateBitOrPointerCast(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;
386}

388/// Recursively visit all values that might become \p IRP at some point. This
389/// will be done by looking through cast instructions, selects, phis, and calls
390/// with the "returned" attribute. Once we cannot look through the value any
391/// further, the callback \p VisitValueCB is invoked and passed the current
392/// value, the \p State, and a flag to indicate if we stripped anything.
393/// Stripped means that we unpacked the value associated with \p IRP at least
394/// once. Note that the value used for the callback may still be the value
395/// associated with \p IRP (due to PHIs). To limit how much effort is invested,
396/// we will never visit more values than specified by \p MaxValues.
397template <typename AAType, typename StateTy>
398static bool genericValueTraversal(
  Attributor &A, IRPosition IRP, const AAType &QueryingAA, StateTy &State,
  const function_ref<bool(Value &, StateTy &, bool)> &VisitValueCB,
  int MaxValues = 8, const function_ref<Value *(Value *)> StripCB = nullptr) {

const AAIsDead *LivenessAA = nullptr;
if (IRP.getAnchorScope())
  LivenessAA = &A.getAAFor<AAIsDead>(
      QueryingAA, IRPosition::function(*IRP.getAnchorScope()),
      /* TrackDependence */ false);
bool AnyDead = false;

// TODO: Use Positions here to allow context sensitivity in VisitValueCB
SmallPtrSet<Value *, 16> Visited;
SmallVector<Value *, 16> Worklist;
Worklist.push_back(&IRP.getAssociatedValue());

int Iteration = 0;
do {
  Value *V = Worklist.pop_back_val();
  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(V).second)
    continue;

  // Make sure we limit the compile time for complex expressions.
  if (Iteration++ >= MaxValues)
    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 {
    CallSite CS(V);
    if (CS && CS.getCalledFunction()) {
      for (Argument &Arg : CS.getCalledFunction()->args())
        if (Arg.hasReturnedAttr()) {
          NewV = CS.getArgOperand(Arg.getArgNo());
          break;
        }
    }
  }
  if (NewV && NewV != V) {
    Worklist.push_back(NewV);
    continue;
  }

  // Look through select instructions, visit both potential values.
  if (auto *SI = dyn_cast<SelectInst>(V)) {
    Worklist.push_back(SI->getTrueValue());
    Worklist.push_back(SI->getFalseValue());
    continue;
  }

  // Look through phi nodes, visit all live operands.
  if (auto *PHI = dyn_cast<PHINode>(V)) {
    assert(LivenessAA &&((LivenessAA && "Expected liveness in the presence of instructions!"
) ? static_cast<void> (0) : __assert_fail ("LivenessAA && \"Expected liveness in the presence of instructions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 460, __PRETTY_FUNCTION__))
           "Expected liveness in the presence of instructions!")((LivenessAA && "Expected liveness in the presence of instructions!"
) ? static_cast<void> (0) : __assert_fail ("LivenessAA && \"Expected liveness in the presence of instructions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 460, __PRETTY_FUNCTION__));
    for (unsigned u = 0, e = PHI->getNumIncomingValues(); u < e; u++) {
      const BasicBlock *IncomingBB = PHI->getIncomingBlock(u);
      if (A.isAssumedDead(*IncomingBB->getTerminator(), &QueryingAA,
                          LivenessAA,
                          /* CheckBBLivenessOnly */ true)) {
        AnyDead = true;
        continue;
      }
      Worklist.push_back(PHI->getIncomingValue(u));
    }
    continue;
  }

  // Once a leaf is reached we inform the user through the callback.
  if (!VisitValueCB(*V, State, Iteration > 1))
    return false;
} while (!Worklist.empty());

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

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

487/// Return true if \p New is equal or worse than \p Old.
488static bool isEqualOrWorse(const Attribute &New, const Attribute &Old) {
if (!Old.isIntAttribute())
  return true;

return Old.getValueAsInt() >= New.getValueAsInt();
493}

495/// Return true if the information provided by \p Attr was added to the
496/// attribute list \p Attrs. This is only the case if it was not already present
497/// in \p Attrs at the position describe by \p PK and \p AttrIdx.
498static bool addIfNotExistent(LLVMContext &Ctx, const Attribute &Attr,
                           AttributeList &Attrs, int AttrIdx) {

if (Attr.isEnumAttribute()) {
  Attribute::AttrKind Kind = Attr.getKindAsEnum();
  if (Attrs.hasAttribute(AttrIdx, Kind))
    if (isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
      return false;
  Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
  return true;
}
if (Attr.isStringAttribute()) {
  StringRef Kind = Attr.getKindAsString();
  if (Attrs.hasAttribute(AttrIdx, Kind))
    if (isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
      return false;
  Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
  return true;
}
if (Attr.isIntAttribute()) {
  Attribute::AttrKind Kind = Attr.getKindAsEnum();
  if (Attrs.hasAttribute(AttrIdx, Kind))
    if (isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
      return false;
  Attrs = Attrs.removeAttribute(Ctx, AttrIdx, Kind);
  Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
  return true;
}

llvm_unreachable("Expected enum or string attribute!")::llvm::llvm_unreachable_internal("Expected enum or string attribute!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 527);
528}

530static const Value *
531getBasePointerOfAccessPointerOperand(const Instruction *I, int64_t &BytesOffset,
                                   const DataLayout &DL,
                                   bool AllowNonInbounds = false) {
const Value *Ptr = getPointerOperand(I, /* AllowVolatile */ false);
if (!Ptr)
  return nullptr;

return GetPointerBaseWithConstantOffset(Ptr, BytesOffset, DL,
                                        AllowNonInbounds);
540}

542ChangeStatus AbstractAttribute::update(Attributor &A) {
ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
if (getState().isAtFixpoint())
  return HasChanged;

LLVM_DEBUG(dbgs() << "[Attributor] Update: " << *this << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Update: " <<
 *this << "\n"; } } while (false);

HasChanged = updateImpl(A);

LLVM_DEBUG(dbgs() << "[Attributor] Update " << HasChanged << " " << *thisdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Update " <<
 HasChanged << " " << *this << "\n"; } } while
 (false)
                  << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Update " <<
 HasChanged << " " << *this << "\n"; } } while
 (false);

return HasChanged;
555}

557ChangeStatus
558IRAttributeManifest::manifestAttrs(Attributor &A, const IRPosition &IRP,
                                 const ArrayRef<Attribute> &DeducedAttrs) {
Function *ScopeFn = IRP.getAssociatedFunction();
IRPosition::Kind PK = IRP.getPositionKind();

// In the following some generic code that will manifest attributes in
// DeducedAttrs if they improve the current IR. Due to the different
// annotation positions we use the underlying AttributeList interface.

AttributeList Attrs;
switch (PK) {
case IRPosition::IRP_INVALID:
case IRPosition::IRP_FLOAT:
  return ChangeStatus::UNCHANGED;
case IRPosition::IRP_ARGUMENT:
case IRPosition::IRP_FUNCTION:
case IRPosition::IRP_RETURNED:
  Attrs = ScopeFn->getAttributes();
  break;
case IRPosition::IRP_CALL_SITE:
case IRPosition::IRP_CALL_SITE_RETURNED:
case IRPosition::IRP_CALL_SITE_ARGUMENT:
  Attrs = ImmutableCallSite(&IRP.getAnchorValue()).getAttributes();
  break;
}

ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
LLVMContext &Ctx = IRP.getAnchorValue().getContext();
for (const Attribute &Attr : DeducedAttrs) {
  if (!addIfNotExistent(Ctx, Attr, Attrs, IRP.getAttrIdx()))
    continue;

  HasChanged = ChangeStatus::CHANGED;
}

if (HasChanged == ChangeStatus::UNCHANGED)
  return HasChanged;

switch (PK) {
case IRPosition::IRP_ARGUMENT:
case IRPosition::IRP_FUNCTION:
case IRPosition::IRP_RETURNED:
  ScopeFn->setAttributes(Attrs);
  break;
case IRPosition::IRP_CALL_SITE:
case IRPosition::IRP_CALL_SITE_RETURNED:
case IRPosition::IRP_CALL_SITE_ARGUMENT:
  CallSite(&IRP.getAnchorValue()).setAttributes(Attrs);
  break;
case IRPosition::IRP_INVALID:
case IRPosition::IRP_FLOAT:
  break;
}

return HasChanged;
613}

615const IRPosition IRPosition::EmptyKey(255);
616const IRPosition IRPosition::TombstoneKey(256);

618SubsumingPositionIterator::SubsumingPositionIterator(const IRPosition &IRP) {
IRPositions.emplace_back(IRP);

ImmutableCallSite ICS(&IRP.getAnchorValue());
switch (IRP.getPositionKind()) {
case IRPosition::IRP_INVALID:
case IRPosition::IRP_FLOAT:
case IRPosition::IRP_FUNCTION:
  return;
case IRPosition::IRP_ARGUMENT:
case IRPosition::IRP_RETURNED:
  IRPositions.emplace_back(
      IRPosition::function(*IRP.getAssociatedFunction()));
  return;
case IRPosition::IRP_CALL_SITE:
  assert(ICS && "Expected call site!")((ICS && "Expected call site!") ? static_cast<void
> (0) : __assert_fail ("ICS && \"Expected call site!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 633, __PRETTY_FUNCTION__));
  // TODO: We need to look at the operand bundles similar to the redirection
  //       in CallBase.
  if (!ICS.hasOperandBundles())
    if (const Function *Callee = ICS.getCalledFunction())
      IRPositions.emplace_back(IRPosition::function(*Callee));
  return;
case IRPosition::IRP_CALL_SITE_RETURNED:
  assert(ICS && "Expected call site!")((ICS && "Expected call site!") ? static_cast<void
> (0) : __assert_fail ("ICS && \"Expected call site!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 641, __PRETTY_FUNCTION__));
  // TODO: We need to look at the operand bundles similar to the redirection
  //       in CallBase.
  if (!ICS.hasOperandBundles()) {
    if (const Function *Callee = ICS.getCalledFunction()) {
      IRPositions.emplace_back(IRPosition::returned(*Callee));
      IRPositions.emplace_back(IRPosition::function(*Callee));
      for (const Argument &Arg : Callee->args())
        if (Arg.hasReturnedAttr()) {
          IRPositions.emplace_back(
              IRPosition::callsite_argument(ICS, Arg.getArgNo()));
          IRPositions.emplace_back(
              IRPosition::value(*ICS.getArgOperand(Arg.getArgNo())));
          IRPositions.emplace_back(IRPosition::argument(Arg));
        }
    }
  }
  IRPositions.emplace_back(
      IRPosition::callsite_function(cast<CallBase>(*ICS.getInstruction())));
  return;
case IRPosition::IRP_CALL_SITE_ARGUMENT: {
  int ArgNo = IRP.getArgNo();
  assert(ICS && ArgNo >= 0 && "Expected call site!")((ICS && ArgNo >= 0 && "Expected call site!"
) ? static_cast<void> (0) : __assert_fail ("ICS && ArgNo >= 0 && \"Expected call site!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 663, __PRETTY_FUNCTION__));
  // TODO: We need to look at the operand bundles similar to the redirection
  //       in CallBase.
  if (!ICS.hasOperandBundles()) {
    const Function *Callee = ICS.getCalledFunction();
    if (Callee && Callee->arg_size() > unsigned(ArgNo))
      IRPositions.emplace_back(IRPosition::argument(*Callee->getArg(ArgNo)));
    if (Callee)
      IRPositions.emplace_back(IRPosition::function(*Callee));
  }
  IRPositions.emplace_back(IRPosition::value(IRP.getAssociatedValue()));
  return;
}
}
677}

679bool IRPosition::hasAttr(ArrayRef<Attribute::AttrKind> AKs,
                       bool IgnoreSubsumingPositions) const {
SmallVector<Attribute, 4> Attrs;
for (const IRPosition &EquivIRP : SubsumingPositionIterator(*this)) {
  for (Attribute::AttrKind AK : AKs)
    if (EquivIRP.getAttrsFromIRAttr(AK, Attrs))
      return true;
  // The first position returned by the SubsumingPositionIterator is
  // always the position itself. If we ignore subsuming positions we
  // are done after the first iteration.
  if (IgnoreSubsumingPositions)
    break;
}
return false;
693}

695void IRPosition::getAttrs(ArrayRef<Attribute::AttrKind> AKs,
                        SmallVectorImpl<Attribute> &Attrs,
                        bool IgnoreSubsumingPositions) const {
for (const IRPosition &EquivIRP : SubsumingPositionIterator(*this)) {
  for (Attribute::AttrKind AK : AKs)
    EquivIRP.getAttrsFromIRAttr(AK, Attrs);
  // The first position returned by the SubsumingPositionIterator is
  // always the position itself. If we ignore subsuming positions we
  // are done after the first iteration.
  if (IgnoreSubsumingPositions)
    break;
}
707}

709bool IRPosition::getAttrsFromIRAttr(Attribute::AttrKind AK,
                                  SmallVectorImpl<Attribute> &Attrs) const {
if (getPositionKind() == IRP_INVALID || getPositionKind() == IRP_FLOAT)
  return false;

AttributeList AttrList;
if (ImmutableCallSite ICS = ImmutableCallSite(&getAnchorValue()))
  AttrList = ICS.getAttributes();
else
  AttrList = getAssociatedFunction()->getAttributes();

bool HasAttr = AttrList.hasAttribute(getAttrIdx(), AK);
if (HasAttr)
  Attrs.push_back(AttrList.getAttribute(getAttrIdx(), AK));
return HasAttr;
724}


727void IRPosition::verify() {
switch (KindOrArgNo) {
default:
  assert(KindOrArgNo >= 0 && "Expected argument or call site argument!")((KindOrArgNo >= 0 && "Expected argument or call site argument!"
) ? static_cast<void> (0) : __assert_fail ("KindOrArgNo >= 0 && \"Expected argument or call site argument!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 730, __PRETTY_FUNCTION__));
  assert((isa<CallBase>(AnchorVal) || isa<Argument>(AnchorVal)) &&(((isa<CallBase>(AnchorVal) || isa<Argument>(AnchorVal
)) && "Expected call base or argument for positive attribute index!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal) || isa<Argument>(AnchorVal)) && \"Expected call base or argument for positive attribute index!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 732, __PRETTY_FUNCTION__))
         "Expected call base or argument for positive attribute index!")(((isa<CallBase>(AnchorVal) || isa<Argument>(AnchorVal
)) && "Expected call base or argument for positive attribute index!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal) || isa<Argument>(AnchorVal)) && \"Expected call base or argument for positive attribute index!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 732, __PRETTY_FUNCTION__));
  if (isa<Argument>(AnchorVal)) {
    assert(cast<Argument>(AnchorVal)->getArgNo() == unsigned(getArgNo()) &&((cast<Argument>(AnchorVal)->getArgNo() == unsigned(
getArgNo()) && "Argument number mismatch!") ? static_cast
<void> (0) : __assert_fail ("cast<Argument>(AnchorVal)->getArgNo() == unsigned(getArgNo()) && \"Argument number mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 735, __PRETTY_FUNCTION__))
           "Argument number mismatch!")((cast<Argument>(AnchorVal)->getArgNo() == unsigned(
getArgNo()) && "Argument number mismatch!") ? static_cast
<void> (0) : __assert_fail ("cast<Argument>(AnchorVal)->getArgNo() == unsigned(getArgNo()) && \"Argument number mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 735, __PRETTY_FUNCTION__));
    assert(cast<Argument>(AnchorVal) == &getAssociatedValue() &&((cast<Argument>(AnchorVal) == &getAssociatedValue(
) && "Associated value mismatch!") ? static_cast<void
> (0) : __assert_fail ("cast<Argument>(AnchorVal) == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 737, __PRETTY_FUNCTION__))
           "Associated value mismatch!")((cast<Argument>(AnchorVal) == &getAssociatedValue(
) && "Associated value mismatch!") ? static_cast<void
> (0) : __assert_fail ("cast<Argument>(AnchorVal) == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 737, __PRETTY_FUNCTION__));
  } else {
    assert(cast<CallBase>(*AnchorVal).arg_size() > unsigned(getArgNo()) &&((cast<CallBase>(*AnchorVal).arg_size() > unsigned(getArgNo
()) && "Call site argument number mismatch!") ? static_cast
<void> (0) : __assert_fail ("cast<CallBase>(*AnchorVal).arg_size() > unsigned(getArgNo()) && \"Call site argument number mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 740, __PRETTY_FUNCTION__))
           "Call site argument number mismatch!")((cast<CallBase>(*AnchorVal).arg_size() > unsigned(getArgNo
()) && "Call site argument number mismatch!") ? static_cast
<void> (0) : __assert_fail ("cast<CallBase>(*AnchorVal).arg_size() > unsigned(getArgNo()) && \"Call site argument number mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 740, __PRETTY_FUNCTION__));
    assert(cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) ==((cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) ==
 &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 743, __PRETTY_FUNCTION__))
               &getAssociatedValue() &&((cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) ==
 &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 743, __PRETTY_FUNCTION__))
           "Associated value mismatch!")((cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) ==
 &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("cast<CallBase>(*AnchorVal).getArgOperand(getArgNo()) == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 743, __PRETTY_FUNCTION__));
  }
  break;
case IRP_INVALID:
  assert(!AnchorVal && "Expected no value for an invalid position!")((!AnchorVal && "Expected no value for an invalid position!"
) ? static_cast<void> (0) : __assert_fail ("!AnchorVal && \"Expected no value for an invalid position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 747, __PRETTY_FUNCTION__));
  break;
case IRP_FLOAT:
  assert((!isa<CallBase>(&getAssociatedValue()) &&(((!isa<CallBase>(&getAssociatedValue()) &&
 !isa<Argument>(&getAssociatedValue())) && "Expected specialized kind for call base and argument values!"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CallBase>(&getAssociatedValue()) && !isa<Argument>(&getAssociatedValue())) && \"Expected specialized kind for call base and argument values!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 752, __PRETTY_FUNCTION__))
          !isa<Argument>(&getAssociatedValue())) &&(((!isa<CallBase>(&getAssociatedValue()) &&
 !isa<Argument>(&getAssociatedValue())) && "Expected specialized kind for call base and argument values!"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CallBase>(&getAssociatedValue()) && !isa<Argument>(&getAssociatedValue())) && \"Expected specialized kind for call base and argument values!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 752, __PRETTY_FUNCTION__))
         "Expected specialized kind for call base and argument values!")(((!isa<CallBase>(&getAssociatedValue()) &&
 !isa<Argument>(&getAssociatedValue())) && "Expected specialized kind for call base and argument values!"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CallBase>(&getAssociatedValue()) && !isa<Argument>(&getAssociatedValue())) && \"Expected specialized kind for call base and argument values!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 752, __PRETTY_FUNCTION__));
  break;
case IRP_RETURNED:
  assert(isa<Function>(AnchorVal) &&((isa<Function>(AnchorVal) && "Expected function for a 'returned' position!"
) ? static_cast<void> (0) : __assert_fail ("isa<Function>(AnchorVal) && \"Expected function for a 'returned' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 756, __PRETTY_FUNCTION__))
         "Expected function for a 'returned' position!")((isa<Function>(AnchorVal) && "Expected function for a 'returned' position!"
) ? static_cast<void> (0) : __assert_fail ("isa<Function>(AnchorVal) && \"Expected function for a 'returned' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 756, __PRETTY_FUNCTION__));
  assert(AnchorVal == &getAssociatedValue() && "Associated value mismatch!")((AnchorVal == &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("AnchorVal == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 757, __PRETTY_FUNCTION__));
  break;
case IRP_CALL_SITE_RETURNED:
  assert((isa<CallBase>(AnchorVal)) &&(((isa<CallBase>(AnchorVal)) && "Expected call base for 'call site returned' position!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal)) && \"Expected call base for 'call site returned' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 761, __PRETTY_FUNCTION__))
         "Expected call base for 'call site returned' position!")(((isa<CallBase>(AnchorVal)) && "Expected call base for 'call site returned' position!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal)) && \"Expected call base for 'call site returned' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 761, __PRETTY_FUNCTION__));
  assert(AnchorVal == &getAssociatedValue() && "Associated value mismatch!")((AnchorVal == &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("AnchorVal == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 762, __PRETTY_FUNCTION__));
  break;
case IRP_CALL_SITE:
  assert((isa<CallBase>(AnchorVal)) &&(((isa<CallBase>(AnchorVal)) && "Expected call base for 'call site function' position!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal)) && \"Expected call base for 'call site function' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 766, __PRETTY_FUNCTION__))
         "Expected call base for 'call site function' position!")(((isa<CallBase>(AnchorVal)) && "Expected call base for 'call site function' position!"
) ? static_cast<void> (0) : __assert_fail ("(isa<CallBase>(AnchorVal)) && \"Expected call base for 'call site function' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 766, __PRETTY_FUNCTION__));
  assert(AnchorVal == &getAssociatedValue() && "Associated value mismatch!")((AnchorVal == &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("AnchorVal == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 767, __PRETTY_FUNCTION__));
  break;
case IRP_FUNCTION:
  assert(isa<Function>(AnchorVal) &&((isa<Function>(AnchorVal) && "Expected function for a 'function' position!"
) ? static_cast<void> (0) : __assert_fail ("isa<Function>(AnchorVal) && \"Expected function for a 'function' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 771, __PRETTY_FUNCTION__))
         "Expected function for a 'function' position!")((isa<Function>(AnchorVal) && "Expected function for a 'function' position!"
) ? static_cast<void> (0) : __assert_fail ("isa<Function>(AnchorVal) && \"Expected function for a 'function' position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 771, __PRETTY_FUNCTION__));
  assert(AnchorVal == &getAssociatedValue() && "Associated value mismatch!")((AnchorVal == &getAssociatedValue() && "Associated value mismatch!"
) ? static_cast<void> (0) : __assert_fail ("AnchorVal == &getAssociatedValue() && \"Associated value mismatch!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 772, __PRETTY_FUNCTION__));
  break;
}
775}

777namespace {

779/// Helper function to clamp a state \p S of type \p StateType with the
780/// information in \p R and indicate/return if \p S did change (as-in update is
781/// required to be run again).
782template <typename StateType>
783ChangeStatus clampStateAndIndicateChange(StateType &S, const StateType &R) {
auto Assumed = S.getAssumed();
S ^= R;
return Assumed == S.getAssumed() ? ChangeStatus::UNCHANGED
                                 : ChangeStatus::CHANGED;
788}

790/// Clamp the information known for all returned values of a function
791/// (identified by \p QueryingAA) into \p S.
792template <typename AAType, typename StateType = typename AAType::StateType>
793static void clampReturnedValueStates(Attributor &A, const AAType &QueryingAA,
                                   StateType &S) {
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() ==(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __PRETTY_FUNCTION__))
            IRPosition::IRP_RETURNED ||(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __PRETTY_FUNCTION__))
        QueryingAA.getIRPosition().getPositionKind() ==(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __PRETTY_FUNCTION__))
            IRPosition::IRP_CALL_SITE_RETURNED) &&(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __PRETTY_FUNCTION__))
       "Can only clamp returned value states for a function returned or call "(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __PRETTY_FUNCTION__))
       "site returned position!")(((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!") ? static_cast<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!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 803, __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);
  const AAType &AA = A.getAAFor<AAType>(QueryingAA, RVPos);
  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 = static_cast<const StateType &>(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;
829}

831/// Helper class to compose two generic deduction
832template <typename AAType, typename Base, typename StateType,
        template <typename...> class F, template <typename...> class G>
834struct AAComposeTwoGenericDeduction
  : public F<AAType, G<AAType, Base, StateType>, StateType> {
AAComposeTwoGenericDeduction(const IRPosition &IRP)
    : F<AAType, G<AAType, Base, StateType>, StateType>(IRP) {}

void initialize(Attributor &A) override {
  F<AAType, G<AAType, Base, StateType>, StateType>::initialize(A);
  G<AAType, Base, StateType>::initialize(A);
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus ChangedF =
      F<AAType, G<AAType, Base, StateType>, StateType>::updateImpl(A);
  ChangeStatus ChangedG = G<AAType, Base, StateType>::updateImpl(A);
  return ChangedF | ChangedG;
}
851};

853/// Helper class for generic deduction: return value -> returned position.
854template <typename AAType, typename Base,
        typename StateType = typename Base::StateType>
856struct AAReturnedFromReturnedValues : public Base {
AAReturnedFromReturnedValues(const IRPosition &IRP) : Base(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  StateType S(StateType::getBestState(this->getState()));
  clampReturnedValueStates<AAType, StateType>(A, *this, S);
  // 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);
}
867};

869/// Clamp the information known at all call sites for a given argument
870/// (identified by \p QueryingAA) into \p S.
871template <typename AAType, typename StateType = typename AAType::StateType>
872static 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() ==((QueryingAA.getIRPosition().getPositionKind() == IRPosition::
IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? static_cast<void> (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 879, __PRETTY_FUNCTION__))
           IRPosition::IRP_ARGUMENT &&((QueryingAA.getIRPosition().getPositionKind() == IRPosition::
IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? static_cast<void> (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 879, __PRETTY_FUNCTION__))
       "Can only clamp call site argument states for an argument position!")((QueryingAA.getIRPosition().getPositionKind() == IRPosition::
IRP_ARGUMENT && "Can only clamp call site argument states for an argument position!"
) ? static_cast<void> (0) : __assert_fail ("QueryingAA.getIRPosition().getPositionKind() == IRPosition::IRP_ARGUMENT && \"Can only clamp call site argument states for an argument position!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 879, __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().getArgNo();

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);
  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 = static_cast<const StateType &>(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 AllCallSitesKnown;
if (!A.checkForAllCallSites(CallSiteCheck, QueryingAA, true,
                            AllCallSitesKnown))
  S.indicatePessimisticFixpoint();
else if (T.hasValue())
  S ^= *T;
914}

916/// Helper class for generic deduction: call site argument -> argument position.
917template <typename AAType, typename Base,
        typename StateType = typename AAType::StateType>
919struct AAArgumentFromCallSiteArguments : public Base {
AAArgumentFromCallSiteArguments(const IRPosition &IRP) : Base(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  StateType S(StateType::getBestState(this->getState()));
  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);
}
930};

932/// Helper class for generic replication: function returned -> cs returned.
933template <typename AAType, typename Base,
        typename StateType = typename Base::StateType>
935struct AACallSiteReturnedFromReturned : public Base {
AACallSiteReturnedFromReturned(const IRPosition &IRP) : Base(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  assert(this->getIRPosition().getPositionKind() ==((this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED
 && "Can only wrap function returned positions for call site returned "
 "positions!") ? static_cast<void> (0) : __assert_fail (
"this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 943, __PRETTY_FUNCTION__))
             IRPosition::IRP_CALL_SITE_RETURNED &&((this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED
 && "Can only wrap function returned positions for call site returned "
 "positions!") ? static_cast<void> (0) : __assert_fail (
"this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 943, __PRETTY_FUNCTION__))
         "Can only wrap function returned positions for call site returned "((this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED
 && "Can only wrap function returned positions for call site returned "
 "positions!") ? static_cast<void> (0) : __assert_fail (
"this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 943, __PRETTY_FUNCTION__))
         "positions!")((this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED
 && "Can only wrap function returned positions for call site returned "
 "positions!") ? static_cast<void> (0) : __assert_fail (
"this->getIRPosition().getPositionKind() == IRPosition::IRP_CALL_SITE_RETURNED && \"Can only wrap function returned positions for call site returned \" \"positions!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 943, __PRETTY_FUNCTION__));
  auto &S = this->getState();

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

  IRPosition FnPos = IRPosition::returned(*AssociatedFunction);
  const AAType &AA = A.getAAFor<AAType>(*this, FnPos);
  return clampStateAndIndicateChange(
      S, static_cast<const StateType &>(AA.getState()));
}
956};

958/// Helper class for generic deduction using must-be-executed-context
959/// Base class is required to have `followUse` method.

961/// bool followUse(Attributor &A, const Use *U, const Instruction *I)
962/// U - Underlying use.
963/// I - The user of the \p U.
964/// `followUse` returns true if the value should be tracked transitively.

966template <typename AAType, typename Base,
        typename StateType = typename AAType::StateType>
968struct AAFromMustBeExecutedContext : public Base {
AAFromMustBeExecutedContext(const IRPosition &IRP) : Base(IRP) {}

void initialize(Attributor &A) override {
  Base::initialize(A);
  const IRPosition &IRP = this->getIRPosition();
  Instruction *CtxI = IRP.getCtxI();

  if (!CtxI)
    return;

  for (const Use &U : IRP.getAssociatedValue().uses())
    Uses.insert(&U);
}

/// Helper function to accumulate uses.
void followUsesInContext(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 && Base::followUse(A, U, UserI, State))
        for (const Use &Us : UserI->uses())
          Uses.insert(&Us);
    }
  }
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto BeforeState = this->getState();
  auto &S = this->getState();
  Instruction *CtxI = this->getIRPosition().getCtxI();
  if (!CtxI)
    return ChangeStatus::UNCHANGED;

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

  followUsesInContext(A, Explorer, CtxI, Uses, S);

  if (this->isAtFixpoint())
    return ChangeStatus::CHANGED;

  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(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;
  }

  return BeforeState == S ? ChangeStatus::UNCHANGED : ChangeStatus::CHANGED;
}

1084private:
/// Container for (transitive) uses of the associated value.
SetVector<const Use *> Uses;
1087};

1089template <typename AAType, typename Base,
        typename StateType = typename AAType::StateType>
1091using AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext =
  AAComposeTwoGenericDeduction<AAType, Base, StateType,
                               AAFromMustBeExecutedContext,
                               AAArgumentFromCallSiteArguments>;

1096template <typename AAType, typename Base,
        typename StateType = typename AAType::StateType>
1098using AACallSiteReturnedFromReturnedAndMustBeExecutedContext =
  AAComposeTwoGenericDeduction<AAType, Base, StateType,
                               AAFromMustBeExecutedContext,
                               AACallSiteReturnedFromReturned>;

1103/// -----------------------NoUnwind Function Attribute--------------------------

1105struct AANoUnwindImpl : AANoUnwind {
AANoUnwindImpl(const IRPosition &IRP) : AANoUnwind(IRP) {}

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 (ImmutableCallSite ICS = ImmutableCallSite(&I)) {
      const auto &NoUnwindAA =
          A.getAAFor<AANoUnwind>(*this, IRPosition::callsite_function(ICS));
      return NoUnwindAA.isAssumedNoUnwind();
    }
    return false;
  };

  if (!A.checkForAllInstructions(CheckForNoUnwind, *this, Opcodes))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}
1136};

1138struct AANoUnwindFunction final : public AANoUnwindImpl {
AANoUnwindFunction(const IRPosition &IRP) : AANoUnwindImpl(IRP) {}

/// 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); } }
1143};

1145/// NoUnwind attribute deduction for a call sites.
1146struct AANoUnwindCallSite final : AANoUnwindImpl {
AANoUnwindCallSite(const IRPosition &IRP) : AANoUnwindImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoUnwindImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AANoUnwind::StateType &>(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); }; }
1173};

1175/// --------------------- Function Return Values -------------------------------

1177/// "Attribute" that collects all potential returned values and the return
1178/// instructions that they arise from.
1179///
1180/// If there is a unique returned value R, the manifest method will:
1181///   - mark R with the "returned" attribute, if R is an argument.
1182class 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;

/// Mapping to remember the number of returned values for a call site such
/// that we can avoid updates if nothing changed.
DenseMap<const CallBase *, unsigned> NumReturnedValuesPerKnownAA;

/// Set of unresolved calls returned by the associated function.
SmallSetVector<CallBase *, 4> UnresolvedCalls;

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

1202public:
AAReturnedValuesImpl(const IRPosition &IRP) : AAReturnedValues(IRP) {}

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

  Function *F = getAssociatedFunction();
  if (!F) {
    indicatePessimisticFixpoint();
    return;
  }
  assert(!F->getReturnType()->isVoidTy() &&((!F->getReturnType()->isVoidTy() && "Did not expect a void return type!"
) ? static_cast<void> (0) : __assert_fail ("!F->getReturnType()->isVoidTy() && \"Did not expect a void return type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1218, __PRETTY_FUNCTION__))
         "Did not expect a void return type!")((!F->getReturnType()->isVoidTy() && "Did not expect a void return type!"
) ? static_cast<void> (0) : __assert_fail ("!F->getReturnType()->isVoidTy() && \"Did not expect a void return type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1218, __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];
      for (Instruction *RI : OpcodeInstMap[Instruction::Ret])
        ReturnInstSet.insert(cast<ReturnInst>(RI));

      indicateOptimisticFixpoint();
      return;
    }
  }

  if (!F->hasExactDefinition())
    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());
}

const SmallSetVector<CallBase *, 4> &getUnresolvedCalls() const override {
  return UnresolvedCalls;
}

/// 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(
    const 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;
}
1298};

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

// Bookkeeping.
assert(isValidState())((isValidState()) ? static_cast<void> (0) : __assert_fail
 ("isValidState()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1304, __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); };

// Callback to replace the uses of CB with the constant C.
auto ReplaceCallSiteUsersWith = [&A](CallBase &CB, Constant &C) {
  if (CB.getNumUses() == 0 || CB.isMustTailCall())
    return ChangeStatus::UNCHANGED;
  if (A.changeValueAfterManifest(CB, C))
    return ChangeStatus::CHANGED;
  return ChangeStatus::UNCHANGED;
};

// If the assumed unique return value is an argument, annotate it.
if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
  // TODO: This should be handled differently!
  this->AnchorVal = UniqueRVArg;
  this->KindOrArgNo = UniqueRVArg->getArgNo();
  Changed = IRAttribute::manifest(A);
} else if (auto *RVC = dyn_cast<Constant>(UniqueRV.getValue())) {
  // We can replace the returned value with the unique returned constant.
  Value &AnchorValue = getAnchorValue();
  if (Function *F = dyn_cast<Function>(&AnchorValue)) {
    for (const Use &U : F->uses())
      if (CallBase *CB = dyn_cast<CallBase>(U.getUser()))
        if (CB->isCallee(&U)) {
          Constant *RVCCast =
              CB->getType() == RVC->getType()
                  ? RVC
                  : ConstantExpr::getTruncOrBitCast(RVC, CB->getType());
          Changed = ReplaceCallSiteUsersWith(*CB, *RVCCast) | Changed;
        }
  } else {
    assert(isa<CallBase>(AnchorValue) &&((isa<CallBase>(AnchorValue) && "Expcected a function or call base anchor!"
) ? static_cast<void> (0) : __assert_fail ("isa<CallBase>(AnchorValue) && \"Expcected a function or call base anchor!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1348, __PRETTY_FUNCTION__))
           "Expcected a function or call base anchor!")((isa<CallBase>(AnchorValue) && "Expcected a function or call base anchor!"
) ? static_cast<void> (0) : __assert_fail ("isa<CallBase>(AnchorValue) && \"Expcected a function or call base anchor!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1348, __PRETTY_FUNCTION__));
    Constant *RVCCast =
        AnchorValue.getType() == RVC->getType()
            ? RVC
            : ConstantExpr::getTruncOrBitCast(RVC, AnchorValue.getType());
    Changed = ReplaceCallSiteUsersWith(cast<CallBase>(AnchorValue), *RVCCast);
  }
  if (Changed == ChangeStatus::CHANGED)
    STATS_DECLTRACK(UniqueConstantReturnValue, FunctionReturn,{ static llvm::Statistic NumIRFunctionReturn_UniqueConstantReturnValue
 = {"attributor", "NumIRFunctionReturn_UniqueConstantReturnValue"
, "Number of function returns replaced by constant return"};;
 ++(NumIRFunctionReturn_UniqueConstantReturnValue); }
                    "Number of function returns replaced by constant return"){ static llvm::Statistic NumIRFunctionReturn_UniqueConstantReturnValue
 = {"attributor", "NumIRFunctionReturn_UniqueConstantReturnValue"
, "Number of function returns replaced by constant return"};;
 ++(NumIRFunctionReturn_UniqueConstantReturnValue); };
}

return Changed;
1361}

1363const std::string AAReturnedValuesImpl::getAsStr() const {
return (isAtFixpoint() ? "returns(#" : "may-return(#") +
       (isValidState() ? std::to_string(getNumReturnValues()) : "?") +
       ")[#UC: " + std::to_string(UnresolvedCalls.size()) + "]";
1367}

1369Optional<Value *>
1370AAReturnedValuesImpl::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;

auto Pred = [&](Value &RV) -> bool {
  // If we found a second returned value and neither the current nor the saved
  // one is an undef, there is no unique returned value. Undefs are special
  // since we can pretend they have any value.
  if (UniqueRV.hasValue() && UniqueRV != &RV &&
      !(isa<UndefValue>(RV) || isa<UndefValue>(UniqueRV.getValue()))) {
    UniqueRV = nullptr;
    return false;
  }

  // Do not overwrite a value with an undef.
  if (!UniqueRV.hasValue() || !isa<UndefValue>(RV))
    UniqueRV = &RV;

  return true;
};

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

return UniqueRV;
1399}

1401bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
  const 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;

  CallBase *CB = dyn_cast<CallBase>(RV);
  if (CB && !UnresolvedCalls.count(CB))
    continue;

  if (!Pred(*RV, It.second))
    return false;
}

return true;
1421}

1423ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) {
size_t NumUnresolvedCalls = UnresolvedCalls.size();
bool Changed = false;

// State used in the value traversals starting in returned values.
struct RVState {
  // The map in which we collect return values -> return instrs.
  decltype(ReturnedValues) &RetValsMap;
  // The flag to indicate a change.
  bool &Changed;
  // The return instrs we come from.
  SmallSetVector<ReturnInst *, 4> RetInsts;
};

// Callback for a leaf value returned by the associated function.
auto VisitValueCB = [](Value &Val, RVState &RVS, bool) -> bool {
  auto Size = RVS.RetValsMap[&Val].size();
  RVS.RetValsMap[&Val].insert(RVS.RetInsts.begin(), RVS.RetInsts.end());
  bool Inserted = RVS.RetValsMap[&Val].size() != Size;
  RVS.Changed |= Inserted;
  LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (Inserted) dbgs() << "[AAReturnedValues] 1 Add new returned value "
 << Val << " => " << RVS.RetInsts.size()
 << "\n"; }; } } while (false)
    if (Inserted)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (Inserted) dbgs() << "[AAReturnedValues] 1 Add new returned value "
 << Val << " => " << RVS.RetInsts.size()
 << "\n"; }; } } while (false)
      dbgs() << "[AAReturnedValues] 1 Add new returned value " << Valdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (Inserted) dbgs() << "[AAReturnedValues] 1 Add new returned value "
 << Val << " => " << RVS.RetInsts.size()
 << "\n"; }; } } while (false)
             << " => " << RVS.RetInsts.size() << "\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (Inserted) dbgs() << "[AAReturnedValues] 1 Add new returned value "
 << Val << " => " << RVS.RetInsts.size()
 << "\n"; }; } } while (false)
  })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (Inserted) dbgs() << "[AAReturnedValues] 1 Add new returned value "
 << Val << " => " << RVS.RetInsts.size()
 << "\n"; }; } } while (false);
  return true;
};

// Helper method to invoke the generic value traversal.
auto VisitReturnedValue = [&](Value &RV, RVState &RVS) {
  IRPosition RetValPos = IRPosition::value(RV);
  return genericValueTraversal<AAReturnedValues, RVState>(A, RetValPos, *this,
                                                          RVS, VisitValueCB);
};

// Callback for all "return intructions" live in the associated function.
auto CheckReturnInst = [this, &VisitReturnedValue, &Changed](Instruction &I) {
  ReturnInst &Ret = cast<ReturnInst>(I);
  RVState RVS({ReturnedValues, Changed, {}});
  RVS.RetInsts.insert(&Ret);
  return VisitReturnedValue(*Ret.getReturnValue(), RVS);
};

// Start by discovering returned values from all live returned instructions in
// the associated function.
if (!A.checkForAllInstructions(CheckReturnInst, *this, {Instruction::Ret}))
  return indicatePessimisticFixpoint();

// Once returned values "directly" present in the code are handled we try to
// resolve returned calls.
decltype(ReturnedValues) NewRVsMap;
for (auto &It : ReturnedValues) {
  LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned value: " << *It.firstdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Returned value: "
 << *It.first << " by #" << It.second.size(
) << " RIs\n"; } } while (false)
                    << " by #" << It.second.size() << " RIs\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Returned value: "
 << *It.first << " by #" << It.second.size(
) << " RIs\n"; } } while (false);
  CallBase *CB = dyn_cast<CallBase>(It.first);
  if (!CB || UnresolvedCalls.count(CB))
    continue;

  if (!CB->getCalledFunction()) {
    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Unresolved call: " << *CBdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Unresolved call: "
 << *CB << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Unresolved call: "
 << *CB << "\n"; } } while (false);
    UnresolvedCalls.insert(CB);
    continue;
  }

  // TODO: use the function scope once we have call site AAReturnedValues.
  const auto &RetValAA = A.getAAFor<AAReturnedValues>(
      *this, IRPosition::function(*CB->getCalledFunction()));
  LLVM_DEBUG(dbgs() << "[AAReturnedValues] Found another AAReturnedValues: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Found another AAReturnedValues: "
 << RetValAA << "\n"; } } while (false)
                    << RetValAA << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Found another AAReturnedValues: "
 << RetValAA << "\n"; } } while (false);

  // Skip dead ends, thus if we do not know anything about the returned
  // call we mark it as unresolved and it will stay that way.
  if (!RetValAA.getState().isValidState()) {
    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Unresolved call: " << *CBdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Unresolved call: "
 << *CB << "\n"; } } while (false)
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Unresolved call: "
 << *CB << "\n"; } } while (false);
    UnresolvedCalls.insert(CB);
    continue;
  }

  // Do not try to learn partial information. If the callee has unresolved
  // return values we will treat the call as unresolved/opaque.
  auto &RetValAAUnresolvedCalls = RetValAA.getUnresolvedCalls();
  if (!RetValAAUnresolvedCalls.empty()) {
    UnresolvedCalls.insert(CB);
    continue;
  }

  // Now check if we can track transitively returned values. If possible, thus
  // if all return value can be represented in the current scope, do so.
  bool Unresolved = false;
  for (auto &RetValAAIt : RetValAA.returned_values()) {
    Value *RetVal = RetValAAIt.first;
    if (isa<Argument>(RetVal) || isa<CallBase>(RetVal) ||
        isa<Constant>(RetVal))
      continue;
    // Anything that did not fit in the above categories cannot be resolved,
    // mark the call as unresolved.
    LLVM_DEBUG(dbgs() << "[AAReturnedValues] transitively returned value "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] transitively returned value "
 "cannot be translated: " << *RetVal << "\n"; } }
 while (false)
                         "cannot be translated: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] transitively returned value "
 "cannot be translated: " << *RetVal << "\n"; } }
 while (false)
                      << *RetVal << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] transitively returned value "
 "cannot be translated: " << *RetVal << "\n"; } }
 while (false);
    UnresolvedCalls.insert(CB);
    Unresolved = true;
    break;
  }

  if (Unresolved)
    continue;

  // Now track transitively returned values.
  unsigned &NumRetAA = NumReturnedValuesPerKnownAA[CB];
  if (NumRetAA == RetValAA.getNumReturnValues()) {
    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Skip call as it has not "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Skip call as it has not "
 "changed since it was seen last\n"; } } while (false)
                         "changed since it was seen last\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Skip call as it has not "
 "changed since it was seen last\n"; } } while (false);
    continue;
  }
  NumRetAA = RetValAA.getNumReturnValues();

  for (auto &RetValAAIt : RetValAA.returned_values()) {
    Value *RetVal = RetValAAIt.first;
    if (Argument *Arg = dyn_cast<Argument>(RetVal)) {
      // Arguments are mapped to call site operands and we begin the traversal
      // again.
      bool Unused = false;
      RVState RVS({NewRVsMap, Unused, RetValAAIt.second});
      VisitReturnedValue(*CB->getArgOperand(Arg->getArgNo()), RVS);
      continue;
    } else if (isa<CallBase>(RetVal)) {
      // Call sites are resolved by the callee attribute over time, no need to
      // do anything for us.
      continue;
    } else if (isa<Constant>(RetVal)) {
      // Constants are valid everywhere, we can simply take them.
      NewRVsMap[RetVal].insert(It.second.begin(), It.second.end());
      continue;
    }
  }
}

// To avoid modifications to the ReturnedValues map while we iterate over it
// we kept record of potential new entries in a copy map, NewRVsMap.
for (auto &It : NewRVsMap) {
  assert(!It.second.empty() && "Entry does not add anything.")((!It.second.empty() && "Entry does not add anything."
) ? static_cast<void> (0) : __assert_fail ("!It.second.empty() && \"Entry does not add anything.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1565, __PRETTY_FUNCTION__));
  auto &ReturnInsts = ReturnedValues[It.first];
  for (ReturnInst *RI : It.second)
    if (ReturnInsts.insert(RI)) {
      LLVM_DEBUG(dbgs() << "[AAReturnedValues] Add new returned value "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Add new returned value "
 << *It.first << " => " << *RI << "\n"
; } } while (false)
                        << *It.first << " => " << *RI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAReturnedValues] Add new returned value "
 << *It.first << " => " << *RI << "\n"
; } } while (false);
      Changed = true;
    }
}

Changed |= (NumUnresolvedCalls != UnresolvedCalls.size());
return Changed ? ChangeStatus::CHANGED : ChangeStatus::UNCHANGED;
1577}

1579struct AAReturnedValuesFunction final : public AAReturnedValuesImpl {
AAReturnedValuesFunction(const IRPosition &IRP) : AAReturnedValuesImpl(IRP) {}

/// 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); } }
1584};

1586/// Returned values information for a call sites.
1587struct AAReturnedValuesCallSite final : AAReturnedValuesImpl {
AAReturnedValuesCallSite(const IRPosition &IRP) : AAReturnedValuesImpl(IRP) {}

/// 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!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1597)
                   "supported for call sites yet!")::llvm::llvm_unreachable_internal("Abstract attributes for returned values are not "
 "supported for call sites yet!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1597);
}

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

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

1609/// ------------------------ NoSync Function Attribute -------------------------

1611struct AANoSyncImpl : AANoSync {
AANoSyncImpl(const IRPosition &IRP) : AANoSync(IRP) {}

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

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

/// Helper function used to determine whether an instruction is non-relaxed
/// atomic. In other words, if an atomic instruction does not have unordered
/// or monotonic ordering
static bool isNonRelaxedAtomic(Instruction *I);

/// Helper function used to determine whether an instruction is volatile.
static bool isVolatile(Instruction *I);

/// Helper function uset to check if intrinsic is volatile (memcpy, memmove,
/// memset).
static bool isNoSyncIntrinsic(Instruction *I);
1632};

1634bool AANoSyncImpl::isNonRelaxedAtomic(Instruction *I) {
if (!I->isAtomic())
  return false;

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;
case Instruction::Fence: {
  auto *FI = cast<FenceInst>(I);
  if (FI->getSyncScopeID() == SyncScope::SingleThread)
    return false;
  Ordering = FI->getOrdering();
  break;
}
case Instruction::AtomicCmpXchg: {
  AtomicOrdering Success = cast<AtomicCmpXchgInst>(I)->getSuccessOrdering();
  AtomicOrdering Failure = cast<AtomicCmpXchgInst>(I)->getFailureOrdering();
  // Only if both are relaxed, than it can be treated as relaxed.
  // Otherwise it is non-relaxed.
  if (Success != AtomicOrdering::Unordered &&
      Success != AtomicOrdering::Monotonic)
    return true;
  if (Failure != AtomicOrdering::Unordered &&
      Failure != AtomicOrdering::Monotonic)
    return true;
  return false;
}
default:
  llvm_unreachable(::llvm::llvm_unreachable_internal("New atomic operations need to be known in the attributor."
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1671)
      "New atomic operations need to be known in the attributor.")::llvm::llvm_unreachable_internal("New atomic operations need to be known in the attributor."
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1671);
}

// Relaxed.
if (Ordering == AtomicOrdering::Unordered ||
    Ordering == AtomicOrdering::Monotonic)
  return false;
return true;
1679}

1681/// Checks if an intrinsic is nosync. Currently only checks mem* intrinsics.
1682/// FIXME: We should ipmrove the handling of intrinsics.
1683bool AANoSyncImpl::isNoSyncIntrinsic(Instruction *I) {
if (auto *II = dyn_cast<IntrinsicInst>(I)) {
  switch (II->getIntrinsicID()) {
  /// Element wise atomic memory intrinsics are can only be unordered,
  /// therefore nosync.
  case Intrinsic::memset_element_unordered_atomic:
  case Intrinsic::memmove_element_unordered_atomic:
  case Intrinsic::memcpy_element_unordered_atomic:
    return true;
  case Intrinsic::memset:
  case Intrinsic::memmove:
  case Intrinsic::memcpy:
    if (!cast<MemIntrinsic>(II)->isVolatile())
      return true;
    return false;
  default:
    return false;
  }
}
return false;
1703}

1705bool AANoSyncImpl::isVolatile(Instruction *I) {
assert(!ImmutableCallSite(I) && !isa<CallBase>(I) &&((!ImmutableCallSite(I) && !isa<CallBase>(I) &&
 "Calls should not be checked here") ? static_cast<void>
 (0) : __assert_fail ("!ImmutableCallSite(I) && !isa<CallBase>(I) && \"Calls should not be checked here\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1707, __PRETTY_FUNCTION__))
       "Calls should not be checked here")((!ImmutableCallSite(I) && !isa<CallBase>(I) &&
 "Calls should not be checked here") ? static_cast<void>
 (0) : __assert_fail ("!ImmutableCallSite(I) && !isa<CallBase>(I) && \"Calls should not be checked here\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1707, __PRETTY_FUNCTION__));

switch (I->getOpcode()) {
case Instruction::AtomicRMW:
  return cast<AtomicRMWInst>(I)->isVolatile();
case Instruction::Store:
  return cast<StoreInst>(I)->isVolatile();
case Instruction::Load:
  return cast<LoadInst>(I)->isVolatile();
case Instruction::AtomicCmpXchg:
  return cast<AtomicCmpXchgInst>(I)->isVolatile();
default:
  return false;
}
1721}

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

auto CheckRWInstForNoSync = [&](Instruction &I) {
  /// We are looking for volatile instructions or Non-Relaxed atomics.
  /// FIXME: We should improve the handling of intrinsics.

  if (isa<IntrinsicInst>(&I) && isNoSyncIntrinsic(&I))
    return true;

  if (ImmutableCallSite ICS = ImmutableCallSite(&I)) {
    if (ICS.hasFnAttr(Attribute::NoSync))
      return true;

    const auto &NoSyncAA =
        A.getAAFor<AANoSync>(*this, IRPosition::callsite_function(ICS));
    if (NoSyncAA.isAssumedNoSync())
      return true;
    return false;
  }

  if (!isVolatile(&I) && !isNonRelaxedAtomic(&I))
    return true;

  return false;
};

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 !ImmutableCallSite(&I).isConvergent();
};

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

return ChangeStatus::UNCHANGED;
1764}

1766struct AANoSyncFunction final : public AANoSyncImpl {
AANoSyncFunction(const IRPosition &IRP) : AANoSyncImpl(IRP) {}

/// 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); } }
1771};

1773/// NoSync attribute deduction for a call sites.
1774struct AANoSyncCallSite final : AANoSyncImpl {
AANoSyncCallSite(const IRPosition &IRP) : AANoSyncImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoSyncImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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);
  return clampStateAndIndicateChange(
      getState(), static_cast<const AANoSync::StateType &>(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
); }; }
1800};

1802/// ------------------------ No-Free Attributes ----------------------------

1804struct AANoFreeImpl : public AANoFree {
AANoFreeImpl(const IRPosition &IRP) : AANoFree(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto CheckForNoFree = [&](Instruction &I) {
    ImmutableCallSite ICS(&I);
    if (ICS.hasFnAttr(Attribute::NoFree))
      return true;

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

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

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

1830struct AANoFreeFunction final : public AANoFreeImpl {
AANoFreeFunction(const IRPosition &IRP) : AANoFreeImpl(IRP) {}

/// 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); } }
1835};

1837/// NoFree attribute deduction for a call sites.
1838struct AANoFreeCallSite final : AANoFreeImpl {
AANoFreeCallSite(const IRPosition &IRP) : AANoFreeImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoFreeImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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);
  return clampStateAndIndicateChange(
      getState(), static_cast<const AANoFree::StateType &>(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
); }; }
1864};

1866/// NoFree attribute for floating values.
1867struct AANoFreeFloating : AANoFreeImpl {
AANoFreeFloating(const IRPosition &IRP) : AANoFreeImpl(IRP) {}

/// 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));
  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));
      return NoFreeArg.isAssumedNoFree();
    }

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

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

  return ChangeStatus::UNCHANGED;
}
1913};

1915/// NoFree attribute for a call site argument.
1916struct AANoFreeArgument final : AANoFreeFloating {
AANoFreeArgument(const IRPosition &IRP) : AANoFreeFloating(IRP) {}

/// 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); } }
1921};

1923/// NoFree attribute for call site arguments.
1924struct AANoFreeCallSiteArgument final : AANoFreeFloating {
AANoFreeCallSiteArgument(const IRPosition &IRP) : AANoFreeFloating(IRP) {}

/// 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);
  return clampStateAndIndicateChange(
      getState(), static_cast<const AANoFree::StateType &>(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); }};
1944};

1946/// NoFree attribute for function return value.
1947struct AANoFreeReturned final : AANoFreeFloating {
AANoFreeReturned(const IRPosition &IRP) : AANoFreeFloating(IRP) {
  llvm_unreachable("NoFree is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoFree is not applicable to function returns!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1949);
}

/// 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!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1954);
}

/// 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!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 1959);
}

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

1966/// NoFree attribute deduction for a call site return value.
1967struct AANoFreeCallSiteReturned final : AANoFreeFloating {
AANoFreeCallSiteReturned(const IRPosition &IRP) : AANoFreeFloating(IRP) {}

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); } }
1975};

1977/// ------------------------ NonNull Argument Attribute ------------------------
1978static 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;

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 (ImmutableCallSite ICS = ImmutableCallSite(I)) {
  if (ICS.isBundleOperand(U))
    return 0;

  if (ICS.isCallee(U)) {
    IsNonNull |= !NullPointerIsDefined;
    return 0;
  }

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

// 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 (auto *GEP = dyn_cast<GetElementPtrInst>(I))
  if (GEP->hasAllConstantIndices()) {
    TrackUse = true;
    return 0;
  }

int64_t Offset;
if (const Value *Base = getBasePointerOfAccessPointerOperand(I, Offset, DL)) {
  if (Base == &AssociatedValue &&
      getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
    int64_t DerefBytes =
        (int64_t)DL.getTypeStoreSize(PtrTy->getPointerElementType()) + Offset;

    IsNonNull |= !NullPointerIsDefined;
    return std::max(int64_t(0), DerefBytes);
  }
}

/// Corner case when an offset is 0.
if (const Value *Base = getBasePointerOfAccessPointerOperand(
        I, Offset, DL, /*AllowNonInbounds*/ true)) {
  if (Offset == 0 && Base == &AssociatedValue &&
      getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
    int64_t DerefBytes =
        (int64_t)DL.getTypeStoreSize(PtrTy->getPointerElementType());
    IsNonNull |= !NullPointerIsDefined;
    return std::max(int64_t(0), DerefBytes);
  }
}

return 0;
2049}

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

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (!NullIsDefined &&
      hasAttr({Attribute::NonNull, Attribute::Dereferenceable}))
    indicateOptimisticFixpoint();
  else if (isa<ConstantPointerNull>(getAssociatedValue()))
    indicatePessimisticFixpoint();
  else
    AANonNull::initialize(A);
}

/// See AAFromMustBeExecutedContext
bool followUse(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;
2088};

2090/// NonNull attribute for a floating value.
2091struct AANonNullFloating
  : AAFromMustBeExecutedContext<AANonNull, AANonNullImpl> {
using Base = AAFromMustBeExecutedContext<AANonNull, AANonNullImpl>;
AANonNullFloating(const IRPosition &IRP) : Base(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Change = Base::updateImpl(A);
  if (isKnownNonNull())
    return Change;

  if (!NullIsDefined) {
    const auto &DerefAA =
        A.getAAFor<AADereferenceable>(*this, getIRPosition());
    if (DerefAA.getAssumedDereferenceableBytes())
      return Change;
  }

  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, AANonNull::StateType &T,
                          bool Stripped) -> bool {
    const auto &AA = A.getAAFor<AANonNull>(*this, IRPosition::value(V));
    if (!Stripped && this == &AA) {
      if (!isKnownNonZero(&V, DL, 0, AC, getCtxI(), DT))
        T.indicatePessimisticFixpoint();
    } else {
      // Use abstract attribute information.
      const AANonNull::StateType &NS =
          static_cast<const AANonNull::StateType &>(AA.getState());
      T ^= NS;
    }
    return T.isValidState();
  };

  StateType T;
  if (!genericValueTraversal<AANonNull, StateType>(A, getIRPosition(), *this,
                                                   T, VisitValueCB))
    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
); } }
2144};

2146/// NonNull attribute for function return value.
2147struct AANonNullReturned final
  : AAReturnedFromReturnedValues<AANonNull, AANonNullImpl> {
AANonNullReturned(const IRPosition &IRP)
    : AAReturnedFromReturnedValues<AANonNull, AANonNullImpl>(IRP) {}

/// 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
); } }
2154};

2156/// NonNull attribute for function argument.
2157struct AANonNullArgument final
  : AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<AANonNull,
                                                            AANonNullImpl> {
AANonNullArgument(const IRPosition &IRP)
    : AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<AANonNull,
                                                              AANonNullImpl>(
          IRP) {}

/// 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); } }
2167};

2169struct AANonNullCallSiteArgument final : AANonNullFloating {
AANonNullCallSiteArgument(const IRPosition &IRP) : AANonNullFloating(IRP) {}

/// 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); } }
2174};

2176/// NonNull attribute for a call site return position.
2177struct AANonNullCallSiteReturned final
  : AACallSiteReturnedFromReturnedAndMustBeExecutedContext<AANonNull,
                                                           AANonNullImpl> {
AANonNullCallSiteReturned(const IRPosition &IRP)
    : AACallSiteReturnedFromReturnedAndMustBeExecutedContext<AANonNull,
                                                             AANonNullImpl>(
          IRP) {}

/// 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); } }
2187};

2189/// ------------------------ No-Recurse Attributes ----------------------------

2191struct AANoRecurseImpl : public AANoRecurse {
AANoRecurseImpl(const IRPosition &IRP) : AANoRecurse(IRP) {}

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

2200struct AANoRecurseFunction final : AANoRecurseImpl {
AANoRecurseFunction(const IRPosition &IRP) : AANoRecurseImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoRecurseImpl::initialize(A);
  if (const Function *F = getAnchorScope())
    if (A.getInfoCache().getSccSize(*F) != 1)
      indicatePessimisticFixpoint();
}

/// 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()),
        /* TrackDependence */ false, DepClassTy::OPTIONAL);
    return NoRecurseAA.isKnownNoRecurse();
  };
  bool AllCallSitesKnown;
  if (A.checkForAllCallSites(CallSitePred, *this, true, AllCallSitesKnown)) {
    // 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 (AllCallSitesKnown)
      indicateOptimisticFixpoint();
    return ChangeStatus::UNCHANGED;
  }

  // If the above check does not hold anymore we look at the calls.
  auto CheckForNoRecurse = [&](Instruction &I) {
    ImmutableCallSite ICS(&I);
    if (ICS.hasFnAttr(Attribute::NoRecurse))
      return true;

    const auto &NoRecurseAA =
        A.getAAFor<AANoRecurse>(*this, IRPosition::callsite_function(ICS));
    if (!NoRecurseAA.isAssumedNoRecurse())
      return false;

    // Recursion to the same function
    if (ICS.getCalledFunction() == getAnchorScope())
      return false;

    return true;
  };

  if (!A.checkForAllCallLikeInstructions(CheckForNoRecurse, *this))
    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); } }
2257};

2259/// NoRecurse attribute deduction for a call sites.
2260struct AANoRecurseCallSite final : AANoRecurseImpl {
AANoRecurseCallSite(const IRPosition &IRP) : AANoRecurseImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoRecurseImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AANoRecurse::StateType &>(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); }; }
2287};

2289/// -------------------- Undefined-Behavior Attributes ------------------------

2291struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior {
AAUndefinedBehaviorImpl(const IRPosition &IRP) : AAUndefinedBehavior(IRP) {}

/// 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) {
    // 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.
    const Value *PtrOp = getPointerOperand(&I, /* AllowVolatile */ true);
    assert(PtrOp &&((PtrOp && "Expected pointer operand of memory accessing instruction"
) ? static_cast<void> (0) : __assert_fail ("PtrOp && \"Expected pointer operand of memory accessing instruction\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 2310, __PRETTY_FUNCTION__))
           "Expected pointer operand of memory accessing instruction")((PtrOp && "Expected pointer operand of memory accessing instruction"
) ? static_cast<void> (0) : __assert_fail ("PtrOp && \"Expected pointer operand of memory accessing instruction\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 2310, __PRETTY_FUNCTION__));

    // 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>(PtrOp)) {
      AssumedNoUBInsts.insert(&I);
      return true;
    }
    const Type *PtrTy = PtrOp->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())
      return true;
    AssumedNoUBInsts.insert(&I);
    return true;
  };

  A.checkForAllInstructions(InspectMemAccessInstForUB, *this,
                            {Instruction::Load, Instruction::Store,
                             Instruction::AtomicCmpXchg,
                             Instruction::AtomicRMW},
                            /* CheckBBLivenessOnly */ true);
  A.checkForAllInstructions(InspectBrInstForUB, *this, {Instruction::Br},
                            /* 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.

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

2441private:
/// 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, const Value *V,
                                       Instruction *I) {
  const auto &ValueSimplifyAA =
      A.getAAFor<AAValueSimplify>(*this, IRPosition::value(*V));
  Optional<Value *> SimplifiedV =
      ValueSimplifyAA.getAssumedSimplifiedValue(A);
  if (!ValueSimplifyAA.isKnown()) {
    // Don't depend on assumed values.
    return llvm::None;
  }
  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;
  }
  Value *Val = SimplifiedV.getValue();
  if (isa<UndefValue>(Val)) {
    KnownUBInsts.insert(I);
    return llvm::None;
  }
  return Val;
}
2477};

2479struct AAUndefinedBehaviorFunction final : AAUndefinedBehaviorImpl {
AAUndefinedBehaviorFunction(const IRPosition &IRP)
    : AAUndefinedBehaviorImpl(IRP) {}

/// 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();
}
2490};

2492/// ------------------------ Will-Return Attributes ----------------------------

2494// Helper function that checks whether a function has any cycle.
2495// TODO: Replace with more efficent code
2496static bool containsCycle(Function &F) {
SmallPtrSet<BasicBlock *, 32> Visited;

// Traverse BB by dfs and check whether successor is already visited.
for (BasicBlock *BB : depth_first(&F)) {
  Visited.insert(BB);
  for (auto *SuccBB : successors(BB)) {
    if (Visited.count(SuccBB))
      return true;
  }
}
return false;
2508}

2510// Helper function that checks the function have a loop which might become an
2511// endless loop
2512// FIXME: Any cycle is regarded as endless loop for now.
2513//        We have to allow some patterns.
2514static bool containsPossiblyEndlessLoop(Function *F) {
return !F || !F->hasExactDefinition() || containsCycle(*F);
2516}

2518struct AAWillReturnImpl : public AAWillReturn {
AAWillReturnImpl(const IRPosition &IRP) : AAWillReturn(IRP) {}

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

  Function *F = getAssociatedFunction();
  if (containsPossiblyEndlessLoop(F))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  auto CheckForWillReturn = [&](Instruction &I) {
    IRPosition IPos = IRPosition::callsite_function(ImmutableCallSite(&I));
    const auto &WillReturnAA = A.getAAFor<AAWillReturn>(*this, IPos);
    if (WillReturnAA.isKnownWillReturn())
      return true;
    if (!WillReturnAA.isAssumedWillReturn())
      return false;
    const auto &NoRecurseAA = A.getAAFor<AANoRecurse>(*this, IPos);
    return NoRecurseAA.isAssumedNoRecurse();
  };

  if (!A.checkForAllCallLikeInstructions(CheckForWillReturn, *this))
    return indicatePessimisticFixpoint();

  return ChangeStatus::UNCHANGED;
}

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

2555struct AAWillReturnFunction final : AAWillReturnImpl {
AAWillReturnFunction(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}

/// 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); } }
2560};

2562/// WillReturn attribute deduction for a call sites.
2563struct AAWillReturnCallSite final : AAWillReturnImpl {
AAWillReturnCallSite(const IRPosition &IRP) : AAWillReturnImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAWillReturnImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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<AAWillReturn>(*this, FnPos);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AAWillReturn::StateType &>(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); }; }
2590};

2592/// -------------------AAReachability Attribute--------------------------

2594struct AAReachabilityImpl : AAReachability {
AAReachabilityImpl(const IRPosition &IRP) : AAReachability(IRP) {}

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

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

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

2611struct AAReachabilityFunction final : public AAReachabilityImpl {
AAReachabilityFunction(const IRPosition &IRP) : AAReachabilityImpl(IRP) {}

/// 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); }; }
2616};

2618/// ------------------------ NoAlias Argument Attribute ------------------------

2620struct AANoAliasImpl : AANoAlias {
AANoAliasImpl(const IRPosition &IRP) : AANoAlias(IRP) {
  assert(getAssociatedType()->isPointerTy() &&((getAssociatedType()->isPointerTy() && "Noalias is a pointer attribute"
) ? static_cast<void> (0) : __assert_fail ("getAssociatedType()->isPointerTy() && \"Noalias is a pointer attribute\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 2623, __PRETTY_FUNCTION__))
         "Noalias is a pointer attribute")((getAssociatedType()->isPointerTy() && "Noalias is a pointer attribute"
) ? static_cast<void> (0) : __assert_fail ("getAssociatedType()->isPointerTy() && \"Noalias is a pointer attribute\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 2623, __PRETTY_FUNCTION__));
}

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

2631/// NoAlias attribute for a floating value.
2632struct AANoAliasFloating final : AANoAliasImpl {
AANoAliasFloating(const IRPosition &IRP) : AANoAliasImpl(IRP) {}

/// 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->getNumUses() != 1)
      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));
    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); }
}
2678};

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

/// 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()));
  if (NoSyncAA.isAssumedNoSync())
    return Base::updateImpl(A);

  // If the argument is read-only, no-alias cannot break synchronization.
  const auto &MemBehaviorAA =
      A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
  if (MemBehaviorAA.isAssumedReadOnly())
    return Base::updateImpl(A);

  // If the argument is never passed through callbacks, no-alias cannot break
  // synchronization.
  bool AllCallSitesKnown;
  if (A.checkForAllCallSites(
          [](AbstractCallSite ACS) { return !ACS.isCallbackCall(); }, *this,
          true, AllCallSitesKnown))
    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); } }
2732};

2734struct AANoAliasCallSiteArgument final : AANoAliasImpl {
AANoAliasCallSiteArgument(const IRPosition &IRP) : AANoAliasImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // See callsite argument attribute and callee argument attribute.
  ImmutableCallSite ICS(&getAnchorValue());
  if (ICS.paramHasAttr(getArgNo(), 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,
                          ImmutableCallSite ICS, unsigned OtherArgNo) {
  // We do not need to worry about aliasing with the underlying IRP.
  if (this->getArgNo() == (int)OtherArgNo)
    return false;

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

  auto &ICSArgMemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
      *this, IRPosition::callsite_argument(ICS, OtherArgNo),
      /* TrackDependence */ false);

  // If the argument is readnone, there is no read-write aliasing.
  if (ICSArgMemBehaviorAA.isAssumedReadNone()) {
    A.recordDependence(ICSArgMemBehaviorAA, *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 (ICSArgMemBehaviorAA.isAssumedReadOnly() && IsReadOnly) {
    A.recordDependence(MemBehaviorAA, *this, DepClassTy::OPTIONAL);
    A.recordDependence(ICSArgMemBehaviorAA, *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;
  }

  const IRPosition &VIRP = IRPosition::value(getAssociatedValue());
  auto &NoCaptureAA =
      A.getAAFor<AANoCapture>(*this, VIRP, /* TrackDependence */ false);
  // Check whether the value is captured in the scope using AANoCapture.
  // FIXME: This is conservative though, it is better to look at CFG and
  //        check only uses possibly executed before this callsite.
  if (!NoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
    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
  ImmutableCallSite ICS(&getAnchorValue());
  for (unsigned OtherArgNo = 0; OtherArgNo < ICS.getNumArgOperands();
       OtherArgNo++)
    if (mayAliasWithArgument(A, AAR, MemBehaviorAA, ICS, 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(),
                                   /* TrackDependence */ false);
  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,
                                                /* TrackDependence */ false);

  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); } }
2870};

2872/// NoAlias attribute for function return value.
2873struct AANoAliasReturned final : AANoAliasImpl {
AANoAliasReturned(const IRPosition &IRP) : AANoAliasImpl(IRP) {}

/// 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.
    ImmutableCallSite ICS(&RV);
    if (!ICS)
      return false;

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

    const auto &NoCaptureAA = A.getAAFor<AANoCapture>(*this, RVPos);
    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
); } }
2907};

2909/// NoAlias attribute deduction for a call site return value.
2910struct AANoAliasCallSiteReturned final : AANoAliasImpl {
AANoAliasCallSiteReturned(const IRPosition &IRP) : AANoAliasImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoAliasImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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);
  return clampStateAndIndicateChange(
      getState(), static_cast<const AANoAlias::StateType &>(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); }; }
2936};

2938/// -------------------AAIsDead Function Attribute-----------------------

2940struct AAIsDeadValueImpl : public AAIsDead {
AAIsDeadValueImpl(const IRPosition &IRP) : AAIsDead(IRP) {}

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

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

/// 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) && getKnown();
}

/// 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) {
  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, 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.getAAFor<AANoUnwind>(*this, CallIRP);
  if (!NoUnwindAA.isAssumedNoUnwind())
    return false;

  const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(*this, CallIRP);
  if (!MemBehaviorAA.isAssumedReadOnly())
    return false;

  return true;
}
3000};

3002struct AAIsDeadFloating : public AAIsDeadValueImpl {
AAIsDeadFloating(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}

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

  Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
  if (!isAssumedSideEffectFree(A, I))
    indicatePessimisticFixpoint();
}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  Instruction *I = dyn_cast<Instruction>(&getAssociatedValue());
  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 (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 =
      getAssumedConstant(A, V, *this, UsedAssumedInformation);
  if (C.hasValue() && C.getValue())
    return ChangeStatus::UNCHANGED;

  UndefValue &UV = *UndefValue::get(V.getType());
  bool AnyChange = A.changeValueAfterManifest(V, UV);
  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); }
}
3059};

3061struct AAIsDeadArgument : public AAIsDeadFloating {
AAIsDeadArgument(const IRPosition &IRP) : AAIsDeadFloating(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (!getAssociatedFunction()->hasExactDefinition())
    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{}))
      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); } }
3085};

3087struct AAIsDeadCallSiteArgument : public AAIsDeadValueImpl {
AAIsDeadCallSiteArgument(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}

/// 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);
  return clampStateAndIndicateChange(
      getState(), static_cast<const AAIsDead::StateType &>(ArgAA.getState()));
}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  CallBase &CB = cast<CallBase>(getAnchorValue());
  Use &U = CB.getArgOperandUse(getArgNo());
  assert(!isa<UndefValue>(U.get()) &&((!isa<UndefValue>(U.get()) && "Expected undef values to be filtered out!"
) ? static_cast<void> (0) : __assert_fail ("!isa<UndefValue>(U.get()) && \"Expected undef values to be filtered out!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3116, __PRETTY_FUNCTION__))
         "Expected undef values to be filtered out!")((!isa<UndefValue>(U.get()) && "Expected undef values to be filtered out!"
) ? static_cast<void> (0) : __assert_fail ("!isa<UndefValue>(U.get()) && \"Expected undef values to be filtered out!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3116, __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); } }
3125};

3127struct AAIsDeadCallSiteReturned : public AAIsDeadFloating {
AAIsDeadCallSiteReturned(const IRPosition &IRP)
    : AAIsDeadFloating(IRP), IsAssumedSideEffectFree(true) {}

/// 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::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  if (auto *CI = dyn_cast<CallInst>(&getAssociatedValue()))
    if (CI->isMustTailCall())
      return ChangeStatus::UNCHANGED;
  return AAIsDeadFloating::manifest(A);
}

/// 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");
}

3183private:
bool IsAssumedSideEffectFree;
3185};

3187struct AAIsDeadReturned : public AAIsDeadValueImpl {
AAIsDeadReturned(const IRPosition &IRP) : AAIsDeadValueImpl(IRP) {}

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

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

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

  bool AllCallSitesKnown;
  if (!A.checkForAllCallSites(PredForCallSite, *this, true,
                              AllCallSitesKnown))
    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 (auto *CI = dyn_cast<CallInst>(RI.getReturnValue()))
      if (CI->isMustTailCall())
        return true;
    if (!isa<UndefValue>(RI.getReturnValue()))
      AnyChange |= A.changeUseAfterManifest(RI.getOperandUse(0), UV);
    return true;
  };
  A.checkForAllInstructions(RetInstPred, *this, {Instruction::Ret});
  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);
 } }
3230};

3232struct AAIsDeadFunction : public AAIsDead {
AAIsDeadFunction(const IRPosition &IRP) : AAIsDead(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  const Function *F = getAssociatedFunction();
  if (F && !F->isDeclaration()) {
    ToBeExploredFrom.insert(&F->getEntryBlock().front());
    assumeLive(A, F->getEntryBlock());
  }
}

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

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  assert(getState().isValidState() &&((getState().isValidState() && "Attempted to manifest an invalid state!"
) ? static_cast<void> (0) : __assert_fail ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3255, __PRETTY_FUNCTION__))
         "Attempted to manifest an invalid state!")((getState().isValidState() && "Attempted to manifest an invalid state!"
) ? static_cast<void> (0) : __assert_fail ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3255, __PRETTY_FUNCTION__));

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

  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.getAAFor<AANoReturn>(*this, IRPosition::callsite_function(*CB));
    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;
  }

  for (BasicBlock &BB : F)
    if (!AssumedLiveBlocks.count(&BB))
      A.deleteAfterManifest(BB);

  return HasChanged;
}

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

/// 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() == getAssociatedFunction() &&((BB->getParent() == getAssociatedFunction() && "BB must be in the same anchor scope function."
) ? static_cast<void> (0) : __assert_fail ("BB->getParent() == getAssociatedFunction() && \"BB must be in the same anchor scope function.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3311, __PRETTY_FUNCTION__))
         "BB must be in the same anchor scope function.")((BB->getParent() == getAssociatedFunction() && "BB must be in the same anchor scope function."
) ? static_cast<void> (0) : __assert_fail ("BB->getParent() == getAssociatedFunction() && \"BB must be in the same anchor scope function.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3311, __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() == getAssociatedFunction() &&((I->getParent()->getParent() == getAssociatedFunction(
) && "Instruction must be in the same anchor scope function."
) ? static_cast<void> (0) : __assert_fail ("I->getParent()->getParent() == getAssociatedFunction() && \"Instruction must be in the same anchor scope function.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3326, __PRETTY_FUNCTION__))
         "Instruction must be in the same anchor scope function.")((I->getParent()->getParent() == getAssociatedFunction(
) && "Instruction must be in the same anchor scope function."
) ? static_cast<void> (0) : __assert_fail ("I->getParent()->getParent() == getAssociatedFunction() && \"Instruction must be in the same anchor scope function.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3326, __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);
}

/// Determine if \p F might catch asynchronous exceptions.
static bool mayCatchAsynchronousExceptions(const Function &F) {
  return F.hasPersonalityFn() && !canSimplifyInvokeNoUnwind(&F);
}

/// 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 (ImmutableCallSite ICS = ImmutableCallSite(&I))
      if (const Function *F = ICS.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 BasicBlocks.
DenseSet<const BasicBlock *> AssumedLiveBlocks;
3383};

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

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

3401static bool
3402identifyAliveSuccessors(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.getAAFor<AANoUnwind>(AA, IPos);
  if (AANoUnw.isAssumedNoUnwind()) {
    UsedAssumedInformation |= !AANoUnw.isKnownNoUnwind();
  } else {
    AliveSuccessors.push_back(&II.getUnwindDest()->front());
  }
}
return UsedAssumedInformation;
3423}

3425static bool
3426identifyAliveSuccessors(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<ConstantInt *> CI = getAssumedConstantInt(
      A, *BI.getCondition(), AA, UsedAssumedInformation);
  if (!CI.hasValue()) {
    // No value yet, assume both edges are dead.
  } else if (CI.getValue()) {
    const BasicBlock *SuccBB =
        BI.getSuccessor(1 - CI.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;
3448}

3450static bool
3451identifyAliveSuccessors(Attributor &A, const SwitchInst &SI,
                      AbstractAttribute &AA,
                      SmallVectorImpl<const Instruction *> &AliveSuccessors) {
bool UsedAssumedInformation = false;
Optional<ConstantInt *> CI =
    getAssumedConstantInt(A, *SI.getCondition(), AA, UsedAssumedInformation);
if (!CI.hasValue()) {
  // No value yet, assume all edges are dead.
} else if (CI.getValue()) {
  for (auto &CaseIt : SI.cases()) {
    if (CaseIt.getCaseValue() == CI.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;
3473}

3475ChangeStatus 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() << "/" << getAssociatedFunction
()->size() << "] BBs and " << ToBeExploredFrom
.size() << " exploration points and " << KnownDeadEnds
.size() << " known dead ends\n"; } } while (false)
                  << getAssociatedFunction()->size() << "] BBs and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAIsDead] Live [" <<
 AssumedLiveBlocks.size() << "/" << getAssociatedFunction
()->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() << "/" << getAssociatedFunction
()->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() << "/" << getAssociatedFunction
()->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);

  AliveSuccessors.clear();

  bool UsedAssumedInformation = false;
  switch (I->getOpcode()) {
  // TODO: look for (assumed) UB to backwards propagate "deadness".
  default:
    if (I->isTerminator()) {
      for (const BasicBlock *SuccBB : successors(I->getParent()))
        AliveSuccessors.push_back(&SuccBB->front());
    } else {
      AliveSuccessors.push_back(I->getNextNode());
    }
    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 {
    Change = ChangeStatus::CHANGED;
    if (AliveSuccessors.empty() ||
        (I->isTerminator() && AliveSuccessors.size() < I->getNumSuccessors()))
      KnownDeadEnds.insert(I);
  }

  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 &&((AliveSuccessors.size() == 1 && "Non-terminator expected to have a single successor!"
) ? static_cast<void> (0) : __assert_fail ("AliveSuccessors.size() == 1 && \"Non-terminator expected to have a single successor!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3541, __PRETTY_FUNCTION__))
             "Non-terminator expected to have a single successor!")((AliveSuccessors.size() == 1 && "Non-terminator expected to have a single successor!"
) ? static_cast<void> (0) : __assert_fail ("AliveSuccessors.size() == 1 && \"Non-terminator expected to have a single successor!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3541, __PRETTY_FUNCTION__));
      Worklist.push_back(AliveSuccessor);
    } else {
      if (assumeLive(A, *AliveSuccessor->getParent()))
        Worklist.push_back(AliveSuccessor);
    }
  }
}

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() &&
    getAssociatedFunction()->size() == AssumedLiveBlocks.size() &&
    llvm::all_of(KnownDeadEnds, [](const Instruction *DeadEndI) {
      return DeadEndI->isTerminator() && DeadEndI->getNumSuccessors() == 0;
    }))
  return indicatePessimisticFixpoint();
return Change;
3565}

3567/// Liveness information for a call sites.
3568struct AAIsDeadCallSite final : AAIsDeadFunction {
AAIsDeadCallSite(const IRPosition &IRP) : AAIsDeadFunction(IRP) {}

/// 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!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3578)
                   "supported for call sites yet!")::llvm::llvm_unreachable_internal("Abstract attributes for liveness are not "
 "supported for call sites yet!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 3578);
}

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

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

3590/// -------------------- Dereferenceable Argument Attribute --------------------

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

3601struct AADereferenceableImpl : AADereferenceable {
AADereferenceableImpl(const IRPosition &IRP) : AADereferenceable(IRP) {}
using StateType = DerefState;

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

  NonNullAA = &A.getAAFor<AANonNull>(*this, getIRPosition(),
                                     /* TrackDependence */ false);

  const IRPosition &IRP = this->getIRPosition();
  bool IsFnInterface = IRP.isFnInterfaceKind();
  const Function *FnScope = IRP.getAnchorScope();
  if (IsFnInterface && (!FnScope || !FnScope->hasExactDefinition()))
    indicatePessimisticFixpoint();
}

/// 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;

  Type *PtrTy = UseV->getType();
  const DataLayout &DL = A.getDataLayout();
  int64_t Offset;
  if (const Value *Base = getBasePointerOfAccessPointerOperand(
          I, Offset, DL, /*AllowNonInbounds*/ true)) {
    if (Base == &getAssociatedValue() &&
        getPointerOperand(I, /* AllowVolatile */ false) == UseV) {
      uint64_t Size = DL.getTypeStoreSize(PtrTy->getPointerElementType());
      State.addAccessedBytes(Offset, Size);
    }
  }
  return;
}

/// See AAFromMustBeExecutedContext
bool followUse(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);

  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()) + ">";
}
3693};

3695/// Dereferenceable attribute for a floating value.
3696struct AADereferenceableFloating
  : AAFromMustBeExecutedContext<AADereferenceable, AADereferenceableImpl> {
using Base =
    AAFromMustBeExecutedContext<AADereferenceable, AADereferenceableImpl>;
AADereferenceableFloating(const IRPosition &IRP) : Base(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  ChangeStatus Change = Base::updateImpl(A);

  const DataLayout &DL = A.getDataLayout();

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

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

    // TODO: Use `AAConstantRange` to infer dereferenceable bytes.

    // 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;
  if (!genericValueTraversal<AADereferenceable, DerefState>(
          A, getIRPosition(), *this, T, VisitValueCB))
    return indicatePessimisticFixpoint();

  return Change | 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);
 }
}
3773};

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

/// 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); }
}
3786};

3788/// Dereferenceable attribute for an argument
3789struct AADereferenceableArgument final
  : AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<
        AADereferenceable, AADereferenceableImpl> {
using Base = AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<
    AADereferenceable, AADereferenceableImpl>;
AADereferenceableArgument(const IRPosition &IRP) : Base(IRP) {}

/// 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
); }
}
3800};

3802/// Dereferenceable attribute for a call site argument.
3803struct AADereferenceableCallSiteArgument final : AADereferenceableFloating {
AADereferenceableCallSiteArgument(const IRPosition &IRP)
    : AADereferenceableFloating(IRP) {}

/// 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); }
}
3811};

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

/// 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); };
}
3825};

3827// ------------------------ Align Argument Attribute ------------------------

3829static unsigned int getKnownAlignForUse(Attributor &A,
                                      AbstractAttribute &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;
  }
}

unsigned Alignment = 0;
if (ImmutableCallSite ICS = ImmutableCallSite(I)) {
  if (ICS.isBundleOperand(U) || ICS.isCallee(U))
    return 0;

  unsigned ArgNo = ICS.getArgumentNo(U);
  IRPosition IRP = IRPosition::callsite_argument(ICS, ArgNo);
  // As long as we only use known information there is no need to track
  // dependences here.
  auto &AlignAA = A.getAAFor<AAAlign>(QueryingAA, IRP,
                                      /* TrackDependence */ false);
  Alignment = AlignAA.getKnownAlign();
}

const Value *UseV = U->get();
if (auto *SI = dyn_cast<StoreInst>(I)) {
  if (SI->getPointerOperand() == UseV)
    Alignment = SI->getAlignment();
} else if (auto *LI = dyn_cast<LoadInst>(I))
  Alignment = LI->getAlignment();

if (Alignment <= 1)
  return 0;

auto &DL = A.getDataLayout();
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;
3887}
3888struct AAAlignImpl : AAAlign {
AAAlignImpl(const IRPosition &IRP) : AAAlign(IRP) {}

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

  if (getIRPosition().isFnInterfaceKind() &&
      (!getAssociatedFunction() ||
       !getAssociatedFunction()->hasExactDefinition()))
    indicatePessimisticFixpoint();
}

/// 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);

  MaybeAlign InheritAlign =
      getAssociatedValue().getPointerAlignment(A.getDataLayout());
  if (InheritAlign.valueOrOne() >= 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 AAFromMustBeExecutedContext
bool followUse(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";
}
3969};

3971/// Align attribute for a floating value.
3972struct AAAlignFloating : AAFromMustBeExecutedContext<AAAlign, AAAlignImpl> {
using Base = AAFromMustBeExecutedContext<AAAlign, AAAlignImpl>;
AAAlignFloating(const IRPosition &IRP) : Base(IRP) {}

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

  const DataLayout &DL = A.getDataLayout();

  auto VisitValueCB = [&](Value &V, AAAlign::StateType &T,
                          bool Stripped) -> bool {
    const auto &AA = A.getAAFor<AAAlign>(*this, IRPosition::value(V));
    if (!Stripped && this == &AA) {
      // Use only IR information if we did not strip anything.
      const MaybeAlign PA = V.getPointerAlignment(DL);
      T.takeKnownMaximum(PA ? PA->value() : 0);
      T.indicatePessimisticFixpoint();
    } else {
      // Use abstract attribute information.
      const AAAlign::StateType &DS =
          static_cast<const AAAlign::StateType &>(AA.getState());
      T ^= DS;
    }
    return T.isValidState();
  };

  StateType T;
  if (!genericValueTraversal<AAAlign, StateType>(A, getIRPosition(), *this, T,
                                                 VisitValueCB))
    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); } }
4011};

4013/// Align attribute for function return value.
4014struct AAAlignReturned final
  : AAReturnedFromReturnedValues<AAAlign, AAAlignImpl> {
AAAlignReturned(const IRPosition &IRP)
    : AAReturnedFromReturnedValues<AAAlign, AAAlignImpl>(IRP) {}

/// 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
); } }
4021};

4023/// Align attribute for function argument.
4024struct AAAlignArgument final
  : AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<AAAlign,
                                                            AAAlignImpl> {
AAAlignArgument(const IRPosition &IRP)
    : AAArgumentFromCallSiteArgumentsAndMustBeExecutedContext<AAAlign,
                                                              AAAlignImpl>(
          IRP) {}

/// 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); } }
4034};

4036struct AAAlignCallSiteArgument final : AAAlignFloating {
AAAlignCallSiteArgument(const IRPosition &IRP) : AAAlignFloating(IRP) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  ChangeStatus Changed = AAAlignImpl::manifest(A);
  MaybeAlign InheritAlign =
      getAssociatedValue().getPointerAlignment(A.getDataLayout());
  if (InheritAlign.valueOrOne() >= 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), /* TrackDependence */ false);
    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); } }
4064};

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

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  Base::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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
); }; }
4085};

4087/// ------------------ Function No-Return Attribute ----------------------------
4088struct AANoReturnImpl : public AANoReturn {
AANoReturnImpl(const IRPosition &IRP) : AANoReturn(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AANoReturn::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F)
    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; };
  if (!A.checkForAllInstructions(CheckForNoReturn, *this,
                                 {(unsigned)Instruction::Ret}))
    return indicatePessimisticFixpoint();
  return ChangeStatus::UNCHANGED;
}
4112};

4114struct AANoReturnFunction final : AANoReturnImpl {
AANoReturnFunction(const IRPosition &IRP) : AANoReturnImpl(IRP) {}

/// 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); } }
4119};

4121/// NoReturn attribute deduction for a call sites.
4122struct AANoReturnCallSite final : AANoReturnImpl {
AANoReturnCallSite(const IRPosition &IRP) : AANoReturnImpl(IRP) {}

/// 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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AANoReturn::StateType &>(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); }; }
4141};

4143/// ----------------------- Variable Capturing ---------------------------------

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

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

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

  const Function *F = getArgNo() >= 0 ? 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 (getArgNo() >= 0) {
    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.getArgNo();
  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";
}
4251};

4253/// Attributor-aware capture tracker.
4254struct 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,
                    SmallVectorImpl<const Value *> &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), /* TrackDependence */ true,
      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);
  }

  // Explicitly catch return instructions.
  if (isa<ReturnInst>(UInst))
    return isCapturedIn(/* Memory */ false, /* Integer */ false,
                        /* 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.
  CallSite CS(UInst);
  if (!CS || !CS.isArgOperand(U))
    return isCapturedIn(/* Memory */ true, /* Integer */ true,
                        /* Return */ true);

  unsigned ArgNo = CS.getArgumentNo(U);
  const IRPosition &CSArgPos = IRPosition::callsite_argument(CS, 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);
  if (ArgNoCaptureAA.isAssumedNoCapture())
    return isCapturedIn(/* Memory */ false, /* Integer */ false,
                        /* Return */ false);
  if (ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
    addPotentialCopy(CS);
    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(CallSite CS) {
  PotentialCopies.push_back(CS.getInstruction());
}

/// See CaptureTracker::shouldExplore(...).
bool shouldExplore(const Use *U) override {
  // Check liveness.
  return !A.isAssumedDead(*U, &NoCaptureAA, &IsDeadAA);
}

/// 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);
}

4379private:
/// 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.
SmallVectorImpl<const Value *> &PotentialCopies;

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

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

const Function *F =
    getArgNo() >= 0 ? IRP.getAssociatedFunction() : IRP.getAnchorScope();
assert(F && "Expected a function!")((F && "Expected a function!") ? static_cast<void>
 (0) : __assert_fail ("F && \"Expected a function!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4408, __PRETTY_FUNCTION__));
const IRPosition &FnPos = IRPosition::function(*F);
const auto &IsDeadAA =
    A.getAAFor<AAIsDead>(*this, FnPos, /* TrackDependence */ false);

AANoCapture::StateType T;

// Readonly means we cannot capture through memory.
const auto &FnMemAA = A.getAAFor<AAMemoryBehavior>(
    *this, FnPos, /* TrackDependence */ true, DepClassTy::OPTIONAL);
if (FnMemAA.isAssumedReadOnly()) {
  T.addKnownBits(NOT_CAPTURED_IN_MEM);
  if (FnMemAA.isKnownReadOnly())
    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, /* TrackDependence */ true, DepClassTy::OPTIONAL);
if (NoUnwindAA.isAssumedNoUnwind()) {
  bool IsVoidTy = F->getReturnType()->isVoidTy();
  const AAReturnedValues *RVAA =
      IsVoidTy ? nullptr
               : &A.getAAFor<AAReturnedValues>(*this, FnPos,
                                               /* TrackDependence */ true,
                                               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.
SmallVector<const Value *, 4> PotentialCopies;
unsigned RemainingUsesToExplore = DefaultMaxUsesToExplore;
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.push_back(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;
4486}

4488/// NoCapture attribute for function arguments.
4489struct AANoCaptureArgument final : AANoCaptureImpl {
AANoCaptureArgument(const IRPosition &IRP) : AANoCaptureImpl(IRP) {}

/// 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); } }
4494};

4496/// NoCapture attribute for call site arguments.
4497struct AANoCaptureCallSiteArgument final : AANoCaptureImpl {
AANoCaptureCallSiteArgument(const IRPosition &IRP) : AANoCaptureImpl(IRP) {}

/// 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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AANoCapture::StateType &>(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
); }};
4526};

4528/// NoCapture attribute for floating values.
4529struct AANoCaptureFloating final : AANoCaptureImpl {
AANoCaptureFloating(const IRPosition &IRP) : AANoCaptureImpl(IRP) {}

/// 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); }
}
4536};

4538/// NoCapture attribute for function return value.
4539struct AANoCaptureReturned final : AANoCaptureImpl {
AANoCaptureReturned(const IRPosition &IRP) : AANoCaptureImpl(IRP) {
  llvm_unreachable("NoCapture is not applicable to function returns!")::llvm::llvm_unreachable_internal("NoCapture is not applicable to function returns!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4541);
}

/// 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!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4546);
}

/// 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!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4551);
}

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

4558/// NoCapture attribute deduction for a call site return value.
4559struct AANoCaptureCallSiteReturned final : AANoCaptureImpl {
AANoCaptureCallSiteReturned(const IRPosition &IRP) : AANoCaptureImpl(IRP) {}

/// 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);
 }
}
4566};

4568/// ------------------ Value Simplify Attribute ----------------------------
4569struct AAValueSimplifyImpl : AAValueSimplify {
AAValueSimplifyImpl(const IRPosition &IRP) : AAValueSimplify(IRP) {}

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

/// See AbstractAttribute::getAsStr().
const std::string getAsStr() const override {
  return getAssumed() ? (getKnown() ? "simplified" : "maybe-simple")
                      : "not-simple";
}

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

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

/// Helper function for querying AAValueSimplify and updating candicate.
/// \param QueryingValue Value trying to unify with SimplifiedValue
/// \param AccumulatedSimplifiedValue Current simplification result.
static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                           Value &QueryingValue,
                           Optional<Value *> &AccumulatedSimplifiedValue) {
  // FIXME: Add a typecast support.

  auto &ValueSimplifyAA = A.getAAFor<AAValueSimplify>(
      QueryingAA, IRPosition::value(QueryingValue));

  Optional<Value *> QueryingValueSimplified =
      ValueSimplifyAA.getAssumedSimplifiedValue(A);

  if (!QueryingValueSimplified.hasValue())
    return true;

  if (!QueryingValueSimplified.getValue())
    return false;

  Value &QueryingValueSimplifiedUnwrapped =
      *QueryingValueSimplified.getValue();

  if (AccumulatedSimplifiedValue.hasValue() &&
      !isa<UndefValue>(AccumulatedSimplifiedValue.getValue()) &&
      !isa<UndefValue>(QueryingValueSimplifiedUnwrapped))
    return AccumulatedSimplifiedValue == QueryingValueSimplified;
  if (AccumulatedSimplifiedValue.hasValue() &&
      isa<UndefValue>(QueryingValueSimplifiedUnwrapped))
    return true;

  LLVM_DEBUG(dbgs() << "[ValueSimplify] " << QueryingValuedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 QueryingValue << " is assumed to be " << QueryingValueSimplifiedUnwrapped
 << "\n"; } } while (false)
                    << " is assumed to be "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 QueryingValue << " is assumed to be " << QueryingValueSimplifiedUnwrapped
 << "\n"; } } while (false)
                    << QueryingValueSimplifiedUnwrapped << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 QueryingValue << " is assumed to be " << QueryingValueSimplifiedUnwrapped
 << "\n"; } } while (false);

  AccumulatedSimplifiedValue = QueryingValueSimplified;
  return true;
}

bool askSimplifiedValueForAAValueConstantRange(Attributor &A) {
  if (!getAssociatedValue().getType()->isIntegerTy())
    return false;

  const auto &ValueConstantRangeAA =
      A.getAAFor<AAValueConstantRange>(*this, getIRPosition());

  Optional<ConstantInt *> COpt =
      ValueConstantRangeAA.getAssumedConstantInt(A);
  if (COpt.hasValue()) {
    if (auto *C = COpt.getValue())
      SimplifiedAssociatedValue = C;
    else
      return false;
  } else {
    SimplifiedAssociatedValue = llvm::None;
  }
  return true;
}

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

  if (SimplifiedAssociatedValue.hasValue() &&
      !SimplifiedAssociatedValue.getValue())
    return Changed;

  Value &V = getAssociatedValue();
  auto *C = SimplifiedAssociatedValue.hasValue()
                ? dyn_cast<Constant>(SimplifiedAssociatedValue.getValue())
                : UndefValue::get(V.getType());
  if (C) {
    // We can replace the AssociatedValue with the constant.
    if (!V.user_empty() && &V != C && V.getType() == C->getType()) {
      LLVM_DEBUG(dbgs() << "[ValueSimplify] " << V << " -> " << *Cdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 V << " -> " << *C << " :: " << *this
 << "\n"; } } while (false)
                        << " :: " << *this << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 V << " -> " << *C << " :: " << *this
 << "\n"; } } while (false);
      if (A.changeValueAfterManifest(V, *C))
        Changed = ChangeStatus::CHANGED;
    }
  }

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

/// See AbstractState::indicatePessimisticFixpoint(...).
ChangeStatus indicatePessimisticFixpoint() override {
  // NOTE: Associated value will be returned in a pessimistic fixpoint and is
  // regarded as known. That's why`indicateOptimisticFixpoint` is called.
  SimplifiedAssociatedValue = &getAssociatedValue();
  indicateOptimisticFixpoint();
  return ChangeStatus::CHANGED;
}

4687protected:
// An assumed simplified value. Initially, it is set to Optional::None, which
// means that the value is not clear under current assumption. If in the
// pessimistic state, getAssumedSimplifiedValue doesn't return this value but
// returns orignal associated value.
Optional<Value *> SimplifiedAssociatedValue;
4693};

4695struct AAValueSimplifyArgument final : AAValueSimplifyImpl {
AAValueSimplifyArgument(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}

void initialize(Attributor &A) override {
  AAValueSimplifyImpl::initialize(A);
  if (!getAssociatedFunction() || getAssociatedFunction()->isDeclaration())
    indicatePessimisticFixpoint();
  if (hasAttr({Attribute::InAlloca, Attribute::StructRet, Attribute::Nest},
              /* 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.
    const auto &MemAA = A.getAAFor<AAMemoryBehavior>(*this, getIRPosition());
    if (!MemAA.isAssumedReadOnly())
      return indicatePessimisticFixpoint();
  }

  bool HasValueBefore = SimplifiedAssociatedValue.hasValue();

  auto PredForCallSite = [&](AbstractCallSite ACS) {
    const IRPosition &ACSArgPos =
        IRPosition::callsite_argument(ACS, getArgNo());
    // 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;

    // We can only propagate thread independent values through callbacks.
    // This is different to direct/indirect call sites because for them we
    // know the thread executing the caller and callee is the same. For
    // callbacks this is not guaranteed, thus a thread dependent value could
    // be different for the caller and callee, making it invalid to propagate.
    Value &ArgOp = ACSArgPos.getAssociatedValue();
    if (ACS.isCallbackCall())
      if (auto *C = dyn_cast<Constant>(&ArgOp))
        if (C->isThreadDependent())
          return false;
    return checkAndUpdate(A, *this, ArgOp, SimplifiedAssociatedValue);
  };

  bool AllCallSitesKnown;
  if (!A.checkForAllCallSites(PredForCallSite, *this, true,
                              AllCallSitesKnown))
    if (!askSimplifiedValueForAAValueConstantRange(A))
      return indicatePessimisticFixpoint();

  // If a candicate was found in this update, return CHANGED.
  return HasValueBefore == SimplifiedAssociatedValue.hasValue()
             ? 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); }
}
4768};

4770struct AAValueSimplifyReturned : AAValueSimplifyImpl {
AAValueSimplifyReturned(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  bool HasValueBefore = SimplifiedAssociatedValue.hasValue();

  auto PredForReturned = [&](Value &V) {
    return checkAndUpdate(A, *this, V, SimplifiedAssociatedValue);
  };

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

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

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

  if (SimplifiedAssociatedValue.hasValue() &&
      !SimplifiedAssociatedValue.getValue())
    return Changed;

  Value &V = getAssociatedValue();
  auto *C = SimplifiedAssociatedValue.hasValue()
                ? dyn_cast<Constant>(SimplifiedAssociatedValue.getValue())
                : UndefValue::get(V.getType());
  if (C) {
    auto PredForReturned =
        [&](Value &V, const SmallSetVector<ReturnInst *, 4> &RetInsts) {
          // We can replace the AssociatedValue with the constant.
          if (&V == C || V.getType() != C->getType() || isa<UndefValue>(V))
            return true;
          if (auto *CI = dyn_cast<CallInst>(&V))
            if (CI->isMustTailCall())
              return true;

          for (ReturnInst *RI : RetInsts) {
            if (RI->getFunction() != getAnchorScope())
              continue;
            LLVM_DEBUG(dbgs() << "[ValueSimplify] " << V << " -> " << *Cdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 V << " -> " << *C << " in " << *RI
 << " :: " << *this << "\n"; } } while (false
)
                              << " in " << *RI << " :: " << *this << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[ValueSimplify] " <<
 V << " -> " << *C << " in " << *RI
 << " :: " << *this << "\n"; } } while (false
);
            if (A.changeUseAfterManifest(RI->getOperandUse(0), *C))
              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
); }
}
4832};

4834struct AAValueSimplifyFloating : AAValueSimplifyImpl {
AAValueSimplifyFloating(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  // FIXME: This might have exposed a SCC iterator update bug in the old PM.
  //        Needs investigation.
  // AAValueSimplifyImpl::initialize(A);
  Value &V = getAnchorValue();

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

/// See AbstractAttribute::updateImpl(...).
ChangeStatus updateImpl(Attributor &A) override {
  bool HasValueBefore = SimplifiedAssociatedValue.hasValue();

  auto VisitValueCB = [&](Value &V, bool &, bool Stripped) -> bool {
    auto &AA = A.getAAFor<AAValueSimplify>(*this, IRPosition::value(V));
    if (!Stripped && this == &AA) {
      // 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, V, SimplifiedAssociatedValue);
  };

  bool Dummy = false;
  if (!genericValueTraversal<AAValueSimplify, bool>(A, getIRPosition(), *this,
                                                    Dummy, VisitValueCB))
    if (!askSimplifiedValueForAAValueConstantRange(A))
      return indicatePessimisticFixpoint();

  // If a candicate was found in this update, return CHANGED.

  return HasValueBefore == SimplifiedAssociatedValue.hasValue()
             ? 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); }
}
4882};

4884struct AAValueSimplifyFunction : AAValueSimplifyImpl {
AAValueSimplifyFunction(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  SimplifiedAssociatedValue = &getAnchorValue();
  indicateOptimisticFixpoint();
}
/// See AbstractAttribute::initialize(...).
ChangeStatus updateImpl(Attributor &A) override {
  llvm_unreachable(::llvm::llvm_unreachable_internal("AAValueSimplify(Function|CallSite)::updateImpl will not be called"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4895)
      "AAValueSimplify(Function|CallSite)::updateImpl will not be called")::llvm::llvm_unreachable_internal("AAValueSimplify(Function|CallSite)::updateImpl will not be called"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4895);
}
/// 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); }
}
4901};

4903struct AAValueSimplifyCallSite : AAValueSimplifyFunction {
AAValueSimplifyCallSite(const IRPosition &IRP)
    : AAValueSimplifyFunction(IRP) {}
/// 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); }
}
4910};

4912struct AAValueSimplifyCallSiteReturned : AAValueSimplifyReturned {
AAValueSimplifyCallSiteReturned(const IRPosition &IRP)
    : AAValueSimplifyReturned(IRP) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  if (auto *CI = dyn_cast<CallInst>(&getAssociatedValue()))
    if (CI->isMustTailCall())
      return ChangeStatus::UNCHANGED;
  return AAValueSimplifyImpl::manifest(A);
}

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
); }
}
4927};
4928struct AAValueSimplifyCallSiteArgument : AAValueSimplifyFloating {
AAValueSimplifyCallSiteArgument(const IRPosition &IRP)
    : AAValueSimplifyFloating(IRP) {}

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
); }
}
4935};

4937/// ----------------------- Heap-To-Stack Conversion ---------------------------
4938struct AAHeapToStackImpl : public AAHeapToStack {
AAHeapToStackImpl(const IRPosition &IRP) : AAHeapToStack(IRP) {}

const std::string getAsStr() const override {
  return "[H2S] Mallocs: " + std::to_string(MallocCalls.size());
}

ChangeStatus manifest(Attributor &A) override {
  assert(getState().isValidState() &&((getState().isValidState() && "Attempted to manifest an invalid state!"
) ? static_cast<void> (0) : __assert_fail ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4947, __PRETTY_FUNCTION__))
1
Assuming the condition is true→
2
←
'?' condition is true→
         "Attempted to manifest an invalid state!")((getState().isValidState() && "Attempted to manifest an invalid state!"
) ? static_cast<void> (0) : __assert_fail ("getState().isValidState() && \"Attempted to manifest an invalid state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 4947, __PRETTY_FUNCTION__));

  ChangeStatus HasChanged = ChangeStatus::UNCHANGED;
  Function *F = getAssociatedFunction();
  const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);

  for (Instruction *MallocCall : MallocCalls) {
3
←
Assuming '__begin2' is not equal to '__end2'→
    // This malloc cannot be replaced.
    if (BadMallocCalls.count(MallocCall))
4
←
Assuming the condition is false→
5
←
Taking false branch→
      continue;

    for (Instruction *FreeCall : FreesForMalloc[MallocCall]) {
      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 call: " << *MallocCalldo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "H2S: Removing malloc call: "
 << *MallocCall << "\n"; } } while (false)
6
←
Assuming 'DebugFlag' is false→
7
←
Loop condition is false.  Exiting loop→
                      << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "H2S: Removing malloc call: "
 << *MallocCall << "\n"; } } while (false);

    Constant *Size;
    if (isCallocLikeFn(MallocCall, TLI)) {
8
←
Assuming the condition is true→
9
←
Taking true branch→
      auto *Num = cast<ConstantInt>(MallocCall->getOperand(0));
10
←
The object is a 'ConstantInt'→
      auto *SizeT = dyn_cast<ConstantInt>(MallocCall->getOperand(1));
11
←
Assuming the object is not a 'ConstantInt'→
12
←
'SizeT' initialized to a null pointer value→
      APInt TotalSize = SizeT->getValue() * Num->getValue();
13
←
Called C++ object pointer is null
      Size =
          ConstantInt::get(MallocCall->getOperand(0)->getType(), TotalSize);
    } else {
      Size = cast<ConstantInt>(MallocCall->getOperand(0));
    }

    unsigned AS = cast<PointerType>(MallocCall->getType())->getAddressSpace();
    Instruction *AI = new AllocaInst(Type::getInt8Ty(F->getContext()), AS,
                                     Size, "", MallocCall->getNextNode());

    if (AI->getType() != MallocCall->getType())
      AI = new BitCastInst(AI, MallocCall->getType(), "malloc_bc",
                           AI->getNextNode());

    A.changeValueAfterManifest(*MallocCall, *AI);

    if (auto *II = dyn_cast<InvokeInst>(MallocCall)) {
      auto *NBB = II->getNormalDest();
      BranchInst::Create(NBB, MallocCall->getParent());
      A.deleteAfterManifest(*MallocCall);
    } else {
      A.deleteAfterManifest(*MallocCall);
    }

    if (isCallocLikeFn(MallocCall, TLI)) {
      auto *BI = new BitCastInst(AI, MallocCall->getType(), "calloc_bc",
                                 AI->getNextNode());
      Value *Ops[] = {
          BI, ConstantInt::get(F->getContext(), APInt(8, 0, false)), Size,
          ConstantInt::get(Type::getInt1Ty(F->getContext()), false)};

      Type *Tys[] = {BI->getType(), MallocCall->getOperand(0)->getType()};
      Module *M = F->getParent();
      Function *Fn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
      CallInst::Create(Fn, Ops, "", BI->getNextNode());
    }
    HasChanged = ChangeStatus::CHANGED;
  }

  return HasChanged;
}

/// Collection of all malloc calls in a function.
SmallSetVector<Instruction *, 4> MallocCalls;

/// Collection of malloc calls that cannot be converted.
DenseSet<const Instruction *> BadMallocCalls;

/// A map for each malloc call to the set of associated free calls.
DenseMap<Instruction *, SmallPtrSet<Instruction *, 4>> FreesForMalloc;

ChangeStatus updateImpl(Attributor &A) override;
5024};

5026ChangeStatus AAHeapToStackImpl::updateImpl(Attributor &A) {
const Function *F = getAssociatedFunction();
const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);

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

auto FreeCheck = [&](Instruction &I) {
  const auto &Frees = FreesForMalloc.lookup(&I);
  if (Frees.size() != 1)
    return false;
  Instruction *UniqueFree = *Frees.begin();
  return Explorer.findInContextOf(UniqueFree, I.getNextNode());
};

auto UsesCheck = [&](Instruction &I) {
  bool ValidUsesOnly = true;
  bool MustUse = 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;
      // Record malloc.
      if (isFreeCall(UserI, TLI)) {
        if (MustUse) {
          FreesForMalloc[&I].insert(UserI);
        } else {
          LLVM_DEBUG(dbgs() << "[H2S] free potentially on different mallocs: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] free potentially on different mallocs: "
 << *UserI << "\n"; } } while (false)
                            << *UserI << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[H2S] free potentially on different mallocs: "
 << *UserI << "\n"; } } while (false);
          ValidUsesOnly = false;
        }
        return true;
      }

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

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

      // If a callsite argument use is nofree, we are fine.
      const auto &ArgNoFreeAA = A.getAAFor<AANoFree>(
          *this, IRPosition::callsite_argument(*CB, ArgNo));

      if (!NoCaptureAA.isAssumedNoCapture() ||
          !ArgNoFreeAA.isAssumedNoFree()) {
        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)) {
      MustUse &= !(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;
  };
  A.checkForAllUses(Pred, *this, I);
  return ValidUsesOnly;
};

auto MallocCallocCheck = [&](Instruction &I) {
  if (BadMallocCalls.count(&I))
    return true;

  bool IsMalloc = isMallocLikeFn(&I, TLI);
  bool IsCalloc = !IsMalloc && isCallocLikeFn(&I, TLI);
  if (!IsMalloc && !IsCalloc) {
    BadMallocCalls.insert(&I);
    return true;
  }

  if (IsMalloc) {
    if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(0)))
      if (Size->getValue().ule(MaxHeapToStackSize))
        if (UsesCheck(I) || FreeCheck(I)) {
          MallocCalls.insert(&I);
          return true;
        }
  } else if (IsCalloc) {
    bool Overflow = false;
    if (auto *Num = dyn_cast<ConstantInt>(I.getOperand(0)))
      if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(1)))
        if ((Size->getValue().umul_ov(Num->getValue(), Overflow))
                .ule(MaxHeapToStackSize))
          if (!Overflow && (UsesCheck(I) || FreeCheck(I))) {
            MallocCalls.insert(&I);
            return true;
          }
  }

  BadMallocCalls.insert(&I);
  return true;
};

size_t NumBadMallocs = BadMallocCalls.size();

A.checkForAllCallLikeInstructions(MallocCallocCheck, *this);

if (NumBadMallocs != BadMallocCalls.size())
  return ChangeStatus::CHANGED;

return ChangeStatus::UNCHANGED;
5148}

5150struct AAHeapToStackFunction final : public AAHeapToStackImpl {
AAHeapToStackFunction(const IRPosition &IRP) : AAHeapToStackImpl(IRP) {}

/// See AbstractAttribute::trackStatistics()
void trackStatistics() const override {
  STATS_DECL(MallocCalls, Function,static llvm::Statistic NumIRFunction_MallocCalls = {"attributor"
, "NumIRFunction_MallocCalls", "Number of malloc calls converted to allocas"
};;
             "Number of malloc calls converted to allocas")static llvm::Statistic NumIRFunction_MallocCalls = {"attributor"
, "NumIRFunction_MallocCalls", "Number of malloc calls converted to allocas"
};;;
  for (auto *C : MallocCalls)
    if (!BadMallocCalls.count(C))
      ++BUILD_STAT_NAME(MallocCalls, Function)NumIRFunction_MallocCalls;
}
5161};

5163/// ----------------------- Privatizable Pointers ------------------------------
5164struct AAPrivatizablePtrImpl : public AAPrivatizablePtr {
AAPrivatizablePtrImpl(const IRPosition &IRP)
    : AAPrivatizablePtr(IRP), 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]";
}

5198protected:
Optional<Type *> PrivatizableType;
5200};

5202// TODO: Do this for call site arguments (probably also other values) as well.

5204struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl {
AAPrivatizablePtrArgument(const IRPosition &IRP)
    : AAPrivatizablePtrImpl(IRP) {}

/// 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 AllCallSitesKnown;
  if (getIRPosition().hasAttr(Attribute::ByVal) &&
      A.checkForAllCallSites([](AbstractCallSite ACS) { return true; }, *this,
                             true, AllCallSitesKnown))
    return getAssociatedValue().getType()->getPointerElementType();

  Optional<Type *> Ty;
  unsigned ArgNo = getIRPosition().getArgNo();

  // 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);
    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, AllCallSitesKnown))
    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();

  // 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();
  }

  // Verify callee and caller agree on how the promoted argument would be
  // passed.
  // TODO: The use of the ArgumentPromotion interface here is ugly, we need a
  // specialized form of TargetTransformInfo::areFunctionArgsABICompatible
  // which doesn't require the arguments ArgumentPromotion wanted to pass.
  Function &Fn = *getIRPosition().getAnchorScope();
  SmallPtrSet<Argument *, 1> ArgsToPromote, Dummy;
  ArgsToPromote.insert(getAssociatedArgument());
  const auto *TTI =
      A.getInfoCache().getAnalysisResultForFunction<TargetIRAnalysis>(Fn);
  if (!TTI ||
      !ArgumentPromotionPass::areFunctionArgsABICompatible(
          Fn, *TTI, ArgsToPromote, Dummy) ||
      ArgsToPromote.empty()) {
    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();
  }

  // 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.
  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 = [&](CallSite CS) {
    SmallVector<const Use *, 4> CBUses;
    AbstractCallSite::getCallbackUses(CS, CBUses);
    for (const Use *U : CBUses) {
      AbstractCallSite CBACS(U);
      assert(CBACS && CBACS.isCallbackCall())((CBACS && CBACS.isCallbackCall()) ? static_cast<void
> (0) : __assert_fail ("CBACS && CBACS.isCallbackCall()"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5326, __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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.getArgOperand(ArgNo) << "\n" <<
 "[AAPrivatizablePtr] " << CBArg << " : " <<
 CBACS.getCallArgOperandNo(CBArg) << " vs " << ArgNo
 << "\n"; }; } } while (false)
              << CS.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 " << CS.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 " << CS.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 " << CS.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 " << CS.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));
        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->getNumArgOperands() &&((DCArgNo >= 0 && unsigned(DCArgNo) < DC->getNumArgOperands
() && "Expected a direct call operand for callback call operand"
) ? static_cast<void> (0) : __assert_fail ("DCArgNo >= 0 && unsigned(DCArgNo) < DC->getNumArgOperands() && \"Expected a direct call operand for callback call operand\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5379, __PRETTY_FUNCTION__))
           "Expected a direct call operand for callback call operand")((DCArgNo >= 0 && unsigned(DCArgNo) < DC->getNumArgOperands
() && "Expected a direct call operand for callback call operand"
) ? static_cast<void> (0) : __assert_fail ("DCArgNo >= 0 && unsigned(DCArgNo) < DC->getNumArgOperands() && \"Expected a direct call operand for callback call operand\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5379, __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)));
      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.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite().getCalledFunction
()->getName() << ").\n[AAPrivatizablePtr] for which the argument "
 "privatization is not compatible.\n"; }; } } while (false)
             << ACS.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite().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.getCallSite());
    if (ACS.isCallbackCall())
      return IsCompatiblePrivArgOfDirectCS(ACS);
    return false;
  };

  bool AllCallSitesKnown;
  if (!A.checkForAllCallSites(IsCompatiblePrivArgOfOtherCallSite, *this, true,
                              AllCallSitesKnown))
    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!")((PrivType && "Expected privatizable type!") ? static_cast
<void> (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5443, __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!")((PrivType && "Expected privatizable type!") ? static_cast
<void> (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5462, __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, &Base, PrivStructLayout->getElementOffset(u), IRB, DL);
      new StoreInst(F.getArg(ArgNo + u), Ptr, &IP);
    }
  } else if (auto *PrivArrayType = dyn_cast<ArrayType>(PrivType)) {
    Type *PointeePtrTy = PrivArrayType->getElementType()->getPointerTo();
    uint64_t PointeeTySize = DL.getTypeStoreSize(PointeePtrTy);
    for (unsigned u = 0, e = PrivArrayType->getNumElements(); u < e; u++) {
      Value *Ptr =
          constructPointer(PointeePtrTy, &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(Type *PrivType, AbstractCallSite ACS,
                             Value *Base,
                             SmallVectorImpl<Value *> &ReplacementValues) {
  assert(Base && "Expected base value!")((Base && "Expected base value!") ? static_cast<void
> (0) : __assert_fail ("Base && \"Expected base value!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5494, __PRETTY_FUNCTION__));
  assert(PrivType && "Expected privatizable type!")((PrivType && "Expected privatizable type!") ? static_cast
<void> (0) : __assert_fail ("PrivType && \"Expected privatizable type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5495, __PRETTY_FUNCTION__));
  Instruction *IP = ACS.getInstruction();

  IRBuilder<NoFolder> IRB(IP);
  const DataLayout &DL = IP->getModule()->getDataLayout();

  if (Base->getType()->getPointerElementType() != PrivType)
    Base = BitCastInst::CreateBitOrPointerCast(Base, PrivType->getPointerTo(),
                                               "", ACS.getInstruction());

  // TODO: Improve the alignment of the loads.
  // 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(), Base,
                           PrivStructLayout->getElementOffset(u), IRB, DL);
      LoadInst *L = new LoadInst(PointeeTy, Ptr, "", IP);
      L->setAlignment(MaybeAlign(1));
      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, Base, u * PointeeTySize, IRB, DL);
      LoadInst *L = new LoadInst(PointeePtrTy, Ptr, "", IP);
      L->setAlignment(MaybeAlign(1));
      ReplacementValues.push_back(L);
    }
  } else {
    LoadInst *L = new LoadInst(PrivType, Base, "", IP);
    L->setAlignment(MaybeAlign(1));
    ReplacementValues.push_back(L);
  }
}

/// See AbstractAttribute::manifest(...)
ChangeStatus manifest(Attributor &A) override {
  if (!PrivatizableType.hasValue())
    return ChangeStatus::UNCHANGED;
  assert(PrivatizableType.getValue() && "Expected privatizable type!")((PrivatizableType.getValue() && "Expected privatizable type!"
) ? static_cast<void> (0) : __assert_fail ("PrivatizableType.getValue() && \"Expected privatizable type!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5540, __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;
  if (!A.checkForAllInstructions(
          [&](Instruction &I) {
            CallInst &CI = cast<CallInst>(I);
            if (CI.isTailCall())
              TailCalls.push_back(&CI);
            return true;
          },
          *this, {Instruction::Call}))
    return ChangeStatus::UNCHANGED;

  Argument *Arg = getAssociatedArgument();

  // 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();
        auto *AI = new AllocaInst(PrivatizableType.getValue(), 0,
                                  Arg->getName() + ".priv", IP);
        createInitialization(PrivatizableType.getValue(), *AI, ReplacementFn,
                             ArgIt->getArgNo(), *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 =
      [=](const Attributor::ArgumentReplacementInfo &ARI,
          AbstractCallSite ACS, SmallVectorImpl<Value *> &NewArgOperands) {
        createReplacementValues(
            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
); };
}
5605};

5607struct AAPrivatizablePtrFloating : public AAPrivatizablePtrImpl {
AAPrivatizablePtrFloating(const IRPosition &IRP)
    : AAPrivatizablePtrImpl(IRP) {}

/// 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", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5619)
                   "updateImpl will not be called")::llvm::llvm_unreachable_internal("AAPrivatizablePtr(Floating|Returned|CallSiteReturned)::"
 "updateImpl will not be called", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5619);
}

/// See AAPrivatizablePtrImpl::identifyPrivatizableType(...)
Optional<Type *> identifyPrivatizableType(Attributor &A) override {
  Value *Obj =
      GetUnderlyingObject(&getAssociatedValue(), A.getInfoCache().getDL());
  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 Obj->getType()->getPointerElementType();
  if (auto *Arg = dyn_cast<Argument>(Obj)) {
    auto &PrivArgAA =
        A.getAAFor<AAPrivatizablePtr>(*this, IRPosition::argument(*Arg));
    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
); };
}
5652};

5654struct AAPrivatizablePtrCallSiteArgument final
  : public AAPrivatizablePtrFloating {
AAPrivatizablePtrCallSiteArgument(const IRPosition &IRP)
    : AAPrivatizablePtrFloating(IRP) {}

/// 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);
  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);
  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();
  }

  const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(*this, IRP);
  if (!MemBehaviorAA.isAssumedReadOnly()) {
    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); };
}
5699};

5701struct AAPrivatizablePtrCallSiteReturned final
  : public AAPrivatizablePtrFloating {
AAPrivatizablePtrCallSiteReturned(const IRPosition &IRP)
    : AAPrivatizablePtrFloating(IRP) {}

/// 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
); };
}
5716};

5718struct AAPrivatizablePtrReturned final : public AAPrivatizablePtrFloating {
AAPrivatizablePtrReturned(const IRPosition &IRP)
    : AAPrivatizablePtrFloating(IRP) {}

/// 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); };
}
5732};

5734/// -------------------- Memory Behavior Attributes ----------------------------
5735/// Includes read-none, read-only, and write-only.
5736/// ----------------------------------------------------------------------------
5737struct AAMemoryBehaviorImpl : public AAMemoryBehavior {
AAMemoryBehaviorImpl(const IRPosition &IRP) : AAMemoryBehavior(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  intersectAssumedBits(BEST_STATE);
  getKnownStateFromValue(getIRPosition(), getState());
  IRAttribute::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!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5765);
    }
  }

  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)((Attrs.size() == 0) ? static_cast<void> (0) : __assert_fail
 ("Attrs.size() == 0", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5780, __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)((Attrs.size() <= 1) ? static_cast<void> (0) : __assert_fail
 ("Attrs.size() <= 1", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 5787, __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];
5826};

5828const Attribute::AttrKind AAMemoryBehaviorImpl::AttrKinds[] = {
  Attribute::ReadNone, Attribute::ReadOnly, Attribute::WriteOnly};

5831/// Memory behavior attribute for a floating value.
5832struct AAMemoryBehaviorFloating : AAMemoryBehaviorImpl {
AAMemoryBehaviorFloating(const IRPosition &IRP) : AAMemoryBehaviorImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryBehaviorImpl::initialize(A);
  // Initialize the use vector with all direct uses of the associated value.
  for (const Use &U : getAssociatedValue().uses())
    Uses.insert(&U);
}

/// 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); }
}

5856private:
/// 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);

5865protected:
/// Container for (transitive) uses of the associated argument.
SetVector<const Use *> Uses;
5868};

5870/// Memory behavior attribute for function argument.
5871struct AAMemoryBehaviorArgument : AAMemoryBehaviorFloating {
AAMemoryBehaviorArgument(const IRPosition &IRP)
    : AAMemoryBehaviorFloating(IRP) {}

/// 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 || !Arg->getParent()->hasExactDefinition()) {
    indicatePessimisticFixpoint();
  } else {
    // Initialize the use vector with all direct uses of the associated value.
    for (const Use &U : Arg->uses())
      Uses.insert(&U);
  }
}

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})) {
    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); }
}
5921};

5923struct AAMemoryBehaviorCallSiteArgument final : AAMemoryBehaviorArgument {
AAMemoryBehaviorCallSiteArgument(const IRPosition &IRP)
    : AAMemoryBehaviorArgument(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  if (Argument *Arg = getAssociatedArgument()) {
    if (Arg->hasByValAttr()) {
      addKnownBits(NO_WRITES);
      removeKnownBits(NO_READS);
      removeAssumedBits(NO_READS);
    }
  } else {
  }
  AAMemoryBehaviorArgument::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 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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AAMemoryBehavior::StateType &>(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
); }
}
5963};

5965/// Memory behavior attribute for a call site return position.
5966struct AAMemoryBehaviorCallSiteReturned final : AAMemoryBehaviorFloating {
AAMemoryBehaviorCallSiteReturned(const IRPosition &IRP)
    : AAMemoryBehaviorFloating(IRP) {}

/// See AbstractAttribute::manifest(...).
ChangeStatus manifest(Attributor &A) override {
  // We do not annotate returned values.
  return ChangeStatus::UNCHANGED;
}

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

5980/// An AA to represent the memory behavior function attributes.
5981struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
AAMemoryBehaviorFunction(const IRPosition &IRP) : AAMemoryBehaviorImpl(IRP) {}

/// 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); }
}
6007};

6009/// AAMemoryBehavior attribute for call sites.
6010struct AAMemoryBehaviorCallSite final : AAMemoryBehaviorImpl {
AAMemoryBehaviorCallSite(const IRPosition &IRP) : AAMemoryBehaviorImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryBehaviorImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || !F->hasExactDefinition())
    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);
  return clampStateAndIndicateChange(
      getState(),
      static_cast<const AAMemoryBehavior::StateType &>(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); }
}
6044};

6046ChangeStatus 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 (ImmutableCallSite ICS = ImmutableCallSite(&I)) {
    const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
        *this, IRPosition::callsite_function(ICS));
    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();
};

if (!A.checkForAllReadWriteInstructions(CheckRWInst, *this))
  return indicatePessimisticFixpoint();

return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
                                      : ChangeStatus::UNCHANGED;
6075}

6077ChangeStatus 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, /* TrackDependence */ true, DepClassTy::OPTIONAL);
  FnMemAssumedState = FnMemAA.getAssumed();
  S.addKnownBits(FnMemAA.getKnown());
  if ((S.getAssumed() & FnMemAA.getAssumed()) == S.getAssumed())
    return ChangeStatus::UNCHANGED;
}

// 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, /* TrackDependence */ true, DepClassTy::OPTIONAL);
if (!ArgNoCaptureAA.isAssumedNoCaptureMaybeReturned()) {
  S.intersectAssumedBits(FnMemAssumedState);
  return ChangeStatus::CHANGED;
}

// The current assumed state used to determine a change.
auto AssumedState = S.getAssumed();

// Liveness information to exclude dead users.
// TODO: Take the FnPos once we have call site specific liveness information.
const auto &LivenessAA = A.getAAFor<AAIsDead>(
    *this, IRPosition::function(*IRP.getAssociatedFunction()),
    /* TrackDependence */ false);

// Visit and expand uses until all are analyzed or a fixpoint is reached.
for (unsigned i = 0; i < Uses.size() && !isAtFixpoint(); i++) {
  const Use *U = Uses[i];
  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 << " [Dead: " <<
 (A.isAssumedDead(*U, this, &LivenessAA)) << "]\n";
 } } while (false)
                    << " [Dead: " << (A.isAssumedDead(*U, this, &LivenessAA))do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryBehavior] Use: " <<
 **U << " in " << *UserI << " [Dead: " <<
 (A.isAssumedDead(*U, this, &LivenessAA)) << "]\n";
 } } while (false)
                    << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryBehavior] Use: " <<
 **U << " in " << *UserI << " [Dead: " <<
 (A.isAssumedDead(*U, this, &LivenessAA)) << "]\n";
 } } while (false);
  if (A.isAssumedDead(*U, this, &LivenessAA))
    continue;

  // Check if the users of UserI should also be visited.
  if (followUsersOfUseIn(A, U, UserI))
    for (const Use &UserIUse : UserI->uses())
      Uses.insert(&UserIUse);

  // If UserI might touch memory we analyze the use in detail.
  if (UserI->mayReadOrWriteMemory())
    analyzeUseIn(A, U, UserI);
}

return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
                                      : ChangeStatus::UNCHANGED;
6140}

6142bool 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.
ImmutableCallSite ICS(UserI);
if (!ICS || !ICS.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 = ICS.getArgumentNo(U);
  const auto &ArgNoCaptureAA = A.getAAFor<AANoCapture>(
      *this, IRPosition::callsite_argument(ICS, ArgNo),
      /* TrackDependence */ true, DepClassTy::OPTIONAL);
  return !ArgNoCaptureAA.isAssumedNoCapture();
}

return true;
6170}

6172void AAMemoryBehaviorFloating::analyzeUseIn(Attributor &A, const Use *U,
                                          const Instruction *UserI) {
assert(UserI->mayReadOrWriteMemory())((UserI->mayReadOrWriteMemory()) ? static_cast<void>
 (0) : __assert_fail ("UserI->mayReadOrWriteMemory()", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6174, __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 we do assume that capturing was taken care of
  // somewhere else.
  if (cast<StoreInst>(UserI)->getPointerOperand() == U->get())
    removeAssumedBits(NO_WRITES);
  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.
  ImmutableCallSite ICS(UserI);

  // Give up on operand bundles.
  if (ICS.isBundleOperand(U)) {
    indicatePessimisticFixpoint();
    return;
  }

  // Calling a function does read the function pointer, maybe write it if the
  // function is self-modifying.
  if (ICS.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(ICS, ICS.getArgumentNo(U));
  else
    Pos = IRPosition::callsite_function(ICS);
  const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
      *this, Pos,
      /* TrackDependence */ true, 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);
6236}

6238} // namespace

6240/// -------------------- Memory Locations Attributes ---------------------------
6241/// Includes read-none, argmemonly, inaccessiblememonly,
6242/// inaccessiblememorargmemonly
6243/// ----------------------------------------------------------------------------

6245std::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;
6270}

6272namespace {

6274struct AAMemoryLocationImpl : public AAMemoryLocation {

AAMemoryLocationImpl(const IRPosition &IRP) : AAMemoryLocation(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  intersectAssumedBits(BEST_STATE);
  getKnownStateFromValue(getIRPosition(), getState());
  IRAttribute::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_LOCAL_MEM | NO_CONST_MEM);
      break;
    case Attribute::InaccessibleMemOnly:
      State.addKnownBits(inverseLocation(NO_INACCESSIBLE_MEM, true, true));
      break;
    case Attribute::ArgMemOnly:
      State.addKnownBits(inverseLocation(NO_ARGUMENT_MEM, true, true));
      break;
    case Attribute::InaccessibleMemOrArgMemOnly:
      State.addKnownBits(
          inverseLocation(NO_INACCESSIBLE_MEM | NO_ARGUMENT_MEM, true, true));
      break;
    default:
      llvm_unreachable("Unexpected attribute!")::llvm::llvm_unreachable_internal("Unexpected attribute!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6307);
    }
  }
}

/// See AbstractAttribute::getDeducedAttributes(...).
void getDeducedAttributes(LLVMContext &Ctx,
                          SmallVectorImpl<Attribute> &Attrs) const override {
  assert(Attrs.size() == 0)((Attrs.size() == 0) ? static_cast<void> (0) : __assert_fail
 ("Attrs.size() == 0", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6315, __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)((Attrs.size() <= 1) ? static_cast<void> (0) : __assert_fail
 ("Attrs.size() <= 1", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6327, __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(
    const 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;

  for (MemoryLocationsKind CurMLK = 1; CurMLK < NO_LOCATIONS; CurMLK *= 2) {
    if (CurMLK & RequestedMLK)
      continue;

    const auto &Accesses = AccessKindAccessesMap.lookup(CurMLK);
    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(), AccessKindAccessesMap, CurMLK, I,
                                nullptr, Changed);
  return AAMemoryLocation::indicatePessimisticFixpoint();
}

6393protected:
/// 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 AccessKindAccessesMapTy =
    DenseMap<unsigned, SmallSet<AccessInfo, 8, AccessInfo>>;
AccessKindAccessesMapTy AccessKindAccessesMap;

/// Return the kind(s) of location that may be accessed by \p V.
AAMemoryLocation::MemoryLocationsKind
categorizeAccessedLocations(Attributor &A, Instruction &I, bool &Changed);

/// Update the state \p State and the AccessKindAccessesMap given that \p I is
/// an access to a \p MLK memory location with the access pointer \p Ptr.
static void updateStateAndAccessesMap(AAMemoryLocation::StateType &State,
                                      AccessKindAccessesMapTy &AccessMap,
                                      MemoryLocationsKind MLK,
                                      const Instruction *I, const Value *Ptr,
                                      bool &Changed) {
  // TODO: The kind should be determined at the call sites based on the
  // information we have there.
  AccessKind Kind = READ_WRITE;
  if (I) {
    Kind = I->mayReadFromMemory() ? READ : NONE;
    Kind = AccessKind(Kind | (I->mayWriteToMemory() ? WRITE : NONE));
  }

  assert(isPowerOf2_32(MLK) && "Expected a single location set!")((isPowerOf2_32(MLK) && "Expected a single location set!"
) ? static_cast<void> (0) : __assert_fail ("isPowerOf2_32(MLK) && \"Expected a single location set!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6446, __PRETTY_FUNCTION__));
  Changed |= AccessMap[MLK].insert(AccessInfo{I, Ptr, Kind}).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);

/// The set of IR attributes AAMemoryLocation deals with.
static const Attribute::AttrKind AttrKinds[4];
6458};

6460const Attribute::AttrKind AAMemoryLocationImpl::AttrKinds[] = {
  Attribute::ReadNone, Attribute::InaccessibleMemOnly, Attribute::ArgMemOnly,
  Attribute::InaccessibleMemOrArgMemOnly};

6464void 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);

auto StripGEPCB = [](Value *V) -> Value * {
  auto *GEP = dyn_cast<GEPOperator>(V);
  while (GEP) {
    V = GEP->getPointerOperand();
    GEP = dyn_cast<GEPOperator>(V);
  }
  return V;
};

auto VisitValueCB = [&](Value &V, AAMemoryLocation::StateType &T,
                        bool Stripped) -> bool {
  assert(!isa<GEPOperator>(V) && "GEPs should have been stripped.")((!isa<GEPOperator>(V) && "GEPs should have been stripped."
) ? static_cast<void> (0) : __assert_fail ("!isa<GEPOperator>(V) && \"GEPs should have been stripped.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6482, __PRETTY_FUNCTION__));
  if (isa<UndefValue>(V))
    return true;
  if (auto *Arg = dyn_cast<Argument>(&V)) {
    if (Arg->hasByValAttr())
      updateStateAndAccessesMap(T, AccessKindAccessesMap, NO_LOCAL_MEM, &I,
                                &V, Changed);
    else
      updateStateAndAccessesMap(T, AccessKindAccessesMap, NO_ARGUMENT_MEM, &I,
                                &V, Changed);
    return true;
  }
  if (auto *GV = dyn_cast<GlobalValue>(&V)) {
    if (GV->hasLocalLinkage())
      updateStateAndAccessesMap(T, AccessKindAccessesMap,
                                NO_GLOBAL_INTERNAL_MEM, &I, &V, Changed);
    else
      updateStateAndAccessesMap(T, AccessKindAccessesMap,
                                NO_GLOBAL_EXTERNAL_MEM, &I, &V, Changed);
    return true;
  }
  if (isa<AllocaInst>(V)) {
    updateStateAndAccessesMap(T, AccessKindAccessesMap, NO_LOCAL_MEM, &I, &V,
                              Changed);
    return true;
  }
  if (ImmutableCallSite ICS = ImmutableCallSite(&V)) {
    const auto &NoAliasAA =
        A.getAAFor<AANoAlias>(*this, IRPosition::callsite_returned(ICS));
    if (NoAliasAA.isAssumedNoAlias()) {
      updateStateAndAccessesMap(T, AccessKindAccessesMap, NO_MALLOCED_MEM, &I,
                                &V, Changed);
      return true;
    }
  }

  updateStateAndAccessesMap(T, AccessKindAccessesMap, NO_UNKOWN_MEM, &I, &V,
                            Changed);
  LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Ptr value cannot be categorized: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value cannot be categorized: "
 << V << " -> " << getMemoryLocationsAsStr
(T.getAssumed()) << "\n"; } } while (false)
                    << V << " -> " << getMemoryLocationsAsStr(T.getAssumed())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value cannot be categorized: "
 << V << " -> " << getMemoryLocationsAsStr
(T.getAssumed()) << "\n"; } } while (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Ptr value cannot be categorized: "
 << V << " -> " << getMemoryLocationsAsStr
(T.getAssumed()) << "\n"; } } while (false);
  return true;
};

if (!genericValueTraversal<AAMemoryLocation, AAMemoryLocation::StateType>(
        A, IRPosition::value(Ptr), *this, State, VisitValueCB,
        /* MaxValues */ 32, StripGEPCB)) {
  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, AccessKindAccessesMap, NO_UNKOWN_MEM, &I,
                            nullptr, Changed);
} else {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "
 << getMemoryLocationsAsStr(State.getAssumed()) <<
 "\n"; } } while (false)
      dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Accessed locations with pointer locations: "
 << getMemoryLocationsAsStr(State.getAssumed()) <<
 "\n"; } } while (false)
      << "[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);
}
6539}

6541AAMemoryLocation::MemoryLocationsKind
6542AAMemoryLocationImpl::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 (ImmutableCallSite ICS = ImmutableCallSite(&I)) {

  // First check if we assume any memory is access is visible.
  const auto &ICSMemLocationAA =
      A.getAAFor<AAMemoryLocation>(*this, IRPosition::callsite_function(ICS));
  LLVM_DEBUG(dbgs() << "[AAMemoryLocation] Categorize call site: " << Ido { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize call site: "
 << I << " [" << ICSMemLocationAA << "]\n"
; } } while (false)
                    << " [" << ICSMemLocationAA << "]\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[AAMemoryLocation] Categorize call site: "
 << I << " [" << ICSMemLocationAA << "]\n"
; } } while (false);

  if (ICSMemLocationAA.isAssumedReadNone())
    return NO_LOCATIONS;

  if (ICSMemLocationAA.isAssumedInaccessibleMemOnly()) {
    updateStateAndAccessesMap(AccessedLocs, AccessKindAccessesMap,
                              NO_INACCESSIBLE_MEM, &I, nullptr, Changed);
    return AccessedLocs.getAssumed();
  }

  uint32_t ICSAssumedNotAccessedLocs =
      ICSMemLocationAA.getAssumedNotAccessedLocation();

  // Set the argmemonly and global bit as we handle them separately below.
  uint32_t ICSAssumedNotAccessedLocsNoArgMem =
      ICSAssumedNotAccessedLocs | NO_ARGUMENT_MEM | NO_GLOBAL_MEM;

  for (MemoryLocationsKind CurMLK = 1; CurMLK < NO_LOCATIONS; CurMLK *= 2) {
    if (ICSAssumedNotAccessedLocsNoArgMem & CurMLK)
      continue;
    updateStateAndAccessesMap(AccessedLocs, AccessKindAccessesMap, CurMLK, &I,
                              nullptr, Changed);
  }

  // Now handle global memory if it might be accessed.
  bool HasGlobalAccesses = !(ICSAssumedNotAccessedLocs & NO_GLOBAL_MEM);
  if (HasGlobalAccesses) {
    auto AccessPred = [&](const Instruction *, const Value *Ptr,
                          AccessKind Kind, MemoryLocationsKind MLK) {
      updateStateAndAccessesMap(AccessedLocs, AccessKindAccessesMap, MLK, &I,
                                Ptr, Changed);
      return true;
    };
    if (!ICSMemLocationAA.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 = !(ICSAssumedNotAccessedLocs & NO_ARGUMENT_MEM);
  if (HasArgAccesses) {
    for (unsigned ArgNo = 0, e = ICS.getNumArgOperands(); ArgNo < e;
         ++ArgNo) {

      // Skip non-pointer arguments.
      const Value *ArgOp = ICS.getArgOperand(ArgNo);
      if (!ArgOp->getType()->isPtrOrPtrVectorTy())
        continue;

      // Skip readnone arguments.
      const IRPosition &ArgOpIRP = IRPosition::callsite_argument(ICS, ArgNo);
      const auto &ArgOpMemLocationAA = A.getAAFor<AAMemoryBehavior>(
          *this, ArgOpIRP, /* TrackDependence */ true, DepClassTy::OPTIONAL);

      if (ArgOpMemLocationAA.isAssumedReadNone())
        continue;

      // Categorize potentially accessed pointer arguments as if there was an
      // access instruction with them as pointer.
      categorizePtrValue(A, I, *ArgOp, 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, AccessKindAccessesMap, NO_UNKOWN_MEM,
                          &I, nullptr, Changed);
return AccessedLocs.getAssumed();
6644}

6646/// An AA to represent the memory behavior function attributes.
6647struct AAMemoryLocationFunction final : public AAMemoryLocationImpl {
AAMemoryLocationFunction(const IRPosition &IRP) : AAMemoryLocationImpl(IRP) {}

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

  const auto &MemBehaviorAA = A.getAAFor<AAMemoryBehavior>(
      *this, getIRPosition(), /* TrackDependence */ false);
  if (MemBehaviorAA.isAssumedReadNone()) {
    if (MemBehaviorAA.isKnownReadNone())
      return indicateOptimisticFixpoint();
    assert(isAssumedReadNone() &&((isAssumedReadNone() && "AAMemoryLocation was not read-none but AAMemoryBehavior was!"
) ? static_cast<void> (0) : __assert_fail ("isAssumedReadNone() && \"AAMemoryLocation was not read-none but AAMemoryBehavior was!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6659, __PRETTY_FUNCTION__))
           "AAMemoryLocation was not read-none but AAMemoryBehavior was!")((isAssumedReadNone() && "AAMemoryLocation was not read-none but AAMemoryBehavior was!"
) ? static_cast<void> (0) : __assert_fail ("isAssumedReadNone() && \"AAMemoryLocation was not read-none but AAMemoryBehavior was!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6659, __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));
    return true;
  };

  if (!A.checkForAllReadWriteInstructions(CheckRWInst, *this))
    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); }
}
6694};

6696/// AAMemoryLocation attribute for call sites.
6697struct AAMemoryLocationCallSite final : AAMemoryLocationImpl {
AAMemoryLocationCallSite(const IRPosition &IRP) : AAMemoryLocationImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAMemoryLocationImpl::initialize(A);
  Function *F = getAssociatedFunction();
  if (!F || !F->hasExactDefinition())
    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);
  bool Changed = false;
  auto AccessPred = [&](const Instruction *I, const Value *Ptr,
                        AccessKind Kind, MemoryLocationsKind MLK) {
    updateStateAndAccessesMap(getState(), AccessKindAccessesMap, MLK, I, Ptr,
                              Changed);
    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); }
}
6734};

6736/// ------------------ Value Constant Range Attribute -------------------------

6738struct AAValueConstantRangeImpl : AAValueConstantRange {
using StateType = IntegerRangeState;
AAValueConstantRangeImpl(const IRPosition &IRP) : AAValueConstantRange(IRP) {}

/// 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<BasicBlock *>(CtxI->getParent()),
                               const_cast<Instruction *>(CtxI));
}

/// See AAValueConstantRange::getKnownConstantRange(..).
ConstantRange
getKnownConstantRange(Attributor &A,
                      const Instruction *CtxI = nullptr) const override {
  if (!CtxI || CtxI == getCtxI())
    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 (!CtxI || CtxI == getCtxI())
    return getAssumed();

  ConstantRange LVIR = getConstantRangeFromLVI(A, CtxI);
  ConstantRange SCEVR = getConstantRangeFromSCEV(A, CtxI);
  return getAssumed().intersectWith(SCEVR).intersectWith(LVIR);
}

/// See AbstractAttribute::initialize(..).
void initialize(Attributor &A) override {
  // Intersect a range given by SCEV.
  intersectKnown(getConstantRangeFromSCEV(A, getCtxI()));

  // Intersect a range given by LVI.
  intersectKnown(getConstantRangeFromLVI(A, getCtxI()));
}

/// 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")((!AssumedConstantRange.isFullSet() && "Invalid state"
) ? static_cast<void> (0) : __assert_fail ("!AssumedConstantRange.isFullSet() && \"Invalid state\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 6909, __PRETTY_FUNCTION__));

  auto &V = getAssociatedValue();
  if (!AssumedConstantRange.isEmptySet() &&
      !AssumedConstantRange.isSingleElement()) {
    if (Instruction *I = dyn_cast<Instruction>(&V))
      if (isa<CallInst>(I) || isa<LoadInst>(I))
        if (setRangeMetadataIfisBetterRange(I, AssumedConstantRange))
          Changed = ChangeStatus::CHANGED;
  }

  return Changed;
}
6922};

6924struct AAValueConstantRangeArgument final
  : AAArgumentFromCallSiteArguments<
        AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState> {
AAValueConstantRangeArgument(const IRPosition &IRP)
    : AAArgumentFromCallSiteArguments<
          AAValueConstantRange, AAValueConstantRangeImpl, IntegerRangeState>(
          IRP) {}

/// 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); }
}
6936};

6938struct AAValueConstantRangeReturned
  : AAReturnedFromReturnedValues<AAValueConstantRange,
                                 AAValueConstantRangeImpl> {
using Base = AAReturnedFromReturnedValues<AAValueConstantRange,
                                          AAValueConstantRangeImpl>;
AAValueConstantRangeReturned(const IRPosition &IRP) : Base(IRP) {}

/// 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
); }
}
6952};

6954struct AAValueConstantRangeFloating : AAValueConstantRangeImpl {
AAValueConstantRangeFloating(const IRPosition &IRP)
    : AAValueConstantRangeImpl(IRP) {}

/// See AbstractAttribute::initialize(...).
void initialize(Attributor &A) override {
  AAValueConstantRangeImpl::initialize(A);
  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<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,
    Instruction *CtxI,
    SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  Value *LHS = BinOp->getOperand(0);
  Value *RHS = BinOp->getOperand(1);
  // TODO: Allow non integers as well.
  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return false;

  auto &LHSAA =
      A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*LHS));
  QuerriedAAs.push_back(&LHSAA);
  auto LHSAARange = LHSAA.getAssumedConstantRange(A, CtxI);

  auto &RHSAA =
      A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*RHS));
  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, Instruction *CtxI,
    SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  assert(CastI->getNumOperands() == 1 && "Expected cast to be unary!")((CastI->getNumOperands() == 1 && "Expected cast to be unary!"
) ? static_cast<void> (0) : __assert_fail ("CastI->getNumOperands() == 1 && \"Expected cast to be unary!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7029, __PRETTY_FUNCTION__));
  // TODO: Allow non integers as well.
  Value &OpV = *CastI->getOperand(0);
  if (!OpV.getType()->isIntegerTy())
    return false;

  auto &OpAA =
      A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(OpV));
  QuerriedAAs.push_back(&OpAA);
  T.unionAssumed(
      OpAA.getAssumed().castOp(CastI->getOpcode(), getState().getBitWidth()));
  return T.isValidState();
}

bool
calculateCmpInst(Attributor &A, CmpInst *CmpI, IntegerRangeState &T,
                 Instruction *CtxI,
                 SmallVectorImpl<const AAValueConstantRange *> &QuerriedAAs) {
  Value *LHS = CmpI->getOperand(0);
  Value *RHS = CmpI->getOperand(1);
  // TODO: Allow non integers as well.
  if (!LHS->getType()->isIntegerTy() || !RHS->getType()->isIntegerTy())
    return false;

  auto &LHSAA =
      A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*LHS));
  QuerriedAAs.push_back(&LHSAA);
  auto &RHSAA =
      A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(*RHS));
  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);

  auto SatisfyingRegion = ConstantRange::makeSatisfyingICmpRegion(
      CmpI->getPredicate(), RHSAARange);

  if (AllowedRegion.intersectWith(LHSAARange).isEmptySet())
    MustFalse = true;

  if (SatisfyingRegion.contains(LHSAARange))
    MustTrue = true;

  assert((!MustTrue || !MustFalse) &&(((!MustTrue || !MustFalse) && "Either MustTrue or MustFalse should be false!"
) ? static_cast<void> (0) : __assert_fail ("(!MustTrue || !MustFalse) && \"Either MustTrue or MustFalse should be false!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7082, __PRETTY_FUNCTION__))
         "Either MustTrue or MustFalse should be false!")(((!MustTrue || !MustFalse) && "Either MustTrue or MustFalse should be false!"
) ? static_cast<void> (0) : __assert_fail ("(!MustTrue || !MustFalse) && \"Either MustTrue or MustFalse should be false!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7082, __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 {
  Instruction *CtxI = getCtxI();
  auto VisitValueCB = [&](Value &V, IntegerRangeState &T,
                          bool Stripped) -> bool {
    Instruction *I = dyn_cast<Instruction>(&V);
    if (!I) {

      // If the value is not instruction, we query AA to Attributor.
      const auto &AA =
          A.getAAFor<AAValueConstantRange>(*this, IRPosition::value(V));

      // 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());

  if (!genericValueTraversal<AAValueConstantRange, IntegerRangeState>(
          A, getIRPosition(), *this, T, VisitValueCB))
    return indicatePessimisticFixpoint();

  return clampStateAndIndicateChange(getState(), T);
}

/// 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); }
}
7162};

7164struct AAValueConstantRangeFunction : AAValueConstantRangeImpl {
AAValueConstantRangeFunction(const IRPosition &IRP)
    : AAValueConstantRangeImpl(IRP) {}

/// 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", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7171)
                   "not be called")::llvm::llvm_unreachable_internal("AAValueConstantRange(Function|CallSite)::updateImpl will "
 "not be called", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7171);
}

/// 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); } }
7176};

7178struct AAValueConstantRangeCallSite : AAValueConstantRangeFunction {
AAValueConstantRangeCallSite(const IRPosition &IRP)
    : AAValueConstantRangeFunction(IRP) {}

/// 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); } }
7184};

7186struct AAValueConstantRangeCallSiteReturned
  : AACallSiteReturnedFromReturned<AAValueConstantRange,
                                   AAValueConstantRangeImpl> {
AAValueConstantRangeCallSiteReturned(const IRPosition &IRP)
    : AACallSiteReturnedFromReturned<AAValueConstantRange,
                                     AAValueConstantRangeImpl>(IRP) {}

/// 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
); }
}
7207};
7208struct AAValueConstantRangeCallSiteArgument : AAValueConstantRangeFloating {
AAValueConstantRangeCallSiteArgument(const IRPosition &IRP)
    : AAValueConstantRangeFloating(IRP) {}

/// 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
); }
}
7216};

7218} // namespace
7219/// ----------------------------------------------------------------------------
7220///                               Attributor
7221/// ----------------------------------------------------------------------------

7223bool Attributor::isAssumedDead(const AbstractAttribute &AA,
                             const AAIsDead *FnLivenessAA,
                             bool CheckBBLivenessOnly, DepClassTy DepClass) {
const IRPosition &IRP = AA.getIRPosition();
if (!Functions.count(IRP.getAnchorScope()))
  return false;
return isAssumedDead(IRP, &AA, FnLivenessAA, CheckBBLivenessOnly, DepClass);
7230}

7232bool Attributor::isAssumedDead(const Use &U,
                             const AbstractAttribute *QueryingAA,
                             const AAIsDead *FnLivenessAA,
                             bool CheckBBLivenessOnly, DepClassTy DepClass) {
Instruction *UserI = dyn_cast<Instruction>(U.getUser());
if (!UserI)
  return isAssumedDead(IRPosition::value(*U.get()), QueryingAA, FnLivenessAA,
                       CheckBBLivenessOnly, DepClass);

if (CallSite CS = CallSite(UserI)) {
  // For call site argument uses we can check if the argument is
  // unused/dead.
  if (CS.isArgOperand(&U)) {
    const IRPosition &CSArgPos =
        IRPosition::callsite_argument(CS, CS.getArgumentNo(&U));
    return isAssumedDead(CSArgPos, QueryingAA, FnLivenessAA,
                         CheckBBLivenessOnly, DepClass);
  }
} else if (ReturnInst *RI = dyn_cast<ReturnInst>(UserI)) {
  const IRPosition &RetPos = IRPosition::returned(*RI->getFunction());
  return isAssumedDead(RetPos, QueryingAA, FnLivenessAA, CheckBBLivenessOnly,
                       DepClass);
} else if (PHINode *PHI = dyn_cast<PHINode>(UserI)) {
  BasicBlock *IncomingBB = PHI->getIncomingBlock(U);
  return isAssumedDead(*IncomingBB->getTerminator(), QueryingAA, FnLivenessAA,
                       CheckBBLivenessOnly, DepClass);
}

return isAssumedDead(IRPosition::value(*UserI), QueryingAA, FnLivenessAA,
                     CheckBBLivenessOnly, DepClass);
7262}

7264bool Attributor::isAssumedDead(const Instruction &I,
                             const AbstractAttribute *QueryingAA,
                             const AAIsDead *FnLivenessAA,
                             bool CheckBBLivenessOnly, DepClassTy DepClass) {
if (!FnLivenessAA)
  FnLivenessAA = lookupAAFor<AAIsDead>(IRPosition::function(*I.getFunction()),
                                       QueryingAA,
                                       /* TrackDependence */ false);

// If we have a context instruction and a liveness AA we use it.
if (FnLivenessAA &&
    FnLivenessAA->getIRPosition().getAnchorScope() == I.getFunction() &&
    FnLivenessAA->isAssumedDead(&I)) {
  if (QueryingAA)
    recordDependence(*FnLivenessAA, *QueryingAA, DepClass);
  return true;
}

if (CheckBBLivenessOnly)
  return false;

const AAIsDead &IsDeadAA = getOrCreateAAFor<AAIsDead>(
    IRPosition::value(I), QueryingAA, /* TrackDependence */ false);
// Don't check liveness for AAIsDead.
if (QueryingAA == &IsDeadAA)
  return false;

if (IsDeadAA.isAssumedDead()) {
  if (QueryingAA)
    recordDependence(IsDeadAA, *QueryingAA, DepClass);
  return true;
}

return false;
7298}

7300bool Attributor::isAssumedDead(const IRPosition &IRP,
                             const AbstractAttribute *QueryingAA,
                             const AAIsDead *FnLivenessAA,
                             bool CheckBBLivenessOnly, DepClassTy DepClass) {
Instruction *CtxI = IRP.getCtxI();
if (CtxI &&
    isAssumedDead(*CtxI, QueryingAA, FnLivenessAA,
                  /* CheckBBLivenessOnly */ true,
                  CheckBBLivenessOnly ? DepClass : DepClassTy::OPTIONAL))
  return true;

if (CheckBBLivenessOnly)
  return false;

// If we haven't succeeded we query the specific liveness info for the IRP.
const AAIsDead *IsDeadAA;
if (IRP.getPositionKind() == IRPosition::IRP_CALL_SITE)
  IsDeadAA = &getOrCreateAAFor<AAIsDead>(
      IRPosition::callsite_returned(cast<CallBase>(IRP.getAssociatedValue())),
      QueryingAA, /* TrackDependence */ false);
else
  IsDeadAA = &getOrCreateAAFor<AAIsDead>(IRP, QueryingAA,
                                         /* TrackDependence */ false);
// Don't check liveness for AAIsDead.
if (QueryingAA == IsDeadAA)
  return false;

if (IsDeadAA->isAssumedDead()) {
  if (QueryingAA)
    recordDependence(*IsDeadAA, *QueryingAA, DepClass);
  return true;
}

return false;
7334}

7336bool Attributor::checkForAllUses(
  const function_ref<bool(const Use &, bool &)> &Pred,
  const AbstractAttribute &QueryingAA, const Value &V,
  DepClassTy LivenessDepClass) {

// Check the trivial case first as it catches void values.
if (V.use_empty())
  return true;

// If the value is replaced by another one, for now a constant, we do not have
// uses. Note that this requires users of `checkForAllUses` to not recurse but
// instead use the `follow` callback argument to look at transitive users,
// however, that should be clear from the presence of the argument.
bool UsedAssumedInformation = false;
Optional<Constant *> C =
    getAssumedConstant(*this, V, QueryingAA, UsedAssumedInformation);
if (C.hasValue() && C.getValue()) {
  LLVM_DEBUG(dbgs() << "[Attributor] Value is simplified, uses skipped: " << Vdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Value is simplified, uses skipped: "
 << V << " -> " << *C.getValue() <<
 "\n"; } } while (false)
                    << " -> " << *C.getValue() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Value is simplified, uses skipped: "
 << V << " -> " << *C.getValue() <<
 "\n"; } } while (false);
  return true;
}

const IRPosition &IRP = QueryingAA.getIRPosition();
SmallVector<const Use *, 16> Worklist;
SmallPtrSet<const Use *, 16> Visited;

for (const Use &U : V.uses())
  Worklist.push_back(&U);

LLVM_DEBUG(dbgs() << "[Attributor] Got " << Worklist.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Got " <<
 Worklist.size() << " initial uses to check\n"; } } while
 (false)
                  << " initial uses to check\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Got " <<
 Worklist.size() << " initial uses to check\n"; } } while
 (false);

const Function *ScopeFn = IRP.getAnchorScope();
const auto *LivenessAA =
    ScopeFn ? &getAAFor<AAIsDead>(QueryingAA, IRPosition::function(*ScopeFn),
                                  /* TrackDependence */ false)
            : nullptr;

while (!Worklist.empty()) {
  const Use *U = Worklist.pop_back_val();
  if (!Visited.insert(U).second)
    continue;
  LLVM_DEBUG(dbgs() << "[Attributor] Check use: " << **U << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Check use: " <<
 **U << " in " << *U->getUser() << "\n";
 } } while (false)
                    << *U->getUser() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Check use: " <<
 **U << " in " << *U->getUser() << "\n";
 } } while (false);
  if (isAssumedDead(*U, &QueryingAA, LivenessAA,
                    /* CheckBBLivenessOnly */ false, LivenessDepClass)) {
    LLVM_DEBUG(dbgs() << "[Attributor] Dead use, skip!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Dead use, skip!\n"
; } } while (false);
    continue;
  }

  bool Follow = false;
  if (!Pred(*U, Follow))
    return false;
  if (!Follow)
    continue;
  for (const Use &UU : U->getUser()->uses())
    Worklist.push_back(&UU);
}

return true;
7396}

7398bool Attributor::checkForAllCallSites(
  const function_ref<bool(AbstractCallSite)> &Pred,
  const AbstractAttribute &QueryingAA, bool RequireAllCallSites,
  bool &AllCallSitesKnown) {
// We can try to determine information from
// the call sites. However, this is only possible all call sites are known,
// hence the function has internal linkage.
const IRPosition &IRP = QueryingAA.getIRPosition();
const Function *AssociatedFunction = IRP.getAssociatedFunction();
if (!AssociatedFunction) {
  LLVM_DEBUG(dbgs() << "[Attributor] No function associated with " << IRPdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] No function associated with "
 << IRP << "\n"; } } while (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] No function associated with "
 << IRP << "\n"; } } while (false);
  AllCallSitesKnown = false;
  return false;
}

return checkForAllCallSites(Pred, *AssociatedFunction, RequireAllCallSites,
                            &QueryingAA, AllCallSitesKnown);
7416}

7418bool Attributor::checkForAllCallSites(
  const function_ref<bool(AbstractCallSite)> &Pred, const Function &Fn,
  bool RequireAllCallSites, const AbstractAttribute *QueryingAA,
  bool &AllCallSitesKnown) {
if (RequireAllCallSites && !Fn.hasLocalLinkage()) {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has no internal linkage, hence not all call sites are known\n"
; } } while (false)
      dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has no internal linkage, hence not all call sites are known\n"
; } } while (false)
      << "[Attributor] Function " << Fn.getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has no internal linkage, hence not all call sites are known\n"
; } } while (false)
      << " has no internal linkage, hence not all call sites are known\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has no internal linkage, hence not all call sites are known\n"
; } } while (false);
  AllCallSitesKnown = false;
  return false;
}

// If we do not require all call sites we might not see all.
AllCallSitesKnown = RequireAllCallSites;

SmallVector<const Use *, 8> Uses(make_pointer_range(Fn.uses()));
for (unsigned u = 0; u < Uses.size(); ++u) {
  const Use &U = *Uses[u];
  LLVM_DEBUG(dbgs() << "[Attributor] Check use: " << *U << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Check use: " <<
 *U << " in " << *U.getUser() << "\n"; } } while
 (false)
                    << *U.getUser() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Check use: " <<
 *U << " in " << *U.getUser() << "\n"; } } while
 (false);
  if (isAssumedDead(U, QueryingAA, nullptr, /* CheckBBLivenessOnly */ true)) {
    LLVM_DEBUG(dbgs() << "[Attributor] Dead use, skip!\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Dead use, skip!\n"
; } } while (false);
    continue;
  }
  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U.getUser())) {
    if (CE->isCast() && CE->getType()->isPointerTy() &&
        CE->getType()->getPointerElementType()->isFunctionTy()) {
      for (const Use &CEU : CE->uses())
        Uses.push_back(&CEU);
      continue;
    }
  }

  AbstractCallSite ACS(&U);
  if (!ACS) {
    LLVM_DEBUG(dbgs() << "[Attributor] Function " << Fn.getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has non call site use " << *U.
get() << " in " << *U.getUser() << "\n"; } }
 while (false)
                      << " has non call site use " << *U.get() << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has non call site use " << *U.
get() << " in " << *U.getUser() << "\n"; } }
 while (false)
                      << *U.getUser() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function " <<
 Fn.getName() << " has non call site use " << *U.
get() << " in " << *U.getUser() << "\n"; } }
 while (false);
    // BlockAddress users are allowed.
    if (isa<BlockAddress>(U.getUser()))
      continue;
    return false;
  }

  const Use *EffectiveUse =
      ACS.isCallbackCall() ? &ACS.getCalleeUseForCallback() : &U;
  if (!ACS.isCallee(EffectiveUse)) {
    if (!RequireAllCallSites)
      continue;
    LLVM_DEBUG(dbgs() << "[Attributor] User " << EffectiveUse->getUser()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] User " <<
 EffectiveUse->getUser() << " is an invalid use of "
 << Fn.getName() << "\n"; } } while (false)
                      << " is an invalid use of " << Fn.getName() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] User " <<
 EffectiveUse->getUser() << " is an invalid use of "
 << Fn.getName() << "\n"; } } while (false);
    return false;
  }

  // Make sure the arguments that can be matched between the call site and the
  // callee argee on their type. It is unlikely they do not and it doesn't
  // make sense for all attributes to know/care about this.
  assert(&Fn == ACS.getCalledFunction() && "Expected known callee")((&Fn == ACS.getCalledFunction() && "Expected known callee"
) ? static_cast<void> (0) : __assert_fail ("&Fn == ACS.getCalledFunction() && \"Expected known callee\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7476, __PRETTY_FUNCTION__));
  unsigned MinArgsParams =
      std::min(size_t(ACS.getNumArgOperands()), Fn.arg_size());
  for (unsigned u = 0; u < MinArgsParams; ++u) {
    Value *CSArgOp = ACS.getCallArgOperand(u);
    if (CSArgOp && Fn.getArg(u)->getType() != CSArgOp->getType()) {
      LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site / callee argument type mismatch ["
 << u << "@" << Fn.getName() << ": " <<
 *Fn.getArg(u)->getType() << " vs. " << *ACS.getCallArgOperand
(u)->getType() << "\n"; } } while (false)
          dbgs() << "[Attributor] Call site / callee argument type mismatch ["do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site / callee argument type mismatch ["
 << u << "@" << Fn.getName() << ": " <<
 *Fn.getArg(u)->getType() << " vs. " << *ACS.getCallArgOperand
(u)->getType() << "\n"; } } while (false)
                 << u << "@" << Fn.getName() << ": "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site / callee argument type mismatch ["
 << u << "@" << Fn.getName() << ": " <<
 *Fn.getArg(u)->getType() << " vs. " << *ACS.getCallArgOperand
(u)->getType() << "\n"; } } while (false)
                 << *Fn.getArg(u)->getType() << " vs. "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site / callee argument type mismatch ["
 << u << "@" << Fn.getName() << ": " <<
 *Fn.getArg(u)->getType() << " vs. " << *ACS.getCallArgOperand
(u)->getType() << "\n"; } } while (false)
                 << *ACS.getCallArgOperand(u)->getType() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site / callee argument type mismatch ["
 << u << "@" << Fn.getName() << ": " <<
 *Fn.getArg(u)->getType() << " vs. " << *ACS.getCallArgOperand
(u)->getType() << "\n"; } } while (false);
      return false;
    }
  }

  if (Pred(ACS))
    continue;

  LLVM_DEBUG(dbgs() << "[Attributor] Call site callback failed for "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site callback failed for "
 << *ACS.getInstruction() << "\n"; } } while (false
)
                    << *ACS.getInstruction() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Call site callback failed for "
 << *ACS.getInstruction() << "\n"; } } while (false
);
  return false;
}

return true;
7500}

7502bool Attributor::checkForAllReturnedValuesAndReturnInsts(
  const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>
      &Pred,
  const AbstractAttribute &QueryingAA) {

const IRPosition &IRP = QueryingAA.getIRPosition();
// Since we need to provide return instructions we have to have an exact
// definition.
const Function *AssociatedFunction = IRP.getAssociatedFunction();
if (!AssociatedFunction)
  return false;

// If this is a call site query we use the call site specific return values
// and liveness information.
// TODO: use the function scope once we have call site AAReturnedValues.
const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
if (!AARetVal.getState().isValidState())
  return false;

return AARetVal.checkForAllReturnedValuesAndReturnInsts(Pred);
7523}

7525bool Attributor::checkForAllReturnedValues(
  const function_ref<bool(Value &)> &Pred,
  const AbstractAttribute &QueryingAA) {

const IRPosition &IRP = QueryingAA.getIRPosition();
const Function *AssociatedFunction = IRP.getAssociatedFunction();
if (!AssociatedFunction)
  return false;

// TODO: use the function scope once we have call site AAReturnedValues.
const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
const auto &AARetVal = getAAFor<AAReturnedValues>(QueryingAA, QueryIRP);
if (!AARetVal.getState().isValidState())
  return false;

return AARetVal.checkForAllReturnedValuesAndReturnInsts(
    [&](Value &RV, const SmallSetVector<ReturnInst *, 4> &) {
      return Pred(RV);
    });
7544}

7546static bool checkForAllInstructionsImpl(
  Attributor *A, InformationCache::OpcodeInstMapTy &OpcodeInstMap,
  const function_ref<bool(Instruction &)> &Pred,
  const AbstractAttribute *QueryingAA, const AAIsDead *LivenessAA,
  const ArrayRef<unsigned> &Opcodes, bool CheckBBLivenessOnly = false) {
for (unsigned Opcode : Opcodes) {
  for (Instruction *I : OpcodeInstMap[Opcode]) {
    // Skip dead instructions.
    if (A && A->isAssumedDead(IRPosition::value(*I), QueryingAA, LivenessAA,
                              CheckBBLivenessOnly))
      continue;

    if (!Pred(*I))
      return false;
  }
}
return true;
7563}

7565bool Attributor::checkForAllInstructions(
  const llvm::function_ref<bool(Instruction &)> &Pred,
  const AbstractAttribute &QueryingAA, const ArrayRef<unsigned> &Opcodes,
  bool CheckBBLivenessOnly) {

const IRPosition &IRP = QueryingAA.getIRPosition();
// Since we need to provide instructions we have to have an exact definition.
const Function *AssociatedFunction = IRP.getAssociatedFunction();
if (!AssociatedFunction)
  return false;

// TODO: use the function scope once we have call site AAReturnedValues.
const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
const auto &LivenessAA =
    getAAFor<AAIsDead>(QueryingAA, QueryIRP, /* TrackDependence */ false);

auto &OpcodeInstMap =
    InfoCache.getOpcodeInstMapForFunction(*AssociatedFunction);
if (!checkForAllInstructionsImpl(this, OpcodeInstMap, Pred, &QueryingAA,
                                 &LivenessAA, Opcodes, CheckBBLivenessOnly))
  return false;

return true;
7588}

7590bool Attributor::checkForAllReadWriteInstructions(
  const llvm::function_ref<bool(Instruction &)> &Pred,
  AbstractAttribute &QueryingAA) {

const Function *AssociatedFunction =
    QueryingAA.getIRPosition().getAssociatedFunction();
if (!AssociatedFunction)
  return false;

// TODO: use the function scope once we have call site AAReturnedValues.
const IRPosition &QueryIRP = IRPosition::function(*AssociatedFunction);
const auto &LivenessAA =
    getAAFor<AAIsDead>(QueryingAA, QueryIRP, /* TrackDependence */ false);

for (Instruction *I :
     InfoCache.getReadOrWriteInstsForFunction(*AssociatedFunction)) {
  // Skip dead instructions.
  if (isAssumedDead(IRPosition::value(*I), &QueryingAA, &LivenessAA))
    continue;

  if (!Pred(*I))
    return false;
}

return true;
7615}

7617ChangeStatus Attributor::run() {
LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Identified and initialized "
 << AllAbstractAttributes.size() << " abstract attributes.\n"
; } } while (false)
                  << AllAbstractAttributes.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Identified and initialized "
 << AllAbstractAttributes.size() << " abstract attributes.\n"
; } } while (false)
                  << " abstract attributes.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Identified and initialized "
 << AllAbstractAttributes.size() << " abstract attributes.\n"
; } } while (false);

// Now that all abstract attributes are collected and initialized we start
// the abstract analysis.

unsigned IterationCounter = 1;

SmallVector<AbstractAttribute *, 64> ChangedAAs;
SetVector<AbstractAttribute *> Worklist, InvalidAAs;
Worklist.insert(AllAbstractAttributes.begin(), AllAbstractAttributes.end());

bool RecomputeDependences = false;

do {
  // Remember the size to determine new attributes.
  size_t NumAAs = AllAbstractAttributes.size();
  LLVM_DEBUG(dbgs() << "\n\n[Attributor] #Iteration: " << IterationCounterdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n\n[Attributor] #Iteration: "
 << IterationCounter << ", Worklist size: " <<
 Worklist.size() << "\n"; } } while (false)
                    << ", Worklist size: " << Worklist.size() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n\n[Attributor] #Iteration: "
 << IterationCounter << ", Worklist size: " <<
 Worklist.size() << "\n"; } } while (false);

  // For invalid AAs we can fix dependent AAs that have a required dependence,
  // thereby folding long dependence chains in a single step without the need
  // to run updates.
  for (unsigned u = 0; u < InvalidAAs.size(); ++u) {
    AbstractAttribute *InvalidAA = InvalidAAs[u];
    auto &QuerriedAAs = QueryMap[InvalidAA];
    LLVM_DEBUG(dbgs() << "[Attributor] InvalidAA: " << *InvalidAA << " has "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] InvalidAA: " <<
 *InvalidAA << " has " << QuerriedAAs.RequiredAAs
.size() << "/" << QuerriedAAs.OptionalAAs.size() <<
 " required/optional dependences\n"; } } while (false)
                      << QuerriedAAs.RequiredAAs.size() << "/"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] InvalidAA: " <<
 *InvalidAA << " has " << QuerriedAAs.RequiredAAs
.size() << "/" << QuerriedAAs.OptionalAAs.size() <<
 " required/optional dependences\n"; } } while (false)
                      << QuerriedAAs.OptionalAAs.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] InvalidAA: " <<
 *InvalidAA << " has " << QuerriedAAs.RequiredAAs
.size() << "/" << QuerriedAAs.OptionalAAs.size() <<
 " required/optional dependences\n"; } } while (false)
                      << " required/optional dependences\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] InvalidAA: " <<
 *InvalidAA << " has " << QuerriedAAs.RequiredAAs
.size() << "/" << QuerriedAAs.OptionalAAs.size() <<
 " required/optional dependences\n"; } } while (false);
    for (AbstractAttribute *DepOnInvalidAA : QuerriedAAs.RequiredAAs) {
      AbstractState &DOIAAState = DepOnInvalidAA->getState();
      DOIAAState.indicatePessimisticFixpoint();
      ++NumAttributesFixedDueToRequiredDependences;
      assert(DOIAAState.isAtFixpoint() && "Expected fixpoint state!")((DOIAAState.isAtFixpoint() && "Expected fixpoint state!"
) ? static_cast<void> (0) : __assert_fail ("DOIAAState.isAtFixpoint() && \"Expected fixpoint state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7653, __PRETTY_FUNCTION__));
      if (!DOIAAState.isValidState())
        InvalidAAs.insert(DepOnInvalidAA);
      else
        ChangedAAs.push_back(DepOnInvalidAA);
    }
    if (!RecomputeDependences)
      Worklist.insert(QuerriedAAs.OptionalAAs.begin(),
                      QuerriedAAs.OptionalAAs.end());
  }

  // If dependences (=QueryMap) are recomputed we have to look at all abstract
  // attributes again, regardless of what changed in the last iteration.
  if (RecomputeDependences) {
    LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Run all AAs to recompute dependences\n"
; } } while (false)
        dbgs() << "[Attributor] Run all AAs to recompute dependences\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Run all AAs to recompute dependences\n"
; } } while (false);
    QueryMap.clear();
    ChangedAAs.clear();
    Worklist.insert(AllAbstractAttributes.begin(),
                    AllAbstractAttributes.end());
  }

  // Add all abstract attributes that are potentially dependent on one that
  // changed to the work list.
  for (AbstractAttribute *ChangedAA : ChangedAAs) {
    auto &QuerriedAAs = QueryMap[ChangedAA];
    Worklist.insert(QuerriedAAs.OptionalAAs.begin(),
                    QuerriedAAs.OptionalAAs.end());
    Worklist.insert(QuerriedAAs.RequiredAAs.begin(),
                    QuerriedAAs.RequiredAAs.end());
  }

  LLVM_DEBUG(dbgs() << "[Attributor] #Iteration: " << IterationCounterdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] #Iteration: "
 << IterationCounter << ", Worklist+Dependent size: "
 << Worklist.size() << "\n"; } } while (false)
                    << ", Worklist+Dependent size: " << Worklist.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] #Iteration: "
 << IterationCounter << ", Worklist+Dependent size: "
 << Worklist.size() << "\n"; } } while (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] #Iteration: "
 << IterationCounter << ", Worklist+Dependent size: "
 << Worklist.size() << "\n"; } } while (false);

  // Reset the changed and invalid set.
  ChangedAAs.clear();
  InvalidAAs.clear();

  // Update all abstract attribute in the work list and record the ones that
  // changed.
  for (AbstractAttribute *AA : Worklist)
    if (!AA->getState().isAtFixpoint() &&
        !isAssumedDead(*AA, nullptr, /* CheckBBLivenessOnly */ true)) {
      QueriedNonFixAA = false;
      if (AA->update(*this) == ChangeStatus::CHANGED) {
        ChangedAAs.push_back(AA);
        if (!AA->getState().isValidState())
          InvalidAAs.insert(AA);
      } else if (!QueriedNonFixAA) {
        // If the attribute did not query any non-fix information, the state
        // will not change and we can indicate that right away.
        AA->getState().indicateOptimisticFixpoint();
      }
    }

  // Check if we recompute the dependences in the next iteration.
  RecomputeDependences = (DepRecomputeInterval > 0 &&
                          IterationCounter % DepRecomputeInterval == 0);

  // Add attributes to the changed set if they have been created in the last
  // iteration.
  ChangedAAs.append(AllAbstractAttributes.begin() + NumAAs,
                    AllAbstractAttributes.end());

  // Reset the work list and repopulate with the changed abstract attributes.
  // Note that dependent ones are added above.
  Worklist.clear();
  Worklist.insert(ChangedAAs.begin(), ChangedAAs.end());

} while (!Worklist.empty() && (IterationCounter++ < MaxFixpointIterations ||
                               VerifyMaxFixpointIterations));

LLVM_DEBUG(dbgs() << "\n[Attributor] Fixpoint iteration done after: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Fixpoint iteration done after: "
 << IterationCounter << "/" << MaxFixpointIterations
 << " iterations\n"; } } while (false)
                  << IterationCounter << "/" << MaxFixpointIterationsdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Fixpoint iteration done after: "
 << IterationCounter << "/" << MaxFixpointIterations
 << " iterations\n"; } } while (false)
                  << " iterations\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Fixpoint iteration done after: "
 << IterationCounter << "/" << MaxFixpointIterations
 << " iterations\n"; } } while (false);

size_t NumFinalAAs = AllAbstractAttributes.size();

// Reset abstract arguments not settled in a sound fixpoint by now. This
// happens when we stopped the fixpoint iteration early. Note that only the
// ones marked as "changed" *and* the ones transitively depending on them
// need to be reverted to a pessimistic state. Others might not be in a
// fixpoint state but we can use the optimistic results for them anyway.
SmallPtrSet<AbstractAttribute *, 32> Visited;
for (unsigned u = 0; u < ChangedAAs.size(); u++) {
  AbstractAttribute *ChangedAA = ChangedAAs[u];
  if (!Visited.insert(ChangedAA).second)
    continue;

  AbstractState &State = ChangedAA->getState();
  if (!State.isAtFixpoint()) {
    State.indicatePessimisticFixpoint();

    NumAttributesTimedOut++;
  }

  auto &QuerriedAAs = QueryMap[ChangedAA];
  ChangedAAs.append(QuerriedAAs.OptionalAAs.begin(),
                    QuerriedAAs.OptionalAAs.end());
  ChangedAAs.append(QuerriedAAs.RequiredAAs.begin(),
                    QuerriedAAs.RequiredAAs.end());
}

LLVM_DEBUG({do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Visited.empty()) dbgs() << "\n[Attributor] Finalized "
 << Visited.size() << " abstract attributes.\n"; }
; } } while (false)
  if (!Visited.empty())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Visited.empty()) dbgs() << "\n[Attributor] Finalized "
 << Visited.size() << " abstract attributes.\n"; }
; } } while (false)
    dbgs() << "\n[Attributor] Finalized " << Visited.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Visited.empty()) dbgs() << "\n[Attributor] Finalized "
 << Visited.size() << " abstract attributes.\n"; }
; } } while (false)
           << " abstract attributes.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Visited.empty()) dbgs() << "\n[Attributor] Finalized "
 << Visited.size() << " abstract attributes.\n"; }
; } } while (false)
})do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { { if (!Visited.empty()) dbgs() << "\n[Attributor] Finalized "
 << Visited.size() << " abstract attributes.\n"; }
; } } while (false);

unsigned NumManifested = 0;
unsigned NumAtFixpoint = 0;
ChangeStatus ManifestChange = ChangeStatus::UNCHANGED;
for (AbstractAttribute *AA : AllAbstractAttributes) {
  AbstractState &State = AA->getState();

  // If there is not already a fixpoint reached, we can now take the
  // optimistic state. This is correct because we enforced a pessimistic one
  // on abstract attributes that were transitively dependent on a changed one
  // already above.
  if (!State.isAtFixpoint())
    State.indicateOptimisticFixpoint();

  // If the state is invalid, we do not try to manifest it.
  if (!State.isValidState())
    continue;

  // Skip dead code.
  if (isAssumedDead(*AA, nullptr, /* CheckBBLivenessOnly */ true))
    continue;
  // Manifest the state and record if we changed the IR.
  ChangeStatus LocalChange = AA->manifest(*this);
  if (LocalChange == ChangeStatus::CHANGED && AreStatisticsEnabled())
    AA->trackStatistics();
  LLVM_DEBUG(dbgs() << "[Attributor] Manifest " << LocalChange << " : " << *AAdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Manifest " <<
 LocalChange << " : " << *AA << "\n"; } } while
 (false)
                    << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Manifest " <<
 LocalChange << " : " << *AA << "\n"; } } while
 (false);

  ManifestChange = ManifestChange | LocalChange;

  NumAtFixpoint++;
  NumManifested += (LocalChange == ChangeStatus::CHANGED);
}

(void)NumManifested;
(void)NumAtFixpoint;
LLVM_DEBUG(dbgs() << "\n[Attributor] Manifested " << NumManifesteddo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Manifested "
 << NumManifested << " arguments while " <<
 NumAtFixpoint << " were in a valid fixpoint state\n"; }
 } while (false)
                  << " arguments while " << NumAtFixpointdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Manifested "
 << NumManifested << " arguments while " <<
 NumAtFixpoint << " were in a valid fixpoint state\n"; }
 } while (false)
                  << " were in a valid fixpoint state\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Manifested "
 << NumManifested << " arguments while " <<
 NumAtFixpoint << " were in a valid fixpoint state\n"; }
 } while (false);

NumAttributesManifested += NumManifested;
NumAttributesValidFixpoint += NumAtFixpoint;

(void)NumFinalAAs;
if (NumFinalAAs != AllAbstractAttributes.size()) {
  for (unsigned u = NumFinalAAs; u < AllAbstractAttributes.size(); ++u)
    errs() << "Unexpected abstract attribute: " << *AllAbstractAttributes[u]
           << " :: "
           << AllAbstractAttributes[u]->getIRPosition().getAssociatedValue()
           << "\n";
  llvm_unreachable("Expected the final number of abstract attributes to "::llvm::llvm_unreachable_internal("Expected the final number of abstract attributes to "
 "remain unchanged!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7814)
                   "remain unchanged!")::llvm::llvm_unreachable_internal("Expected the final number of abstract attributes to "
 "remain unchanged!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7814);
}

// Delete stuff at the end to avoid invalid references and a nice order.
{
  LLVM_DEBUG(dbgs() << "\n[Attributor] Delete at least "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Delete at least "
 << ToBeDeletedFunctions.size() << " functions and "
 << ToBeDeletedBlocks.size() << " blocks and " <<
 ToBeDeletedInsts.size() << " instructions and " <<
 ToBeChangedUses.size() << " uses\n"; } } while (false)
                    << ToBeDeletedFunctions.size() << " functions and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Delete at least "
 << ToBeDeletedFunctions.size() << " functions and "
 << ToBeDeletedBlocks.size() << " blocks and " <<
 ToBeDeletedInsts.size() << " instructions and " <<
 ToBeChangedUses.size() << " uses\n"; } } while (false)
                    << ToBeDeletedBlocks.size() << " blocks and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Delete at least "
 << ToBeDeletedFunctions.size() << " functions and "
 << ToBeDeletedBlocks.size() << " blocks and " <<
 ToBeDeletedInsts.size() << " instructions and " <<
 ToBeChangedUses.size() << " uses\n"; } } while (false)
                    << ToBeDeletedInsts.size() << " instructions and "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Delete at least "
 << ToBeDeletedFunctions.size() << " functions and "
 << ToBeDeletedBlocks.size() << " blocks and " <<
 ToBeDeletedInsts.size() << " instructions and " <<
 ToBeChangedUses.size() << " uses\n"; } } while (false)
                    << ToBeChangedUses.size() << " uses\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "\n[Attributor] Delete at least "
 << ToBeDeletedFunctions.size() << " functions and "
 << ToBeDeletedBlocks.size() << " blocks and " <<
 ToBeDeletedInsts.size() << " instructions and " <<
 ToBeChangedUses.size() << " uses\n"; } } while (false);

  SmallVector<WeakTrackingVH, 32> DeadInsts;
  SmallVector<Instruction *, 32> TerminatorsToFold;

  for (auto &It : ToBeChangedUses) {
    Use *U = It.first;
    Value *NewV = It.second;
    Value *OldV = U->get();
    LLVM_DEBUG(dbgs() << "Use " << *NewV << " in " << *U->getUser()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Use " << *NewV <<
 " in " << *U->getUser() << " instead of " <<
 *OldV << "\n"; } } while (false)
                      << " instead of " << *OldV << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "Use " << *NewV <<
 " in " << *U->getUser() << " instead of " <<
 *OldV << "\n"; } } while (false);
    U->set(NewV);
    // Do not modify call instructions outside the SCC.
    if (auto *CB = dyn_cast<CallBase>(OldV))
      if (!Functions.count(CB->getCaller()))
        continue;
    if (Instruction *I = dyn_cast<Instruction>(OldV)) {
      CGModifiedFunctions.insert(I->getFunction());
      if (!isa<PHINode>(I) && !ToBeDeletedInsts.count(I) &&
          isInstructionTriviallyDead(I))
        DeadInsts.push_back(I);
    }
    if (isa<Constant>(NewV) && isa<BranchInst>(U->getUser())) {
      Instruction *UserI = cast<Instruction>(U->getUser());
      if (isa<UndefValue>(NewV)) {
        ToBeChangedToUnreachableInsts.insert(UserI);
      } else {
        TerminatorsToFold.push_back(UserI);
      }
    }
  }
  for (auto &V : InvokeWithDeadSuccessor)
    if (InvokeInst *II = dyn_cast_or_null<InvokeInst>(V)) {
      bool UnwindBBIsDead = II->hasFnAttr(Attribute::NoUnwind);
      bool NormalBBIsDead = II->hasFnAttr(Attribute::NoReturn);
      bool Invoke2CallAllowed =
          !AAIsDeadFunction::mayCatchAsynchronousExceptions(
              *II->getFunction());
      assert((UnwindBBIsDead || NormalBBIsDead) &&(((UnwindBBIsDead || NormalBBIsDead) && "Invoke does not have dead successors!"
) ? static_cast<void> (0) : __assert_fail ("(UnwindBBIsDead || NormalBBIsDead) && \"Invoke does not have dead successors!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7862, __PRETTY_FUNCTION__))
             "Invoke does not have dead successors!")(((UnwindBBIsDead || NormalBBIsDead) && "Invoke does not have dead successors!"
) ? static_cast<void> (0) : __assert_fail ("(UnwindBBIsDead || NormalBBIsDead) && \"Invoke does not have dead successors!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7862, __PRETTY_FUNCTION__));
      BasicBlock *BB = II->getParent();
      BasicBlock *NormalDestBB = II->getNormalDest();
      if (UnwindBBIsDead) {
        Instruction *NormalNextIP = &NormalDestBB->front();
        if (Invoke2CallAllowed) {
          changeToCall(II);
          NormalNextIP = BB->getTerminator();
        }
        if (NormalBBIsDead)
          ToBeChangedToUnreachableInsts.insert(NormalNextIP);
      } else {
        assert(NormalBBIsDead && "Broken invariant!")((NormalBBIsDead && "Broken invariant!") ? static_cast
<void> (0) : __assert_fail ("NormalBBIsDead && \"Broken invariant!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7874, __PRETTY_FUNCTION__));
        if (!NormalDestBB->getUniquePredecessor())
          NormalDestBB = SplitBlockPredecessors(NormalDestBB, {BB}, ".dead");
        ToBeChangedToUnreachableInsts.insert(&NormalDestBB->front());
      }
    }
  for (Instruction *I : TerminatorsToFold) {
    CGModifiedFunctions.insert(I->getFunction());
    ConstantFoldTerminator(I->getParent());
  }
  for (auto &V : ToBeChangedToUnreachableInsts)
    if (Instruction *I = dyn_cast_or_null<Instruction>(V)) {
      CGModifiedFunctions.insert(I->getFunction());
      changeToUnreachable(I, /* UseLLVMTrap */ false);
    }

  for (auto &V : ToBeDeletedInsts) {
    if (Instruction *I = dyn_cast_or_null<Instruction>(V)) {
      CGModifiedFunctions.insert(I->getFunction());
      if (!I->getType()->isVoidTy())
        I->replaceAllUsesWith(UndefValue::get(I->getType()));
      if (!isa<PHINode>(I) && isInstructionTriviallyDead(I))
        DeadInsts.push_back(I);
      else
        I->eraseFromParent();
    }
  }

  RecursivelyDeleteTriviallyDeadInstructions(DeadInsts);

  if (unsigned NumDeadBlocks = ToBeDeletedBlocks.size()) {
    SmallVector<BasicBlock *, 8> ToBeDeletedBBs;
    ToBeDeletedBBs.reserve(NumDeadBlocks);
    for (BasicBlock *BB : ToBeDeletedBlocks) {
      CGModifiedFunctions.insert(BB->getParent());
      ToBeDeletedBBs.push_back(BB);
    }
    // Actually we do not delete the blocks but squash them into a single
    // unreachable but untangling branches that jump here is something we need
    // to do in a more generic way.
    DetatchDeadBlocks(ToBeDeletedBBs, nullptr);
    STATS_DECL(AAIsDead, BasicBlock, "Number of dead basic blocks deleted.")static llvm::Statistic NumIRBasicBlock_AAIsDead = {"attributor"
, "NumIRBasicBlock_AAIsDead", "Number of dead basic blocks deleted."
};;;
    BUILD_STAT_NAME(AAIsDead, BasicBlock)NumIRBasicBlock_AAIsDead += ToBeDeletedBlocks.size();
  }

  // Identify dead internal functions and delete them. This happens outside
  // the other fixpoint analysis as we might treat potentially dead functions
  // as live to lower the number of iterations. If they happen to be dead, the
  // below fixpoint loop will identify and eliminate them.
  SmallVector<Function *, 8> InternalFns;
  for (Function *F : Functions)
    if (F->hasLocalLinkage())
      InternalFns.push_back(F);

  bool FoundDeadFn = true;
  while (FoundDeadFn) {
    FoundDeadFn = false;
    for (unsigned u = 0, e = InternalFns.size(); u < e; ++u) {
      Function *F = InternalFns[u];
      if (!F)
        continue;

      bool AllCallSitesKnown;
      if (!checkForAllCallSites(
              [this](AbstractCallSite ACS) {
                return ToBeDeletedFunctions.count(
                    ACS.getInstruction()->getFunction());
              },
              *F, true, nullptr, AllCallSitesKnown))
        continue;

      ToBeDeletedFunctions.insert(F);
      InternalFns[u] = nullptr;
      FoundDeadFn = true;
    }
  }
}

// Rewrite the functions as requested during manifest.
ManifestChange =
    ManifestChange | rewriteFunctionSignatures(CGModifiedFunctions);

for (Function *Fn : CGModifiedFunctions)
  CGUpdater.reanalyzeFunction(*Fn);

STATS_DECL(AAIsDead, Function, "Number of dead functions deleted.")static llvm::Statistic NumIRFunction_AAIsDead = {"attributor"
, "NumIRFunction_AAIsDead", "Number of dead functions deleted."
};;;
BUILD_STAT_NAME(AAIsDead, Function)NumIRFunction_AAIsDead += ToBeDeletedFunctions.size();

for (Function *Fn : ToBeDeletedFunctions)
  CGUpdater.removeFunction(*Fn);

if (VerifyMaxFixpointIterations &&
    IterationCounter != MaxFixpointIterations) {
  errs() << "\n[Attributor] Fixpoint iteration done after: "
         << IterationCounter << "/" << MaxFixpointIterations
         << " iterations\n";
  llvm_unreachable("The fixpoint was not reached with exactly the number of "::llvm::llvm_unreachable_internal("The fixpoint was not reached with exactly the number of "
 "specified iterations!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7971)
                   "specified iterations!")::llvm::llvm_unreachable_internal("The fixpoint was not reached with exactly the number of "
 "specified iterations!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 7971);
}

return ManifestChange;
7975}

7977bool Attributor::isValidFunctionSignatureRewrite(
  Argument &Arg, ArrayRef<Type *> ReplacementTypes) {

auto CallSiteCanBeChanged = [](AbstractCallSite ACS) {
  // Forbid must-tail calls for now.
  return !ACS.isCallbackCall() && !ACS.getCallSite().isMustTailCall();
};

Function *Fn = Arg.getParent();
// Avoid var-arg functions for now.
if (Fn->isVarArg()) {
  LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite var-args functions\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Cannot rewrite var-args functions\n"
; } } while (false);
  return false;
}

// Avoid functions with complicated argument passing semantics.
AttributeList FnAttributeList = Fn->getAttributes();
if (FnAttributeList.hasAttrSomewhere(Attribute::Nest) ||
    FnAttributeList.hasAttrSomewhere(Attribute::StructRet) ||
    FnAttributeList.hasAttrSomewhere(Attribute::InAlloca)) {
  LLVM_DEBUG(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Cannot rewrite due to complex attribute\n"
; } } while (false)
      dbgs() << "[Attributor] Cannot rewrite due to complex attribute\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Cannot rewrite due to complex attribute\n"
; } } while (false);
  return false;
}

// Avoid callbacks for now.
bool AllCallSitesKnown;
if (!checkForAllCallSites(CallSiteCanBeChanged, *Fn, true, nullptr,
                          AllCallSitesKnown)) {
  LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite all call sites\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Cannot rewrite all call sites\n"
; } } while (false);
  return false;
}

auto InstPred = [](Instruction &I) {
  if (auto *CI = dyn_cast<CallInst>(&I))
    return !CI->isMustTailCall();
  return true;
};

// Forbid must-tail calls for now.
// TODO:
auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(*Fn);
if (!checkForAllInstructionsImpl(nullptr, OpcodeInstMap, InstPred, nullptr,
                                 nullptr, {Instruction::Call})) {
  LLVM_DEBUG(dbgs() << "[Attributor] Cannot rewrite due to instructions\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Cannot rewrite due to instructions\n"
; } } while (false);
  return false;
}

return true;
8026}

8028bool Attributor::registerFunctionSignatureRewrite(
  Argument &Arg, ArrayRef<Type *> ReplacementTypes,
  ArgumentReplacementInfo::CalleeRepairCBTy &&CalleeRepairCB,
  ArgumentReplacementInfo::ACSRepairCBTy &&ACSRepairCB) {
LLVM_DEBUG(dbgs() << "[Attributor] Register new rewrite of " << Arg << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false)
                  << Arg.getParent()->getName() << " with "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false)
                  << ReplacementTypes.size() << " replacements\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false);
assert(isValidFunctionSignatureRewrite(Arg, ReplacementTypes) &&((isValidFunctionSignatureRewrite(Arg, ReplacementTypes) &&
 "Cannot register an invalid rewrite") ? static_cast<void>
 (0) : __assert_fail ("isValidFunctionSignatureRewrite(Arg, ReplacementTypes) && \"Cannot register an invalid rewrite\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8036, __PRETTY_FUNCTION__))
       "Cannot register an invalid rewrite")((isValidFunctionSignatureRewrite(Arg, ReplacementTypes) &&
 "Cannot register an invalid rewrite") ? static_cast<void>
 (0) : __assert_fail ("isValidFunctionSignatureRewrite(Arg, ReplacementTypes) && \"Cannot register an invalid rewrite\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8036, __PRETTY_FUNCTION__));

Function *Fn = Arg.getParent();
SmallVectorImpl<ArgumentReplacementInfo *> &ARIs = ArgumentReplacementMap[Fn];
if (ARIs.empty())
  ARIs.resize(Fn->arg_size());

// If we have a replacement already with less than or equal new arguments,
// ignore this request.
ArgumentReplacementInfo *&ARI = ARIs[Arg.getArgNo()];
if (ARI && ARI->getNumReplacementArgs() <= ReplacementTypes.size()) {
  LLVM_DEBUG(dbgs() << "[Attributor] Existing rewrite is preferred\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Existing rewrite is preferred\n"
; } } while (false);
  return false;
}

// If we have a replacement already but we like the new one better, delete
// the old.
if (ARI)
  delete ARI;

LLVM_DEBUG(dbgs() << "[Attributor] Register new rewrite of " << Arg << " in "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false)
                  << Arg.getParent()->getName() << " with "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false)
                  << ReplacementTypes.size() << " replacements\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Register new rewrite of "
 << Arg << " in " << Arg.getParent()->getName
() << " with " << ReplacementTypes.size() <<
 " replacements\n"; } } while (false);

// Remember the replacement.
ARI = new ArgumentReplacementInfo(*this, Arg, ReplacementTypes,
                                  std::move(CalleeRepairCB),
                                  std::move(ACSRepairCB));

return true;
8066}

8068ChangeStatus Attributor::rewriteFunctionSignatures(
  SmallPtrSetImpl<Function *> &ModifiedFns) {
ChangeStatus Changed = ChangeStatus::UNCHANGED;

for (auto &It : ArgumentReplacementMap) {
  Function *OldFn = It.getFirst();

  // Deleted functions do not require rewrites.
  if (ToBeDeletedFunctions.count(OldFn))
    continue;

  const SmallVectorImpl<ArgumentReplacementInfo *> &ARIs = It.getSecond();
  assert(ARIs.size() == OldFn->arg_size() && "Inconsistent state!")((ARIs.size() == OldFn->arg_size() && "Inconsistent state!"
) ? static_cast<void> (0) : __assert_fail ("ARIs.size() == OldFn->arg_size() && \"Inconsistent state!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8080, __PRETTY_FUNCTION__));

  SmallVector<Type *, 16> NewArgumentTypes;
  SmallVector<AttributeSet, 16> NewArgumentAttributes;

  // Collect replacement argument types and copy over existing attributes.
  AttributeList OldFnAttributeList = OldFn->getAttributes();
  for (Argument &Arg : OldFn->args()) {
    if (ArgumentReplacementInfo *ARI = ARIs[Arg.getArgNo()]) {
      NewArgumentTypes.append(ARI->ReplacementTypes.begin(),
                              ARI->ReplacementTypes.end());
      NewArgumentAttributes.append(ARI->getNumReplacementArgs(),
                                   AttributeSet());
    } else {
      NewArgumentTypes.push_back(Arg.getType());
      NewArgumentAttributes.push_back(
          OldFnAttributeList.getParamAttributes(Arg.getArgNo()));
    }
  }

  FunctionType *OldFnTy = OldFn->getFunctionType();
  Type *RetTy = OldFnTy->getReturnType();

  // Construct the new function type using the new arguments types.
  FunctionType *NewFnTy =
      FunctionType::get(RetTy, NewArgumentTypes, OldFnTy->isVarArg());

  LLVM_DEBUG(dbgs() << "[Attributor] Function rewrite '" << OldFn->getName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function rewrite '"
 << OldFn->getName() << "' from " << *OldFn
->getFunctionType() << " to " << *NewFnTy <<
 "\n"; } } while (false)
                    << "' from " << *OldFn->getFunctionType() << " to "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function rewrite '"
 << OldFn->getName() << "' from " << *OldFn
->getFunctionType() << " to " << *NewFnTy <<
 "\n"; } } while (false)
                    << *NewFnTy << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Function rewrite '"
 << OldFn->getName() << "' from " << *OldFn
->getFunctionType() << " to " << *NewFnTy <<
 "\n"; } } while (false);

  // Create the new function body and insert it into the module.
  Function *NewFn = Function::Create(NewFnTy, OldFn->getLinkage(),
                                     OldFn->getAddressSpace(), "");
  OldFn->getParent()->getFunctionList().insert(OldFn->getIterator(), NewFn);
  NewFn->takeName(OldFn);
  NewFn->copyAttributesFrom(OldFn);

  // Patch the pointer to LLVM function in debug info descriptor.
  NewFn->setSubprogram(OldFn->getSubprogram());
  OldFn->setSubprogram(nullptr);

  // Recompute the parameter attributes list based on the new arguments for
  // the function.
  LLVMContext &Ctx = OldFn->getContext();
  NewFn->setAttributes(AttributeList::get(
      Ctx, OldFnAttributeList.getFnAttributes(),
      OldFnAttributeList.getRetAttributes(), NewArgumentAttributes));

  // Since we have now created the new function, splice the body of the old
  // function right into the new function, leaving the old rotting hulk of the
  // function empty.
  NewFn->getBasicBlockList().splice(NewFn->begin(),
                                    OldFn->getBasicBlockList());

  // Set of all "call-like" instructions that invoke the old function mapped
  // to their new replacements.
  SmallVector<std::pair<CallBase *, CallBase *>, 8> CallSitePairs;

  // Callback to create a new "call-like" instruction for a given one.
  auto CallSiteReplacementCreator = [&](AbstractCallSite ACS) {
    CallBase *OldCB = cast<CallBase>(ACS.getInstruction());
    const AttributeList &OldCallAttributeList = OldCB->getAttributes();

    // Collect the new argument operands for the replacement call site.
    SmallVector<Value *, 16> NewArgOperands;
    SmallVector<AttributeSet, 16> NewArgOperandAttributes;
    for (unsigned OldArgNum = 0; OldArgNum < ARIs.size(); ++OldArgNum) {
      unsigned NewFirstArgNum = NewArgOperands.size();
      (void)NewFirstArgNum; // only used inside assert.
      if (ArgumentReplacementInfo *ARI = ARIs[OldArgNum]) {
        if (ARI->ACSRepairCB)
          ARI->ACSRepairCB(*ARI, ACS, NewArgOperands);
        assert(ARI->getNumReplacementArgs() + NewFirstArgNum ==((ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands
.size() && "ACS repair callback did not provide as many operand as new "
 "types were registered!") ? static_cast<void> (0) : __assert_fail
 ("ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands.size() && \"ACS repair callback did not provide as many operand as new \" \"types were registered!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8156, __PRETTY_FUNCTION__))
                   NewArgOperands.size() &&((ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands
.size() && "ACS repair callback did not provide as many operand as new "
 "types were registered!") ? static_cast<void> (0) : __assert_fail
 ("ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands.size() && \"ACS repair callback did not provide as many operand as new \" \"types were registered!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8156, __PRETTY_FUNCTION__))
               "ACS repair callback did not provide as many operand as new "((ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands
.size() && "ACS repair callback did not provide as many operand as new "
 "types were registered!") ? static_cast<void> (0) : __assert_fail
 ("ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands.size() && \"ACS repair callback did not provide as many operand as new \" \"types were registered!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8156, __PRETTY_FUNCTION__))
               "types were registered!")((ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands
.size() && "ACS repair callback did not provide as many operand as new "
 "types were registered!") ? static_cast<void> (0) : __assert_fail
 ("ARI->getNumReplacementArgs() + NewFirstArgNum == NewArgOperands.size() && \"ACS repair callback did not provide as many operand as new \" \"types were registered!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8156, __PRETTY_FUNCTION__));
        // TODO: Exose the attribute set to the ACS repair callback
        NewArgOperandAttributes.append(ARI->ReplacementTypes.size(),
                                       AttributeSet());
      } else {
        NewArgOperands.push_back(ACS.getCallArgOperand(OldArgNum));
        NewArgOperandAttributes.push_back(
            OldCallAttributeList.getParamAttributes(OldArgNum));
      }
    }

    assert(NewArgOperands.size() == NewArgOperandAttributes.size() &&((NewArgOperands.size() == NewArgOperandAttributes.size() &&
 "Mismatch # argument operands vs. # argument operand attributes!"
) ? static_cast<void> (0) : __assert_fail ("NewArgOperands.size() == NewArgOperandAttributes.size() && \"Mismatch # argument operands vs. # argument operand attributes!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8168, __PRETTY_FUNCTION__))
           "Mismatch # argument operands vs. # argument operand attributes!")((NewArgOperands.size() == NewArgOperandAttributes.size() &&
 "Mismatch # argument operands vs. # argument operand attributes!"
) ? static_cast<void> (0) : __assert_fail ("NewArgOperands.size() == NewArgOperandAttributes.size() && \"Mismatch # argument operands vs. # argument operand attributes!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8168, __PRETTY_FUNCTION__));
    assert(NewArgOperands.size() == NewFn->arg_size() &&((NewArgOperands.size() == NewFn->arg_size() && "Mismatch # argument operands vs. # function arguments!"
) ? static_cast<void> (0) : __assert_fail ("NewArgOperands.size() == NewFn->arg_size() && \"Mismatch # argument operands vs. # function arguments!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8170, __PRETTY_FUNCTION__))
           "Mismatch # argument operands vs. # function arguments!")((NewArgOperands.size() == NewFn->arg_size() && "Mismatch # argument operands vs. # function arguments!"
) ? static_cast<void> (0) : __assert_fail ("NewArgOperands.size() == NewFn->arg_size() && \"Mismatch # argument operands vs. # function arguments!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8170, __PRETTY_FUNCTION__));

    SmallVector<OperandBundleDef, 4> OperandBundleDefs;
    OldCB->getOperandBundlesAsDefs(OperandBundleDefs);

    // Create a new call or invoke instruction to replace the old one.
    CallBase *NewCB;
    if (InvokeInst *II = dyn_cast<InvokeInst>(OldCB)) {
      NewCB =
          InvokeInst::Create(NewFn, II->getNormalDest(), II->getUnwindDest(),
                             NewArgOperands, OperandBundleDefs, "", OldCB);
    } else {
      auto *NewCI = CallInst::Create(NewFn, NewArgOperands, OperandBundleDefs,
                                     "", OldCB);
      NewCI->setTailCallKind(cast<CallInst>(OldCB)->getTailCallKind());
      NewCB = NewCI;
    }

    // Copy over various properties and the new attributes.
    uint64_t W;
    if (OldCB->extractProfTotalWeight(W))
      NewCB->setProfWeight(W);
    NewCB->setCallingConv(OldCB->getCallingConv());
    NewCB->setDebugLoc(OldCB->getDebugLoc());
    NewCB->takeName(OldCB);
    NewCB->setAttributes(AttributeList::get(
        Ctx, OldCallAttributeList.getFnAttributes(),
        OldCallAttributeList.getRetAttributes(), NewArgOperandAttributes));

    CallSitePairs.push_back({OldCB, NewCB});
    return true;
  };

  // Use the CallSiteReplacementCreator to create replacement call sites.
  bool AllCallSitesKnown;
  bool Success = checkForAllCallSites(CallSiteReplacementCreator, *OldFn,
                                      true, nullptr, AllCallSitesKnown);
  (void)Success;
  assert(Success && "Assumed call site replacement to succeed!")((Success && "Assumed call site replacement to succeed!"
) ? static_cast<void> (0) : __assert_fail ("Success && \"Assumed call site replacement to succeed!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8208, __PRETTY_FUNCTION__));

  // Rewire the arguments.
  auto OldFnArgIt = OldFn->arg_begin();
  auto NewFnArgIt = NewFn->arg_begin();
  for (unsigned OldArgNum = 0; OldArgNum < ARIs.size();
       ++OldArgNum, ++OldFnArgIt) {
    if (ArgumentReplacementInfo *ARI = ARIs[OldArgNum]) {
      if (ARI->CalleeRepairCB)
        ARI->CalleeRepairCB(*ARI, *NewFn, NewFnArgIt);
      NewFnArgIt += ARI->ReplacementTypes.size();
    } else {
      NewFnArgIt->takeName(&*OldFnArgIt);
      OldFnArgIt->replaceAllUsesWith(&*NewFnArgIt);
      ++NewFnArgIt;
    }
  }

  // Eliminate the instructions *after* we visited all of them.
  for (auto &CallSitePair : CallSitePairs) {
    CallBase &OldCB = *CallSitePair.first;
    CallBase &NewCB = *CallSitePair.second;
    // We do not modify the call graph here but simply reanalyze the old
    // function. This should be revisited once the old PM is gone.
    ModifiedFns.insert(OldCB.getFunction());
    OldCB.replaceAllUsesWith(&NewCB);
    OldCB.eraseFromParent();
  }

  // Replace the function in the call graph (if any).
  CGUpdater.replaceFunctionWith(*OldFn, *NewFn);

  // If the old function was modified and needed to be reanalyzed, the new one
  // does now.
  if (ModifiedFns.erase(OldFn))
    ModifiedFns.insert(NewFn);

  Changed = ChangeStatus::CHANGED;
}

return Changed;
8249}

8251void Attributor::initializeInformationCache(Function &F) {

// Walk all instructions to find interesting instructions that might be
// queried by abstract attributes during their initialization or update.
// This has to happen before we create attributes.
auto &ReadOrWriteInsts = InfoCache.FuncRWInstsMap[&F];
auto &InstOpcodeMap = InfoCache.FuncInstOpcodeMap[&F];

for (Instruction &I : instructions(&F)) {
  bool IsInterestingOpcode = false;

  // To allow easy access to all instructions in a function with a given
  // opcode we store them in the InfoCache. As not all opcodes are interesting
  // to concrete attributes we only cache the ones that are as identified in
  // the following switch.
  // Note: There are no concrete attributes now so this is initially empty.
  switch (I.getOpcode()) {
  default:
    assert((!ImmutableCallSite(&I)) && (!isa<CallBase>(&I)) &&(((!ImmutableCallSite(&I)) && (!isa<CallBase>
(&I)) && "New call site/base instruction type needs to be known int the "
 "Attributor.") ? static_cast<void> (0) : __assert_fail
 ("(!ImmutableCallSite(&I)) && (!isa<CallBase>(&I)) && \"New call site/base instruction type needs to be known int the \" \"Attributor.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8271, __PRETTY_FUNCTION__))
           "New call site/base instruction type needs to be known int the "(((!ImmutableCallSite(&I)) && (!isa<CallBase>
(&I)) && "New call site/base instruction type needs to be known int the "
 "Attributor.") ? static_cast<void> (0) : __assert_fail
 ("(!ImmutableCallSite(&I)) && (!isa<CallBase>(&I)) && \"New call site/base instruction type needs to be known int the \" \"Attributor.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8271, __PRETTY_FUNCTION__))
           "Attributor.")(((!ImmutableCallSite(&I)) && (!isa<CallBase>
(&I)) && "New call site/base instruction type needs to be known int the "
 "Attributor.") ? static_cast<void> (0) : __assert_fail
 ("(!ImmutableCallSite(&I)) && (!isa<CallBase>(&I)) && \"New call site/base instruction type needs to be known int the \" \"Attributor.\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8271, __PRETTY_FUNCTION__));
    break;
  case Instruction::Load:
    // The alignment of a pointer is interesting for loads.
  case Instruction::Store:
    // The alignment of a pointer is interesting for stores.
  case Instruction::Call:
  case Instruction::CallBr:
  case Instruction::Invoke:
  case Instruction::CleanupRet:
  case Instruction::CatchSwitch:
  case Instruction::AtomicRMW:
  case Instruction::AtomicCmpXchg:
  case Instruction::Br:
  case Instruction::Resume:
  case Instruction::Ret:
    IsInterestingOpcode = true;
  }
  if (IsInterestingOpcode)
    InstOpcodeMap[I.getOpcode()].push_back(&I);
  if (I.mayReadOrWriteMemory())
    ReadOrWriteInsts.push_back(&I);
}
8294}

8296void Attributor::recordDependence(const AbstractAttribute &FromAA,
                                const AbstractAttribute &ToAA,
                                DepClassTy DepClass) {
if (FromAA.getState().isAtFixpoint())
  return;

if (DepClass == DepClassTy::REQUIRED)
  QueryMap[&FromAA].RequiredAAs.insert(
      const_cast<AbstractAttribute *>(&ToAA));
else
  QueryMap[&FromAA].OptionalAAs.insert(
      const_cast<AbstractAttribute *>(&ToAA));
QueriedNonFixAA = true;
8309}

8311void Attributor::identifyDefaultAbstractAttributes(Function &F) {
if (!VisitedFunctions.insert(&F).second)
  return;
if (F.isDeclaration())
  return;

IRPosition FPos = IRPosition::function(F);

// Check for dead BasicBlocks in every function.
// We need dead instruction detection because we do not want to deal with
// broken IR in which SSA rules do not apply.
getOrCreateAAFor<AAIsDead>(FPos);

// Every function might be "will-return".
getOrCreateAAFor<AAWillReturn>(FPos);

// Every function might contain instructions that cause "undefined behavior".
getOrCreateAAFor<AAUndefinedBehavior>(FPos);

// Every function can be nounwind.
getOrCreateAAFor<AANoUnwind>(FPos);

// Every function might be marked "nosync"
getOrCreateAAFor<AANoSync>(FPos);

// Every function might be "no-free".
getOrCreateAAFor<AANoFree>(FPos);

// Every function might be "no-return".
getOrCreateAAFor<AANoReturn>(FPos);

// Every function might be "no-recurse".
getOrCreateAAFor<AANoRecurse>(FPos);

// Every function might be "readnone/readonly/writeonly/...".
getOrCreateAAFor<AAMemoryBehavior>(FPos);

// Every function can be "readnone/argmemonly/inaccessiblememonly/...".
getOrCreateAAFor<AAMemoryLocation>(FPos);

// Every function might be applicable for Heap-To-Stack conversion.
if (EnableHeapToStack)
  getOrCreateAAFor<AAHeapToStack>(FPos);

// Return attributes are only appropriate if the return type is non void.
Type *ReturnType = F.getReturnType();
if (!ReturnType->isVoidTy()) {
  // Argument attribute "returned" --- Create only one per function even
  // though it is an argument attribute.
  getOrCreateAAFor<AAReturnedValues>(FPos);

  IRPosition RetPos = IRPosition::returned(F);

  // Every returned value might be dead.
  getOrCreateAAFor<AAIsDead>(RetPos);

  // Every function might be simplified.
  getOrCreateAAFor<AAValueSimplify>(RetPos);

  if (ReturnType->isPointerTy()) {

    // Every function with pointer return type might be marked align.
    getOrCreateAAFor<AAAlign>(RetPos);

    // Every function with pointer return type might be marked nonnull.
    getOrCreateAAFor<AANonNull>(RetPos);

    // Every function with pointer return type might be marked noalias.
    getOrCreateAAFor<AANoAlias>(RetPos);

    // Every function with pointer return type might be marked
    // dereferenceable.
    getOrCreateAAFor<AADereferenceable>(RetPos);
  }
}

for (Argument &Arg : F.args()) {
  IRPosition ArgPos = IRPosition::argument(Arg);

  // Every argument might be simplified.
  getOrCreateAAFor<AAValueSimplify>(ArgPos);

  // Every argument might be dead.
  getOrCreateAAFor<AAIsDead>(ArgPos);

  if (Arg.getType()->isPointerTy()) {
    // Every argument with pointer type might be marked nonnull.
    getOrCreateAAFor<AANonNull>(ArgPos);

    // Every argument with pointer type might be marked noalias.
    getOrCreateAAFor<AANoAlias>(ArgPos);

    // Every argument with pointer type might be marked dereferenceable.
    getOrCreateAAFor<AADereferenceable>(ArgPos);

    // Every argument with pointer type might be marked align.
    getOrCreateAAFor<AAAlign>(ArgPos);

    // Every argument with pointer type might be marked nocapture.
    getOrCreateAAFor<AANoCapture>(ArgPos);

    // Every argument with pointer type might be marked
    // "readnone/readonly/writeonly/..."
    getOrCreateAAFor<AAMemoryBehavior>(ArgPos);

    // Every argument with pointer type might be marked nofree.
    getOrCreateAAFor<AANoFree>(ArgPos);

    // Every argument with pointer type might be privatizable (or promotable)
    getOrCreateAAFor<AAPrivatizablePtr>(ArgPos);
  }
}

auto CallSitePred = [&](Instruction &I) -> bool {
  CallSite CS(&I);
  IRPosition CSRetPos = IRPosition::callsite_returned(CS);

  // Call sites might be dead if they do not have side effects and no live
  // users. The return value might be dead if there are no live users.
  getOrCreateAAFor<AAIsDead>(CSRetPos);

  if (Function *Callee = CS.getCalledFunction()) {
    // Skip declerations except if annotations on their call sites were
    // explicitly requested.
    if (!AnnotateDeclarationCallSites && Callee->isDeclaration() &&
        !Callee->hasMetadata(LLVMContext::MD_callback))
      return true;

    if (!Callee->getReturnType()->isVoidTy() && !CS->use_empty()) {

      IRPosition CSRetPos = IRPosition::callsite_returned(CS);

      // Call site return integer values might be limited by a constant range.
      if (Callee->getReturnType()->isIntegerTy())
        getOrCreateAAFor<AAValueConstantRange>(CSRetPos);
    }

    for (int i = 0, e = CS.getNumArgOperands(); i < e; i++) {

      IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);

      // Every call site argument might be dead.
      getOrCreateAAFor<AAIsDead>(CSArgPos);

      // Call site argument might be simplified.
      getOrCreateAAFor<AAValueSimplify>(CSArgPos);

      if (!CS.getArgument(i)->getType()->isPointerTy())
        continue;

      // Call site argument attribute "non-null".
      getOrCreateAAFor<AANonNull>(CSArgPos);

      // Call site argument attribute "no-alias".
      getOrCreateAAFor<AANoAlias>(CSArgPos);

      // Call site argument attribute "dereferenceable".
      getOrCreateAAFor<AADereferenceable>(CSArgPos);

      // Call site argument attribute "align".
      getOrCreateAAFor<AAAlign>(CSArgPos);

      // Call site argument attribute
      // "readnone/readonly/writeonly/..."
      getOrCreateAAFor<AAMemoryBehavior>(CSArgPos);

      // Call site argument attribute "nofree".
      getOrCreateAAFor<AANoFree>(CSArgPos);
    }
  }
  return true;
};

auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
bool Success;
Success = checkForAllInstructionsImpl(
    nullptr, OpcodeInstMap, CallSitePred, nullptr, nullptr,
    {(unsigned)Instruction::Invoke, (unsigned)Instruction::CallBr,
     (unsigned)Instruction::Call});
(void)Success;
assert(Success && "Expected the check call to be successful!")((Success && "Expected the check call to be successful!"
) ? static_cast<void> (0) : __assert_fail ("Success && \"Expected the check call to be successful!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8491, __PRETTY_FUNCTION__));

auto LoadStorePred = [&](Instruction &I) -> bool {
  if (isa<LoadInst>(I))
    getOrCreateAAFor<AAAlign>(
        IRPosition::value(*cast<LoadInst>(I).getPointerOperand()));
  else
    getOrCreateAAFor<AAAlign>(
        IRPosition::value(*cast<StoreInst>(I).getPointerOperand()));
  return true;
};
Success = checkForAllInstructionsImpl(
    nullptr, OpcodeInstMap, LoadStorePred, nullptr, nullptr,
    {(unsigned)Instruction::Load, (unsigned)Instruction::Store});
(void)Success;
assert(Success && "Expected the check call to be successful!")((Success && "Expected the check call to be successful!"
) ? static_cast<void> (0) : __assert_fail ("Success && \"Expected the check call to be successful!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8506, __PRETTY_FUNCTION__));
8507}

8509/// Helpers to ease debugging through output streams and print calls.
8510///
8511///{
8512raw_ostream &llvm::operator<<(raw_ostream &OS, ChangeStatus S) {
return OS << (S == ChangeStatus::CHANGED ? "changed" : "unchanged");
8514}

8516raw_ostream &llvm::operator<<(raw_ostream &OS, IRPosition::Kind AP) {
switch (AP) {
case IRPosition::IRP_INVALID:
  return OS << "inv";
case IRPosition::IRP_FLOAT:
  return OS << "flt";
case IRPosition::IRP_RETURNED:
  return OS << "fn_ret";
case IRPosition::IRP_CALL_SITE_RETURNED:
  return OS << "cs_ret";
case IRPosition::IRP_FUNCTION:
  return OS << "fn";
case IRPosition::IRP_CALL_SITE:
  return OS << "cs";
case IRPosition::IRP_ARGUMENT:
  return OS << "arg";
case IRPosition::IRP_CALL_SITE_ARGUMENT:
  return OS << "cs_arg";
}
llvm_unreachable("Unknown attribute position!")::llvm::llvm_unreachable_internal("Unknown attribute position!"
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8535);
8536}

8538raw_ostream &llvm::operator<<(raw_ostream &OS, const IRPosition &Pos) {
const Value &AV = Pos.getAssociatedValue();
return OS << "{" << Pos.getPositionKind() << ":" << AV.getName() << " ["
          << Pos.getAnchorValue().getName() << "@" << Pos.getArgNo() << "]}";
8542}

8544template <typename base_ty, base_ty BestState, base_ty WorstState>
8545raw_ostream &
8546llvm::operator<<(raw_ostream &OS,
               const IntegerStateBase<base_ty, BestState, WorstState> &S) {
return OS << "(" << S.getKnown() << "-" << S.getAssumed() << ")"
          << static_cast<const AbstractState &>(S);
8550}

8552raw_ostream &llvm::operator<<(raw_ostream &OS, const IntegerRangeState &S) {
OS << "range-state(" << S.getBitWidth() << ")<";
S.getKnown().print(OS);
OS << " / ";
S.getAssumed().print(OS);
OS << ">";

return OS << static_cast<const AbstractState &>(S);
8560}

8562raw_ostream &llvm::operator<<(raw_ostream &OS, const AbstractState &S) {
return OS << (!S.isValidState() ? "top" : (S.isAtFixpoint() ? "fix" : ""));
8564}

8566raw_ostream &llvm::operator<<(raw_ostream &OS, const AbstractAttribute &AA) {
AA.print(OS);
return OS;
8569}

8571void AbstractAttribute::print(raw_ostream &OS) const {
OS << "[P: " << getIRPosition() << "][" << getAsStr() << "][S: " << getState()
   << "]";
8574}
8575///}

8577/// ----------------------------------------------------------------------------
8578///                       Pass (Manager) Boilerplate
8579/// ----------------------------------------------------------------------------

8581static bool runAttributorOnFunctions(InformationCache &InfoCache,
                                   SetVector<Function *> &Functions,
                                   AnalysisGetter &AG,
                                   CallGraphUpdater &CGUpdater) {
if (DisableAttributor || Functions.empty())
  return false;

LLVM_DEBUG(dbgs() << "[Attributor] Run on module with " << Functions.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Run on module with "
 << Functions.size() << " functions.\n"; } } while
 (false)
                  << " functions.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Run on module with "
 << Functions.size() << " functions.\n"; } } while
 (false);

// Create an Attributor and initially empty information cache that is filled
// while we identify default attribute opportunities.
Attributor A(Functions, InfoCache, CGUpdater, DepRecInterval);

for (Function *F : Functions)
  A.initializeInformationCache(*F);

for (Function *F : Functions) {
  if (F->hasExactDefinition())
    NumFnWithExactDefinition++;
  else
    NumFnWithoutExactDefinition++;

  // We look at internal functions only on-demand but if any use is not a
  // direct call or outside the current set of analyzed functions, we have to
  // do it eagerly.
  if (F->hasLocalLinkage()) {
    if (llvm::all_of(F->uses(), [&Functions](const Use &U) {
          ImmutableCallSite ICS(U.getUser());
          return ICS && ICS.isCallee(&U) &&
                 Functions.count(const_cast<Function *>(ICS.getCaller()));
        }))
      continue;
  }

  // Populate the Attributor with abstract attribute opportunities in the
  // function and the information cache with IR information.
  A.identifyDefaultAbstractAttributes(*F);
}

ChangeStatus Changed = A.run();
assert(!verifyModule(*Functions.front()->getParent(), &errs()) &&((!verifyModule(*Functions.front()->getParent(), &errs
()) && "Module verification failed!") ? static_cast<
void> (0) : __assert_fail ("!verifyModule(*Functions.front()->getParent(), &errs()) && \"Module verification failed!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8623, __PRETTY_FUNCTION__))
       "Module verification failed!")((!verifyModule(*Functions.front()->getParent(), &errs
()) && "Module verification failed!") ? static_cast<
void> (0) : __assert_fail ("!verifyModule(*Functions.front()->getParent(), &errs()) && \"Module verification failed!\""
, "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8623, __PRETTY_FUNCTION__));
LLVM_DEBUG(dbgs() << "[Attributor] Done with " << Functions.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Done with " <<
 Functions.size() << " functions, result: " << Changed
 << ".\n"; } } while (false)
                  << " functions, result: " << Changed << ".\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("attributor")) { dbgs() << "[Attributor] Done with " <<
 Functions.size() << " functions, result: " << Changed
 << ".\n"; } } while (false);
return Changed == ChangeStatus::CHANGED;
8627}

8629PreservedAnalyses AttributorPass::run(Module &M, ModuleAnalysisManager &AM) {
FunctionAnalysisManager &FAM =
    AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
AnalysisGetter AG(FAM);

SetVector<Function *> Functions;
for (Function &F : M)
  Functions.insert(&F);

CallGraphUpdater CGUpdater;
InformationCache InfoCache(M, AG, /* CGSCC */ nullptr);
if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater)) {
  // FIXME: Think about passes we will preserve and add them here.
  return PreservedAnalyses::none();
}
return PreservedAnalyses::all();
8645}

8647PreservedAnalyses AttributorCGSCCPass::run(LazyCallGraph::SCC &C,
                                         CGSCCAnalysisManager &AM,
                                         LazyCallGraph &CG,
                                         CGSCCUpdateResult &UR) {
FunctionAnalysisManager &FAM =
    AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
AnalysisGetter AG(FAM);

SetVector<Function *> Functions;
for (LazyCallGraph::Node &N : C)
  Functions.insert(&N.getFunction());

if (Functions.empty())
  return PreservedAnalyses::all();

Module &M = *Functions.back()->getParent();
CallGraphUpdater CGUpdater;
CGUpdater.initialize(CG, C, AM, UR);
InformationCache InfoCache(M, AG, /* CGSCC */ &Functions);
if (runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater)) {
  // FIXME: Think about passes we will preserve and add them here.
  return PreservedAnalyses::none();
}
return PreservedAnalyses::all();
8671}

8673namespace {

8675struct AttributorLegacyPass : public ModulePass {
static char ID;

AttributorLegacyPass() : ModulePass(ID) {
  initializeAttributorLegacyPassPass(*PassRegistry::getPassRegistry());
}

bool runOnModule(Module &M) override {
  if (skipModule(M))
    return false;

  AnalysisGetter AG;
  SetVector<Function *> Functions;
  for (Function &F : M)
    Functions.insert(&F);

  CallGraphUpdater CGUpdater;
  InformationCache InfoCache(M, AG, /* CGSCC */ nullptr);
  return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater);
}

void getAnalysisUsage(AnalysisUsage &AU) const override {
  // FIXME: Think about passes we will preserve and add them here.
  AU.addRequired<TargetLibraryInfoWrapperPass>();
}
8700};

8702struct AttributorCGSCCLegacyPass : public CallGraphSCCPass {
CallGraphUpdater CGUpdater;
static char ID;

AttributorCGSCCLegacyPass() : CallGraphSCCPass(ID) {
  initializeAttributorCGSCCLegacyPassPass(*PassRegistry::getPassRegistry());
}

bool runOnSCC(CallGraphSCC &SCC) override {
  if (skipSCC(SCC))
    return false;

  SetVector<Function *> Functions;
  for (CallGraphNode *CGN : SCC)
    if (Function *Fn = CGN->getFunction())
      if (!Fn->isDeclaration())
        Functions.insert(Fn);

  if (Functions.empty())
    return false;

  AnalysisGetter AG;
  CallGraph &CG = const_cast<CallGraph &>(SCC.getCallGraph());
  CGUpdater.initialize(CG, SCC);
  Module &M = *Functions.back()->getParent();
  InformationCache InfoCache(M, AG, /* CGSCC */ &Functions);
  return runAttributorOnFunctions(InfoCache, Functions, AG, CGUpdater);
}

bool doFinalization(CallGraph &CG) override { return CGUpdater.finalize(); }

void getAnalysisUsage(AnalysisUsage &AU) const override {
  // FIXME: Think about passes we will preserve and add them here.
  AU.addRequired<TargetLibraryInfoWrapperPass>();
  CallGraphSCCPass::getAnalysisUsage(AU);
}
8738};

8740} // end anonymous namespace

8742Pass *llvm::createAttributorLegacyPass() { return new AttributorLegacyPass(); }
8743Pass *llvm::createAttributorCGSCCLegacyPass() {
return new AttributorCGSCCLegacyPass();
8745}

8747char AttributorLegacyPass::ID = 0;
8748char AttributorCGSCCLegacyPass::ID = 0;

8750const char AAReturnedValues::ID = 0;
8751const char AANoUnwind::ID = 0;
8752const char AANoSync::ID = 0;
8753const char AANoFree::ID = 0;
8754const char AANonNull::ID = 0;
8755const char AANoRecurse::ID = 0;
8756const char AAWillReturn::ID = 0;
8757const char AAUndefinedBehavior::ID = 0;
8758const char AANoAlias::ID = 0;
8759const char AAReachability::ID = 0;
8760const char AANoReturn::ID = 0;
8761const char AAIsDead::ID = 0;
8762const char AADereferenceable::ID = 0;
8763const char AAAlign::ID = 0;
8764const char AANoCapture::ID = 0;
8765const char AAValueSimplify::ID = 0;
8766const char AAHeapToStack::ID = 0;
8767const char AAPrivatizablePtr::ID = 0;
8768const char AAMemoryBehavior::ID = 0;
8769const char AAMemoryLocation::ID = 0;
8770const char AAValueConstantRange::ID = 0;

8772// Macro magic to create the static generator function for attributes that
8773// follow the naming scheme.

8775#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!", "/build/llvm-toolchain-snapshot-11~++20200309111110+2c36c23f347/llvm/lib/Transforms/IPO/Attributor.cpp"
, 8777);

8779#define SWITCH_PK_CREATE(CLASS, IRP, PK, SUFFIX)                               \
case IRPosition::PK:                                                         \
  AA = new CLASS##SUFFIX(IRP);                                               \
  break;

8784#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;                                                                \
}

8800#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;                                                                \
}

8816#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;                                                                \
}

8832#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;                                                                \
}

8848#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;                                                                \
}

8864CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoUnwind)
8865CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoSync)
8866CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoRecurse)
8867CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAWillReturn)
8868CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoReturn)
8869CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReturnedValues)
8870CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryLocation)

8872CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANonNull)
8873CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoAlias)
8874CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAPrivatizablePtr)
8875CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AADereferenceable)
8876CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAAlign)
8877CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoCapture)
8878CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueConstantRange)

8880CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAValueSimplify)
8881CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAIsDead)
8882CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION(AANoFree)

8884CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAHeapToStack)
8885CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAReachability)
8886CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAUndefinedBehavior)

8888CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION(AAMemoryBehavior)

8890#undef CREATE_FUNCTION_ONLY_ABSTRACT_ATTRIBUTE_FOR_POSITION
8891#undef CREATE_FUNCTION_ABSTRACT_ATTRIBUTE_FOR_POSITION
8892#undef CREATE_NON_RET_ABSTRACT_ATTRIBUTE_FOR_POSITION
8893#undef CREATE_VALUE_ABSTRACT_ATTRIBUTE_FOR_POSITION
8894#undef CREATE_ALL_ABSTRACT_ATTRIBUTE_FOR_POSITION
8895#undef SWITCH_PK_CREATE
8896#undef SWITCH_PK_INV

8898INITIALIZE_PASS_BEGIN(AttributorLegacyPass, "attributor",static void *initializeAttributorLegacyPassPassOnce(PassRegistry
 &Registry) {
                    "Deduce and propagate attributes", false, false)static void *initializeAttributorLegacyPassPassOnce(PassRegistry
 &Registry) {
8900INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
8901INITIALIZE_PASS_END(AttributorLegacyPass, "attributor",PassInfo *PI = new PassInfo( "Deduce and propagate attributes"
, "attributor", &AttributorLegacyPass::ID, PassInfo::NormalCtor_t
(callDefaultCtor<AttributorLegacyPass>), false, false);
 Registry.registerPass(*PI, true); return PI; } static llvm::
once_flag InitializeAttributorLegacyPassPassFlag; void llvm::
initializeAttributorLegacyPassPass(PassRegistry &Registry
) { llvm::call_once(InitializeAttributorLegacyPassPassFlag, initializeAttributorLegacyPassPassOnce
, std::ref(Registry)); }
                  "Deduce and propagate attributes", false, false)PassInfo *PI = new PassInfo( "Deduce and propagate attributes"
, "attributor", &AttributorLegacyPass::ID, PassInfo::NormalCtor_t
(callDefaultCtor<AttributorLegacyPass>), false, false);
 Registry.registerPass(*PI, true); return PI; } static llvm::
once_flag InitializeAttributorLegacyPassPassFlag; void llvm::
initializeAttributorLegacyPassPass(PassRegistry &Registry
) { llvm::call_once(InitializeAttributorLegacyPassPassFlag, initializeAttributorLegacyPassPassOnce
, std::ref(Registry)); }
8903INITIALIZE_PASS_BEGIN(AttributorCGSCCLegacyPass, "attributor-cgscc",static void *initializeAttributorCGSCCLegacyPassPassOnce(PassRegistry
 &Registry) {
                    "Deduce and propagate attributes (CGSCC pass)", false,static void *initializeAttributorCGSCCLegacyPassPassOnce(PassRegistry
 &Registry) {
                    false)static void *initializeAttributorCGSCCLegacyPassPassOnce(PassRegistry
 &Registry) {
8906INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
8907INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)initializeCallGraphWrapperPassPass(Registry);
8908INITIALIZE_PASS_END(AttributorCGSCCLegacyPass, "attributor-cgscc",PassInfo *PI = new PassInfo( "Deduce and propagate attributes (CGSCC pass)"
, "attributor-cgscc", &AttributorCGSCCLegacyPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<AttributorCGSCCLegacyPass>
), false, false); Registry.registerPass(*PI, true); return PI
; } static llvm::once_flag InitializeAttributorCGSCCLegacyPassPassFlag
; void llvm::initializeAttributorCGSCCLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeAttributorCGSCCLegacyPassPassFlag
, initializeAttributorCGSCCLegacyPassPassOnce, std::ref(Registry
)); }
                  "Deduce and propagate attributes (CGSCC pass)", false,PassInfo *PI = new PassInfo( "Deduce and propagate attributes (CGSCC pass)"
, "attributor-cgscc", &AttributorCGSCCLegacyPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<AttributorCGSCCLegacyPass>
), false, false); Registry.registerPass(*PI, true); return PI
; } static llvm::once_flag InitializeAttributorCGSCCLegacyPassPassFlag
; void llvm::initializeAttributorCGSCCLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeAttributorCGSCCLegacyPassPassFlag
, initializeAttributorCGSCCLegacyPassPassOnce, std::ref(Registry
)); }
                  false)PassInfo *PI = new PassInfo( "Deduce and propagate attributes (CGSCC pass)"
, "attributor-cgscc", &AttributorCGSCCLegacyPass::ID, PassInfo
::NormalCtor_t(callDefaultCtor<AttributorCGSCCLegacyPass>
), false, false); Registry.registerPass(*PI, true); return PI
; } static llvm::once_flag InitializeAttributorCGSCCLegacyPassPassFlag
; void llvm::initializeAttributorCGSCCLegacyPassPass(PassRegistry
 &Registry) { llvm::call_once(InitializeAttributorCGSCCLegacyPassPassFlag
, initializeAttributorCGSCCLegacyPassPassOnce, std::ref(Registry
)); }