[Attributor] Deduce memory behavior function attributes

[jdoerfert]

Summary

Deduce the memory behavior, aka "read-none", "read-only", or
"write-only", for functions. This also improves argument deduction
(D59980) because it can rely on the function memory behavior which
is derived.

Impact on the statistics (-stats) for LLVM-TS + Spec2006:

CHANGED: attributor                   NumAttributesManifested                77683 ->      87205 (   +12.258%)
CHANGED: attributor                   NumAttributesValidFixpoint            109073 ->     118598 (    +8.733%)
CHANGED: attributor                   NumFnArgumentReadOnly                  16532 ->      16755 (    +1.349%)
  ADDED: attributor                   NumFnReadNone                            n/a ->       2930
  ADDED: attributor                   NumFnReadOnly                            n/a ->       4380
  ADDED: attributor                   NumFnWriteOnly                           n/a ->       1960
CHANGED: functionattrs                NumReadNone                             3095 ->        165 (   -94.669%)
CHANGED: functionattrs                NumReadNoneArg                           216 ->        144 (   -33.333%)
CHANGED: functionattrs                NumReadOnly                             4363 ->        134 (   -96.929%)
CHANGED: functionattrs                NumReadOnlyArg                          1072 ->        945 (   -11.847%)
CHANGED: functionattrs                NumWriteOnly                            2012 ->         52 (   -97.416%)

Note: The deduction will improve with later patches that introduce new

functionality we can utilize. Also, some are a result of a bug, see:
http://llvm.org/PR41328

[jdoerfert]

Obsolete, D67384.

clang/test/CodeGenOpenCL/as_type.cl

 
 //CHECK: define spir_func i32 addrspace(1)* @int_to_ptr(i32 %[[x:.*]])
 //CHECK: %[[cast:.*]] = inttoptr i32 %[[x]] to i32 addrspace(1)*
 //CHECK: ret i32 addrspace(1)* %[[cast]]
 global int* int_to_ptr(int x) {
   return __builtin_astype(x, global int*);
 }
 
-//CHECK: define spir_func i32 @ptr_to_int(i32* %[[x:.*]])
+//CHECK: define spir_func i32 @ptr_to_int(i32* readnone %[[x:.*]])
 //CHECK: %[[cast:.*]] = ptrtoint i32* %[[x]] to i32
 //CHECK: ret i32 %[[cast]]
 int ptr_to_int(int *x) {
   return __builtin_astype(x, int);
 }
 
-//CHECK: define spir_func <3 x i8> @ptr_to_char3(i32* %[[x:.*]])
+//CHECK: define spir_func <3 x i8> @ptr_to_char3(i32* readnone %[[x:.*]])
 //CHECK: %[[cast1:.*]] = ptrtoint i32* %[[x]] to i32
 //CHECK: %[[cast2:.*]] = bitcast i32 %[[cast1]] to <4 x i8>
 //CHECK: %[[astype:.*]] = shufflevector <4 x i8> %[[cast2]], <4 x i8> undef, <3 x i32> <i32 0, i32 1, i32 2>
 //CHECK: ret <3 x i8> %[[astype]]
 char3 ptr_to_char3(int *x) {
   return  __builtin_astype(x, char3);
 }
 
 //CHECK: define spir_func i32* @char3_to_ptr(<3 x i8> %[[x:.*]])
 //CHECK: %[[astype:.*]] = shufflevector <3 x i8> %[[x]], <3 x i8> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 undef>
 //CHECK: %[[cast1:.*]] = bitcast <4 x i8> %[[astype]] to i32
 //CHECK: %[[cast2:.*]] = inttoptr i32 %[[cast1]] to i32*
 //CHECK: ret i32* %[[cast2]]
 int* char3_to_ptr(char3 x) {
   return __builtin_astype(x, int*);
 }

llvm/include/llvm/Transforms/IPO/Attributor.h

 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 struct AbstractAttribute;
 struct Attributor;
+class AAResults;
 
 class Function;
 class Module;
 
+namespace {
+template <typename T> using GetterTy = std::function<T &(llvm::Function &)>;
+using AAGetterTy = GetterTy<llvm::AAResults>;
+} // anonymous namespace
+
 /// Simple enum class that forces the status to be spelled out explicitly.
 ///
 ///{
 enum class ChangeStatus {
   CHANGED,
   UNCHANGED,
 };
 
 ChangeStatus operator|(ChangeStatus l, ChangeStatus r);
 ChangeStatus operator&(ChangeStatus l, ChangeStatus r);
 ///}
 
 /// The fixpoint analysis framework that drives the attribute deduction.
 struct Attributor {
+  Attributor(AAGetterTy &AARGetter) : AARGetter(AARGetter) {}
   ~Attributor() { DeleteContainerPointers(AllAbstractAttributes); }
 
   /// Run the fixpoint analyses on the call graph SCC \p SCC.
   ///
   /// \Returns CHANGED if the IR was changed, otherwise UNCHANGED.
   ChangeStatus run(SmallVectorImpl<Function *> &SCC);
 
   /// Lookup an abstract attribute of type \p AAType anchored at value \p V and
struct Attributor {
   /// A vector type to hold instructions.
   using InstructionVectorTy = std::vector<Instruction *>;
 
   /// Return the instructions in \p F that may read or write memory.
   InstructionVectorTy &getReadOrWriteInstsForFunction(Function &F) {
     return FunctionReadOrWriteInstsMap[&F];
   }
 
+  /// Return the alias analysis results for \p F.
+  AAResults &getAAR(Function &F) { return AARGetter(F); }
+
 private:
   /// Introduce a new abstract attribute into the fixpoint analysis.
   template <typename AAType> AAType &registerAA(AAType &AA, int ArgNo = -1);
 
   /// Determine opportunities to derive attributes in \p F and create abstract
   /// attribute objects for them.
   void identifyAbstractAttributes(Function &F);
 
private:
 
   /// A nested map to lookup abstract attributes based on the anchored value and
   /// an argument positions (or -1) on the outer level, and attribute kinds
   /// (Attribute::AttrKind) on the inner level.
   ///{
   using KindToAbstractAttributeMap = DenseMap<unsigned, AbstractAttribute *>;
   DenseMap<std::pair<const Value *, int>, KindToAbstractAttributeMap> AAMap;
   ///}
+
+  /// Closure to get alias analysis results for a function.
+  AAGetterTy &AARGetter;
 };
 
 /// ----------------------------------------------------------------------------
 ///                Abstract State & Abstract Attribute Interface
 /// ----------------------------------------------------------------------------
 
 /// An interface for the internal state of an abstract attribute.
 struct AbstractState {

llvm/lib/Transforms/IPO/Attributor.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/Attributor.h"
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/InstIterator.h"

 
 STATISTIC(NumFnArgumentReadNone,
           "Number of function arguments marked read-none");
 STATISTIC(NumFnArgumentReadOnly,
           "Number of function arguments marked read-only");
 STATISTIC(NumFnArgumentWriteOnly,
           "Number of function arguments marked write-only");
 
+STATISTIC(NumFnReadNone, "Number of functions marked read-none");
+STATISTIC(NumFnReadOnly, "Number of functions marked read-only");
+STATISTIC(NumFnWriteOnly, "Number of functions marked write-only");
+
 // TODO: Determine a good default value.
 //
 // In the LLVM-TS and SPEC2006, 32 seems to not induce compile time overheads
 // (when run with the first 5 abstract attributes). The results also indicate
 // that we never reach 32 iterations but always find a fixpoint sooner.
 //
 // This will become more evolved once we perform two interleaved fixpoint
 // iterations: bottom-up and top-down.
case Attribute::NoCapture:
     return;
   case Attribute::NoReturn:
     NumFnNoReturn++;
     return;
   case Attribute::NoRecurse:
     NumFnNoRecurse++;
     return;
   case Attribute::ReadNone:
-    NumFnArgumentReadNone++;
+    MP == AbstractAttribute::MP_ARGUMENT ? NumFnArgumentReadNone++
+                                         : NumFnReadNone++;
     return;
   case Attribute::ReadOnly:
-    NumFnArgumentReadOnly++;
+    MP == AbstractAttribute::MP_ARGUMENT ? NumFnArgumentReadOnly++
+                                         : NumFnReadOnly++;
     return;
   case Attribute::WriteOnly:
-    NumFnArgumentWriteOnly++;
+    MP == AbstractAttribute::MP_ARGUMENT ? NumFnArgumentWriteOnly++
+                                         : NumFnWriteOnly++;
     return;
   default:
     return;
   }
 }
 
 template <typename StateTy>
 using followValueCB_t = std::function<bool(Value *, StateTy &State)>;

 /// ----------------------------------------------------------------------------
 
 /// A class to hold the state of for memory behaviour attributes.
 ///
 /// The state is encoded in the bits of the "char" variables known and assumed
 /// as defined by the encoding bits.
 struct AAMemoryBehaviorImpl : public AAMemoryBehavior, IntegerState {
 
-  AAMemoryBehaviorImpl(Value &V)
-      : AAMemoryBehavior(V), IntegerState(BEST_STATE) {
+  AAMemoryBehaviorImpl(Value &V, AAResults &AAR)
+      : AAMemoryBehavior(V), IntegerState(BEST_STATE), AAR(AAR) {
     assert(getAssumed() == BEST_STATE && "Expected optimistic initialization!");
   }
 
   /// State encoding bits. A set bit in the state means the property holds.
   /// BEST_STATE is the best possible state, 0 the worst possible state.
   enum {
     NO_READS = 1 << 0,
     NO_WRITES = 1 << 1,
const std::string getAsStr() const override {
     else
       S = "may-read/write";
 
     return S;
   }
 
   /// Return the memory behavior information of \p V encoded in the IR.
   static void getKnownStateFromValue(const Value &V, IntegerState &State,
-                                     bool ValueOnly);
+                                     bool ValueOnly, AAResults *AAR = nullptr);
 
   /// See AbstractAttribute::getDeducedAttributes(Attributor &A).
   virtual void
   getDeducedAttributes(SmallVectorImpl<Attribute> &Attrs) const override;
 
   /// See AbstractAttribute::getState()
   ///{
   AbstractState &getState() override { return *this; }
   const AbstractState &getState() const override { return *this; }
   ///}
+
+protected:
+  /// The alias analysis results for the associated function.
+  AAResults &AAR;
 };
 
 void AAMemoryBehaviorImpl::getKnownStateFromValue(const Value &V,
                                                   IntegerState &State,
-                                                  bool ValueOnly) {
-
+                                                  bool ValueOnly,
+                                                  AAResults *AAR) {
   if (const Argument *Arg = dyn_cast<Argument>(&V)) {
     if (Arg->hasAttribute(Attribute::ReadNone))
       State.addKnownBits(NO_ACCESSES);
     else if (Arg->hasAttribute(Attribute::ReadOnly))
       State.addKnownBits(NO_WRITES);
     else if (Arg->hasAttribute(Attribute::WriteOnly))
       State.addKnownBits(NO_READS);
     if (!ValueOnly)
-      getKnownStateFromValue(*Arg->getParent(), State, ValueOnly);
+      getKnownStateFromValue(*Arg->getParent(), State, ValueOnly, AAR);
   } else if (const Function *Fn = dyn_cast<Function>(&V)) {
+    if (AAR) {
+      auto ModRef = AAR->getModRefBehavior(Fn);
+      if (AAResults::onlyReadsMemory(ModRef))
+        State.addKnownBits(NO_WRITES);
+      if (AAResults::doesNotReadMemory(ModRef))
+        State.addKnownBits(NO_READS);
+    } else {
       if (Fn->hasFnAttribute(Attribute::ReadNone))
         State.addKnownBits(NO_ACCESSES);
       else if (Fn->hasFnAttribute(Attribute::ReadOnly))
         State.addKnownBits(NO_WRITES);
       else if (Fn->hasFnAttribute(Attribute::WriteOnly))
         State.addKnownBits(NO_READS);
     }
   }
+}
 
 void AAMemoryBehaviorImpl::getDeducedAttributes(
     SmallVectorImpl<Attribute> &Attrs) const {
   LLVMContext &Ctx = getAnchoredValue().getContext();
   assert(Attrs.size() == 0);
-  if (isAssumedReadNone())
+  if (isAssumedReadNone()) {
     Attrs.push_back(Attribute::get(Ctx, Attribute::ReadNone));
-  else if (isAssumedReadOnly())
+    return;
+  }
+
+  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);
 }
 
+/// An AA to represent the memory behavior function attributes.
+struct AAMemoryBehaviorFunction final : public AAMemoryBehaviorImpl {
+
+  /// See AAMemoryBehaviorImpl::AAMemoryBehaviorImpl(...).
+  AAMemoryBehaviorFunction(Function &F, AAResults &AAR)
+      : AAMemoryBehaviorImpl(F, AAR) {}
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    Function &F = cast<Function>(getAnchoredValue());
+    getKnownStateFromValue(F, *this, /* ValueOnly */ false, &AAR);
+  }
+
+  /// See AbstractAttribute::updateImpl(Attributor &A).
+  virtual ChangeStatus updateImpl(Attributor &A) override;
+
+  /// See AbstractAttribute::manifest(Attributor &A).
+  virtual ChangeStatus manifest(Attributor &A) override;
+
+  /// See AbstractAttribute::getManifestPosition().
+  virtual ManifestPosition getManifestPosition() const override {
+    return MP_FUNCTION;
+  }
+};
+
+ChangeStatus AAMemoryBehaviorFunction::updateImpl(Attributor &A) {
+
+  // The current assumed state used to determine a change.
+  auto AssumedState = getAssumed();
+
+  Function &F = cast<Function>(getAnchoredValue());
+  auto &ReadOrWriteInsts = A.getReadOrWriteInstsForFunction(F);
+
+  for (const Instruction *I : ReadOrWriteInsts) {
+    assert(I->mayReadOrWriteMemory());
+
+    // 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.
+    auto *MemBehaviorAA = A.getAAFor<AAMemoryBehaviorImpl>(*this, *I);
+    if (MemBehaviorAA && MemBehaviorAA->getState().isValidState()) {
+      intersectAssumedBits(MemBehaviorAA->getAssumed());
+      continue;
+    }
+
+    // Remove access kind modifiers if necessary.
+    if (I->mayReadFromMemory())
+      removeAssumedBits(NO_READS);
+    if (I->mayWriteToMemory())
+      removeAssumedBits(NO_WRITES);
+  }
+
+  return (AssumedState != getAssumed()) ? ChangeStatus::CHANGED
+                                        : ChangeStatus::UNCHANGED;
+}
+
+ChangeStatus AAMemoryBehaviorFunction::manifest(Attributor &A) {
+  Function &F = cast<Function>(getAnchoredValue());
+
+  // Check if we would improve the existing attributes first
+  IntegerState ExistingState;
+  getKnownStateFromValue(F, ExistingState, /* ValueOnly */ true,
+                         /* AAR */ nullptr);
+  if (ExistingState.isKnown(getAssumed()))
+    return ChangeStatus::UNCHANGED;
+
+  // Remove existing attributes as they not always mix well with derived ones.
+  F.removeFnAttr(Attribute::ReadNone);
+  F.removeFnAttr(Attribute::ReadOnly);
+  F.removeFnAttr(Attribute::WriteOnly);
+  if (isAssumedReadNone()) {
+    F.removeFnAttr(Attribute::ArgMemOnly);
+    F.removeFnAttr(Attribute::InaccessibleMemOnly);
+    F.removeFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
+  }
+  return AbstractAttribute::manifest(A);
+}
+
 /// An AA to represent the memory behavior argument attributes.
 struct AAMemoryBehaviorArgument final : public AAMemoryBehaviorImpl {
 
   /// See AAMemoryBehaviorImpl::AAMemoryBehaviorImpl(...).
-  AAMemoryBehaviorArgument(Argument &Arg) : AAMemoryBehaviorImpl(Arg) {}
+  AAMemoryBehaviorArgument(Argument &Arg, AAResults &AAR)
+      : AAMemoryBehaviorImpl(Arg, AAR) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     Argument &Arg = cast<Argument>(getAnchoredValue());
 
     if (Arg.getNumUses() == 0)
       addKnownBits(NO_ACCESSES);
     else
-      getKnownStateFromValue(Arg, *this, /* ValueOnly */ false);
+      getKnownStateFromValue(Arg, *this, /* ValueOnly */ false, &AAR);
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   virtual ChangeStatus updateImpl(Attributor &A) override;
 
   /// See AbstractAttribute::getManifestPosition().
   virtual ManifestPosition getManifestPosition() const override {
     return MP_ARGUMENT;
private:
   SmallPtrSet<const Use *, 32> VisitedUses;
 };
 
 ChangeStatus AAMemoryBehaviorArgument::manifest(Attributor &A) {
   Argument &Arg = cast<Argument>(getAnchoredValue());
 
   // Check if we would improve the existing attributes first.
   IntegerState ExistingState;
-  getKnownStateFromValue(Arg, ExistingState,
-                         /* value only */ true);
+  getKnownStateFromValue(Arg, ExistingState, /* ValueOnly */ true,
+                         /* AAR */ nullptr);
   if (ExistingState.isKnown(getAssumed()))
     return ChangeStatus::UNCHANGED;
 
   // Remove existing attributes as they not always mix well with derived ones.
   Arg.removeAttr(Attribute::ReadNone);
   Arg.removeAttr(Attribute::ReadOnly);
   Arg.removeAttr(Attribute::WriteOnly);
   return AbstractAttribute::manifest(A);
bool AAMemoryBehaviorArgument::followUseIn(Attributor &A, const Use *U,
   // By default we follow all uses assuming UserI might leak information on U.
   return true;
 }
 
 void AAMemoryBehaviorArgument::analyzeUseIn(Attributor &A, const Use *U,
                                             const Instruction *UserI) {
   assert(UserI->mayReadOrWriteMemory());
 
+  auto IsConstMem = [&](MemoryLocation Loc) {
+    return AAR.pointsToConstantMemory(Loc, /*OrLocal=*/false);
+  };
+
   switch (UserI->getOpcode()) {
+  case Instruction::VAArg:
+    // Ignore vaargs on local memory.
+    if (IsConstMem(MemoryLocation::get(cast<VAArgInst>(UserI))))
+      return;
+    break;
   case Instruction::Load:
     // Loads cause the NO_READS property to disappear.
+    if (!IsConstMem(MemoryLocation::get(cast<LoadInst>(UserI))))
       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())
+      if (!IsConstMem(MemoryLocation::get(cast<StoreInst>(UserI))))
         removeAssumedBits(NO_WRITES);
     return;
 
   case Instruction::Call:
   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)) {
       indicateFixpoint(/* Optimistic */ false);
       return;
     }
 
+    // FIXME: This should not be neccessary anymore once we have call site
+    //        memory behavior attributes.
+    FunctionModRefBehavior MRB = AAR.getModRefBehavior(cast<CallBase>(UserI));
+    if (MRB == FMRB_DoesNotAccessMemory)
+      return;
+
     if (ICS.isCallee(U))
       break;
 
     // Adjust the possible access behavior based on the information on the
     // argument.
     unsigned ArgNo = ICS.getArgumentNo(U);
     auto *ArgMemAccBehavior = A.getAAFor<AAMemoryBehaviorArgument>(
         *this, *ICS.getCalledValue(), ArgNo);
     if (ArgMemAccBehavior && ArgMemAccBehavior->getState().isValidState()) {
       // "assumed" has at most the same bits as the ArgMemAccBehavior assumed
       // and at least "known".
       intersectAssumedBits(ArgMemAccBehavior->getAssumed());
       return;
     }
 
     if (const Function *Callee = ICS.getCalledFunction()) {
       if (Callee->arg_size() > ArgNo) {
         // "assumed" has at most the same bits known to hold for the argument
         // and at least "known".
         const Argument &CalleeArg = *(Callee->arg_begin() + ArgNo);
         IntegerState ExistingState;
         getKnownStateFromValue(CalleeArg, ExistingState,
-                               /* value only */ false);
+                               /* value only */ false, &AAR);
         intersectAssumedBits(ExistingState.getKnown());
         return;
       }
     }
     break;
   }
   };
 
AAType &Attributor::registerAA(AAType &AA, int ArgNo) {
   if (auto *Arg = dyn_cast<Argument>(&AnchoredVal))
     ArgNo = Arg->getArgNo();
   AAMap[{&AnchoredVal, ArgNo}][AAType::ID] = &AA;
   AllAbstractAttributes.push_back(&AA);
   return AA;
 }
 
 void Attributor::identifyAbstractAttributes(Function &F) {
+  AAResults &AAR = getAAR(F);
+
   // 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.
     registerAA(*new AAReturnedValuesImpl(F));
   }
 
   // Every function might be "no-recurse".
   registerAA(*new AANoRecurseFunction(F));
 
   // Every function might be "no-return".
   registerAA(*new AANoReturnFunction(F));
 
+  // Every function might be readnone/readonly/writeonly
+  registerAA(*new AAMemoryBehaviorFunction(F, AAR));
+
   // For each argument we check if we can derive attributes.
   for (Argument &Arg : F.args()) {
 
     // So far only pointer arguments are interesting. However, "returned"
     // is also derived but as a "function return attribute" (see above).
     if (Arg.getType()->isPointerTy()) {
       registerAA(*new AANoCaptureArgument(Arg));
-      registerAA(*new AAMemoryBehaviorArgument(Arg));
+      registerAA(*new AAMemoryBehaviorArgument(Arg, AAR));
     }
   }
 
   // Walk all instructions to find more attribute opportunities and also
   // interesting instructions that might be querried by abstract attributes
   // during their initialziation or update.
   auto &ReadOrWriteInsts = FunctionReadOrWriteInstsMap[&F];
   auto &InstOpcodeMap = FuncInstOpcodeMap[&F];

 }
 ///}
 
 /// ----------------------------------------------------------------------------
 ///                       Pass (Manager) Boilerplate
 /// ----------------------------------------------------------------------------
 
 PreservedAnalyses AttributorPass::run(LazyCallGraph::SCC &C,
-                                      CGSCCAnalysisManager &, LazyCallGraph &,
-                                      CGSCCUpdateResult &) {
+                                      CGSCCAnalysisManager &AM,
+                                      LazyCallGraph &CG, CGSCCUpdateResult &) {
 
   SmallVector<Function *, 16> SCCFunctions;
   for (LazyCallGraph::Node &N : C) {
     Function &Fn = N.getFunction();
     if (!Fn.isDeclaration())
       SCCFunctions.push_back(&Fn);
   }
 
-  Attributor A;
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
+
+  // We pass a lambda into functions to wire them up to the analysis manager
+  // for getting function analyses.
+  std::function<AAResults &(Function &)> AARGetter =
+      [&](Function &F) -> AAResults & { return FAM.getResult<AAManager>(F); };
+  Attributor A(AARGetter);
   if (A.run(SCCFunctions) == ChangeStatus::CHANGED)
     return PreservedAnalyses::none();
 
   return PreservedAnalyses::all();
 }
 
 namespace {
 
if (skipSCC(SCC))
       return false;
 
     SmallVector<Function *, 16> SCCFunctions;
     for (CallGraphNode *I : SCC)
       if (Function *Fn = I->getFunction())
         if (!Fn->isDeclaration())
           SCCFunctions.push_back(Fn);
 
-    Attributor A;
+    LegacyAARGetter LAARGetter(*this);
+    std::function<AAResults &(Function &)> AARGetter =
+        [&](Function &F) -> AAResults & { return LAARGetter(F); };
+
+    Attributor A(AARGetter);
     return A.run(SCCFunctions) == ChangeStatus::CHANGED;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesCFG();
+    AU.addRequired<AssumptionCacheTracker>();
+    getAAResultsAnalysisUsage(AU);
     AU.addPreserved<CallGraphWrapperPass>();
     CallGraphSCCPass::getAnalysisUsage(AU);
   }
 };
 
 } // end anonymous namespace
 
 Pass *llvm::createAttributorLegacyPass() { return new AttributorLegacyPass(); }
 
 char AttributorLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(AttributorLegacyPass, "attributor",
                       "Deduce and propagate attributes", false, false)
 INITIALIZE_PASS_END(AttributorLegacyPass, "attributor",
                     "Deduce and propagate attributes", false, false)
 

llvm/test/Transforms/FunctionAttrs/arg_returned.ll

 ; double select_and_phi(double b) {
 ;   double x = b;
 ;   if (b > 0)
 ;     x = b;
 ;   return b == 0? b : x;
 ; }
 ;
 ; FNATTR:     define dso_local double @select_and_phi(double %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double @select_and_phi(double returned %b) [[NoInlineNoRecurseNoUnwindUwtable:#[0-9]*]]
+; ATTRIBUTOR: define dso_local double @select_and_phi(double returned %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double @select_and_phi(double %b) #0 {
 entry:
   %cmp = fcmp ogt double %b, 0.000000e+00
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry
   br label %if.end

 ; double recursion_select_and_phi(int a, double b) {
 ;   double x = b;
 ;   if (a-- > 0)
 ;     x = recursion_select_and_phi(a, b);
 ;   return b == 0? b : x;
 ; }
 ;
 ; FNATTR:     define dso_local double @recursion_select_and_phi(i32 %a, double %b) [[NoInlineNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double @recursion_select_and_phi(i32 %a, double returned %b) [[NoInlineNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double @recursion_select_and_phi(i32 %a, double returned %b) [[NoInlineNoUnwindReadnoneUwtable]]
 ;
 define dso_local double @recursion_select_and_phi(i32 %a, double %b) #0 {
 entry:
   %dec = add nsw i32 %a, -1
   %cmp = icmp sgt i32 %a, 0
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:                                          ; preds = %entry

 
 ; TEST 8
 ;
 ; double* bitcast(int* b) {
 ;   return (double*)b;
 ; }
 ;
 ; FNATTR:     define dso_local double* @bitcast(i32* readnone %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double* @bitcast(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double* @bitcast(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ; BOTH:       define dso_local double* @bitcast(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double* @bitcast(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   ret double* %bc0
 }
 
 
 ; TEST 9
 ;
 ; double* bitcasts_select_and_phi(int* b) {
 ;   double* x = b;
 ;   if (b == 0)
 ;     x = b;
 ;   return b != 0 ? b : x;
 ; }
 ;
 ; FNATTR:     define dso_local double* @bitcasts_select_and_phi(i32* readnone %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double* @bitcasts_select_and_phi(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double* @bitcasts_select_and_phi(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ; BOTH:       define dso_local double* @bitcasts_select_and_phi(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double* @bitcasts_select_and_phi(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %if.then, label %if.end
 

 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; FNATTR:     define dso_local double* @ret_arg_arg_undef(i32* readnone %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double* @ret_arg_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double* @ret_arg_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ; BOTH:       define dso_local double* @ret_arg_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double* @ret_arg_arg_undef(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_arg0, label %if.end
 

 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; FNATTR:     define dso_local double* @ret_undef_arg_arg(i32* readnone %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double* @ret_undef_arg_arg(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double* @ret_undef_arg_arg(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ; BOTH:       define dso_local double* @ret_undef_arg_arg(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double* @ret_undef_arg_arg(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_undef, label %if.end
 

 ;   if (b == 0)
 ;     /* return undef */
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
 ; FNATTR:     define dso_local double* @ret_undef_arg_undef(i32* readnone %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
-; ATTRIBUTOR: define dso_local double* @ret_undef_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindUwtable]]
+; ATTRIBUTOR: define dso_local double* @ret_undef_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ; BOTH:       define dso_local double* @ret_undef_arg_undef(i32* readnone returned "no-capture-maybe-returned" %b) [[NoInlineNoRecurseNoUnwindReadnoneUwtable]]
 ;
 define dso_local double* @ret_undef_arg_undef(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   %cmp = icmp eq double* %bc0, null
   br i1 %cmp, label %ret_undef0, label %if.end