[Attributor] Deduce "returned" argument attribute

[jdoerfert]

Summary

Deduce the "returned" argument attribute by collecting all potentially
returned values.

Note: Not only the unique return value, if any, can be used by
subsequent attributes but also the set of all potentially returned
values as well as the mapping from returned values to return
instructions that they originate from.

Change in statistics (-stats) for LLVM-TS + Spec2006, totaling ~19% more "returned" arguments.

  ADDED: attributor                   NumAttributesManifested                  n/a ->        637
  ADDED: attributor                   NumAttributesValidFixpoint               n/a ->      25545
  ADDED: attributor                   NumFnArgumentReturned                    n/a ->        637
  ADDED: attributor                   NumFnKnownReturns                        n/a ->      25545
  ADDED: attributor                   NumFnUniqueReturned                      n/a ->      14118
CHANGED: deadargelim                  NumRetValsEliminated                     470 ->        449 (    -4.468%)
REMOVED: functionattrs                NumReturned                              535 ->        n/a
CHANGED: indvars                      NumElimIdentity                          138 ->        164 (   +18.841%)

[jdoerfert]

Fix the last bug exposed by llvm-test-suite & SPEC2006

[jdoerfert]

Minor updates

[xbolva00]

llvm/lib/Transforms/IPO/Attributor.cpp

358

Maybe enum here ?
So you could call indicateFixpoint(Fixpoint::optimistic) ?

Or maybe even better, indicateOptimisticFixpoint()?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

358

Good points. I'll probably go with the second, most explicit, solution. I'll update (all) the source files soon.

[jdoerfert]

Minor changes

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

415

This should probably call llvm_unreachable with a message instead of returning -1.

[jdoerfert]

Rebase on newest Attributor design

[jdoerfert]

Update to new Attributor design and more tests

[jdoerfert]

Cleanup leftover arguments

[nicholas]

CHANGED: build-libcalls NumNoUnwind 4526 -> 3382 ( -25.276%)

Why did the number of nounwinds drop?

llvm/lib/Transforms/IPO/Attributor.cpp

115

Typo in "gerneric", should be "generic".

127

LLVM generally has a preference for not recursing like this, it means that the amount of stack space we need depends on the input IR and it's hard for a user of llvm as a library to foresee or handle an out of stack condition.

Common practice is to structure it as a loop like:

SmallVector<Value *, 32> Worklist;
SmallSet<Value *> Visited;
Worklist.push_back(V);
do {
  Value *V = Worklist.pop_back_val();
  if (!Visited.insert(V).second)
    continue;
  V = V->stripPointerCasts();
  // ...
} while (!Worklist.empty());

Also, consider having some sort of loop iteration limit as a safety value against runaway compile time.

133

Offhand, I think placing this after the CS check is incorrect. I haven't tried it out, but I expect the testcase that triggers infinite loop to look something like this:

define i32 @test(i32 %A) {
entry:
  ret i32 0
unreachableblock:
  %B = call i32 @test(i32 %B)
  ret i32 %B
}

which should pass the verifier and trigger an infinite loop if you call gernericValueTraversal on %B.

Also, if you really need a callback and not just a SmallSet named Visited, I'd suggest calling the callback immediately before adding each value to the Worklist (or as written not, call it on each value before recursing).

[jdoerfert]

Thanks for looking at this. I'll update the patch asap

In D59919#1535643, @nicholas wrote:

CHANGED: build-libcalls NumNoUnwind 4526 -> 3382 ( -25.276%)

Why did the number of nounwinds drop?

I haven't looked into this but my initial guess would be that we removed code due to the "returned" information for which we then did not add nounwind. To be honest, I don't see how else it should have happened.

llvm/lib/Transforms/IPO/Attributor.cpp

127

Though there is not really stack space needed I see your point. I'll rewrite the recursion.

133

The test cases above passes just fine but again I see your point. I will add that one and the one below which breaks as you predicted. I'll rewrite the whole traversal.

declare i32 @test2(i32 returned %A);
define i32 @test(i32 %A) {
entry:
  ret i32 %A
unreachableblock:
  %B = call i32 @test2(i32 %B)
  ret i32 %B
}

[jdoerfert]

Use worklist instead of recursion, add tests

[jdoerfert]

Fix Typo

[jdoerfert]

In D59919#1535643, @nicholas wrote:

CHANGED: build-libcalls NumNoUnwind 4526 -> 3382 ( -25.276%)

Why did the number of nounwinds drop?

I rerun the experiment with and without this commit. The numbers are the same as before except that there is no difference in NumNoUnwind. I don't know if I used a different baseline or if there was another problem (e.g., concurrency related) but I don't think this patch does affect the NumNoUnwind number at all.

Btw. I only report statistics that changed more than 1% as there seem to be some minimal variations all the time.

[jdoerfert]

Update tests

[jdoerfert]

Simplify the interface

[jdoerfert]

Rebase (tests will be run later today)

[jdoerfert]

ninja check-all passed

[hfinkel]

LGTM

clang/test/CodeGenOpenCL/as_type.cl

3

I recommend leaving the Clang tests along. Clang tests that run the optimizer don't follow out best practices and, while end-to-end testing is valuable, I don't think that we should encourage general optimizer testing here.

clang/test/CodeGenOpenCL/as_type.cl

 // RUN: %clang_cc1 %s -emit-llvm -triple spir-unknown-unknown -o - | FileCheck %s
 
 typedef __attribute__(( ext_vector_type(3) )) char char3;
 typedef __attribute__(( ext_vector_type(4) )) char char4;
 typedef __attribute__(( ext_vector_type(16) )) char char16;
 typedef __attribute__(( ext_vector_type(3) )) int int3;
 
 //CHECK: define spir_func <3 x i8> @f1(<4 x i8> %[[x:.*]])
 //CHECK: %[[astype:.*]] = shufflevector <4 x i8> %[[x]], <4 x i8> undef, <3 x i32> <i32 0, i32 1, i32 2>
 //CHECK: ret <3 x i8> %[[astype]]
 char3 f1(char4 x) {

 //CHECK: define spir_func <3 x i32> @f8(<16 x i8> %[[x:.*]])
 //CHECK: %[[cast:.*]] = bitcast <16 x i8> %[[x]] to <4 x i32>
 //CHECK: %[[astype:.*]] = shufflevector <4 x i32> %[[cast]], <4 x i32> undef, <3 x i32> <i32 0, i32 1, i32 2>
 //CHECK: ret <3 x i32> %[[astype]]
 int3 f8(char16 x) {
   return __builtin_astype(x, int3);
 }
 
-//CHECK: define spir_func i32 addrspace(1)* @addr_cast(i32* readnone %[[x:.*]])
+//CHECK: define spir_func i32 addrspace(1)* @addr_cast(i32* readnone returned %[[x:.*]])
 //CHECK: %[[cast:.*]] = addrspacecast i32* %[[x]] to i32 addrspace(1)*
 //CHECK: ret i32 addrspace(1)* %[[cast]]
 global int* addr_cast(int *x) {
   return __builtin_astype(x, global int*);
 }
 
 //CHECK: define spir_func i32 addrspace(1)* @int_to_ptr(i32 %[[x:.*]])
 //CHECK: %[[cast:.*]] = inttoptr i32 %[[x]] to i32 addrspace(1)*

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

 };
 
 Pass *createAttributorLegacyPass();
 
 /// ----------------------------------------------------------------------------
 ///                       Abstract Attribute Classes
 /// ----------------------------------------------------------------------------
 
+/// An abstract attribute for the returned values of a function.
+struct AAReturnedValues : public AbstractAttribute {
+
+  /// See AbstractAttribute::AbstractAttribute(...).
+  AAReturnedValues(Function &F, InformationCache &InfoCache)
+      : AbstractAttribute(F, InfoCache) {}
+
+  /// Return the number of potential return values, -1 if unknown.
+  virtual size_t getNumReturnValues() const = 0;
+
+  /// Return true if \p V maybe returned by the underlying function.
+  ///
+  /// This method will return false until it cannot justify that answer anymore.
+  virtual bool maybeReturned(Value *V) const = 0;
+
+  /// See AbstractAttribute::getAttrKind()
+  virtual Attribute::AttrKind getAttrKind() const override { return ID; }
+
+  /// The identifier used by the Attributor for this class of attributes.
+  static constexpr Attribute::AttrKind ID = Attribute::Returned;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_FUNCTIONATTRS_H

llvm/lib/Transforms/IPO/Attributor.cpp

STATISTIC(NumFnWithoutExactDefinition,
           "Number of function without exact definitions");
 STATISTIC(NumAttributesTimedOut,
           "Number of abstract attributes timed out before fixpoint");
 STATISTIC(NumAttributesValidFixpoint,
           "Number of abstract attributes in a valid fixpoint state");
 STATISTIC(NumAttributesManifested,
           "Number of abstract attributes manifested in IR");
 
+STATISTIC(NumFnUniqueReturned, "Number of function with unique return");
+STATISTIC(NumFnKnownReturns, "Number of function with known return values");
+STATISTIC(NumFnArgumentReturned,
+          "Number of function arguments marked returned");
+
 // 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.

 /// Helper to adjust the statistics.
 static void bookkeeping(AbstractAttribute::ManifestPosition MP,
                         const Attribute &Attr) {
   if (!AreStatisticsEnabled())
     return;
 
   if (!Attr.isEnumAttribute())
     return;
-  //switch (Attr.getKindAsEnum()) {
-  //default:
-  //  return;
-  //}
+  switch (Attr.getKindAsEnum()) {
+  case Attribute::Returned:
+    NumFnArgumentReturned++;
+    return;
+  default:
+    return;
+  }
+}
+
+template <typename StateTy>
+using followValueCB_t = std::function<bool(Value *, StateTy &State)>;
+template <typename StateTy>
+using visitValueCB_t = std::function<void(Value *, StateTy &State)>;
+
+/// Recursively visit all values that might become \p V at some point. This will
+/// be done by looking through cast instructions, selects, phis, and calls with
+/// the "returned" attribute. The callback \p FollowValueCB is asked before
+/// multiple potential origin values are tracked. If it returns false, the
+/// tracking of the passed value is stopped right away. Once we cannot look
+/// through the value any further, the callback \p VisitValueCB is invoked.
+template <typename StateTy>
+static void gernericValueTraversal(Attributor &A, AbstractAttribute &QueryingAA,
+                                   Value *V, StateTy &State,
+                                   followValueCB_t<StateTy> &FollowValueCB,
+                                   visitValueCB_t<StateTy> &VisitValueCB) {
+  V = V->stripPointerCasts();
+
+  CallSite CS(V);
+  if (CS && CS.getCalledFunction()) {
+    // Explicitly look through calls with a "returned" attribute if we do not
+    // have a pointer as stripPointerCasts only works on them.
+    if (!V->getType()->isPointerTy()) {
+      for (Argument &Arg : CS.getCalledFunction()->args())
+        if (Arg.hasReturnedAttr())
+          return gernericValueTraversal(A, QueryingAA,
+                                        CS.getArgOperand(Arg.getArgNo()), State,
+                                        FollowValueCB, VisitValueCB);
+    }
+  }
+
+  // Check if we should start to follow multiple values. To prevent endless
+  // recursion keep a record of the values we followed!
+  if (!FollowValueCB(V, State))
+    return;
+
+  // Look through select instructions, visit both potential values.
+  if (auto *SI = dyn_cast<SelectInst>(V)) {
+    gernericValueTraversal(A, QueryingAA, SI->getTrueValue(), State,
+                           FollowValueCB, VisitValueCB);
+    gernericValueTraversal(A, QueryingAA, SI->getFalseValue(), State,
+                           FollowValueCB, VisitValueCB);
+    return;
+  }
+
+  // Look through phi nodes, visit all operands.
+  if (auto *PHI = dyn_cast<PHINode>(V)) {
+    for (Value *PHIOp : PHI->operands())
+      gernericValueTraversal(A, QueryingAA, PHIOp, State, FollowValueCB,
+                             VisitValueCB);
+    return;
+  }
+
+  // Once a leaf is reached we inform the user through the callback.
+  VisitValueCB(V, State);
 }
 
 /// Helper to identify the correct offset into an attribute list.
 static unsigned getAttrIndex(AbstractAttribute::ManifestPosition MP,
                              unsigned ArgNo = 0) {
   switch (MP) {
   case AbstractAttribute::MP_ARGUMENT:
   case AbstractAttribute::MP_CALL_SITE_ARGUMENT:
if (isa<Instruction>(V))
     return *cast<Instruction>(V).getFunction();
   llvm_unreachable("No scope for anchored value found!");
 }
 
 const Function &AbstractAttribute::getAnchorScope() const {
   return const_cast<AbstractAttribute *>(this)->getAnchorScope();
 }
 
+/// --------------------- Function Return Values -------------------------------
+
+/// "Attribute" that collects all potential returned values and the return
+/// instructions that they arise from.
+///
+/// If there is a unique returned value R, the manifest method will:
+///   - mark R with the "returned" attribute, if R is an argument.
+class AAReturnedValuesImpl final : public AAReturnedValues, AbstractState {
+
+  /// Mapping of values potentially returned by the associated function to the
+  /// return instructions that might return them.
+  DenseMap<Value *, SmallPtrSet<ReturnInst *, 2>> ReturnedValues;
+
+  /// State flags
+  ///
+  ///{
+  bool IsFixed;
+  bool IsValidState;
+  bool HasOverdefinedReturnedCalls;
+  ///}
+
+  /// Collect values that could become \p V in the set \p Values, each mapped to
+  /// \p ReturnInsts.
+  void collectValuesRecursively(
+      Attributor &A, Value *V, SmallPtrSetImpl<ReturnInst *> &ReturnInsts,
+      DenseMap<Value *, SmallPtrSet<ReturnInst *, 2>> &Values) {
+
+    SmallPtrSet<Value *, 8> Visited;
+    followValueCB_t<bool> FollowValueCB = [&](Value *Val, bool &) {
+      return Visited.insert(Val).second;
+    };
+    visitValueCB_t<bool> VisitValueCB = [&](Value *Val, bool &) {
+      assert(!isa<Instruction>(Val) ||
+             &getAnchorScope() == cast<Instruction>(Val)->getFunction());
+      Values[Val].insert(ReturnInsts.begin(), ReturnInsts.end());
+    };
+
+    bool UnusedBool;
+    gernericValueTraversal(A, *this, V, UnusedBool, FollowValueCB,
+                           VisitValueCB);
+  }
+
+public:
+  /// See AbstractAttribute::AbstractAttribute(...).
+  AAReturnedValuesImpl(Function &F, InformationCache &InfoCache)
+      : AAReturnedValues(F, InfoCache) {
+    // We do not have an associated argument yet.
+    AssociatedVal = nullptr;
+  }
+
+  /// See AbstractAttribute::initialize(...).
+  void initialize(Attributor &A) override {
+    // Reset the state.
+    AssociatedVal = nullptr;
+    IsFixed = false;
+    IsValidState = true;
+    HasOverdefinedReturnedCalls = false;
+    ReturnedValues.clear();
+
+    Function &F = cast<Function>(getAnchoredValue());
+
+    // The map from instruction opcodes to those instructions in the function.
+    auto &OpcodeInstMap = InfoCache.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 no argument was marked as returned we look at all return instructions
+    // and collect potentially returned values.
+    for (Instruction *RI : OpcodeInstMap[Instruction::Ret]) {
+      SmallPtrSet<ReturnInst *, 1> RISet({cast<ReturnInst>(RI)});
+      collectValuesRecursively(A, cast<ReturnInst>(RI)->getReturnValue(), RISet,
+                               ReturnedValues);
+    }
+  }
+
+  /// See AbstractAttribute::manifest(...).
+  virtual ChangeStatus manifest(Attributor &A) override;
+
+  /// See AbstractAttribute::getState(...).
+  virtual AbstractState &getState() override { return *this; }
+
+  /// See AbstractAttribute::getState(...).
+  virtual const AbstractState &getState() const override { return *this; }
+
+  /// See AbstractAttribute::getManifestPosition().
+  virtual ManifestPosition getManifestPosition() const override {
+    return MP_ARGUMENT;
+  }
+
+  /// See AbstractAttribute::maybeReturned(...).
+  virtual bool maybeReturned(Value *V) const override {
+    return (!isValidState() || HasOverdefinedReturnedCalls ||
+            ReturnedValues.count(V));
+  }
+
+  /// See AbstractAttribute::updateImpl(Attributor &A).
+  virtual ChangeStatus updateImpl(Attributor &A) override;
+
+  /// See AAReturnedValues::getNumReturnValues().
+  virtual size_t getNumReturnValues() const override {
+    return isValidState() ? ReturnedValues.size() : -1;
+  }
+
+  /// Iterators to walk through all possibly returned values.
+  ///{
+  using const_iterator = decltype(ReturnedValues)::const_iterator;
+  const_iterator begin() const { return ReturnedValues.begin(); }
+  const_iterator end() const { return ReturnedValues.end(); }
+  ///}
+
+  /// 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 *> getUniqueReturnValue() const;
+
+  /// Pretty print the attribute similar to the IR representation.
+  virtual 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(...).
+  void indicateOptimisticFixpoint() override {
+    IsFixed = true;
+    IsValidState &= true;
+  }
+  void indicatePessimisticFixpoint() override {
+    IsFixed = true;
+    IsValidState = false;
+  }
+};
+
+ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
+  ChangeStatus Changed = ChangeStatus::UNCHANGED;
+
+  // Bookkeeping.
+  assert(isValidState());
+  NumFnKnownReturns++;
+
+  // Check if we have an assumed unique return value that we could manifest.
+  Optional<Value *> UniqueRV = getUniqueReturnValue();
+
+  if (!UniqueRV.hasValue() || !UniqueRV.getValue())
+    return Changed;
+
+  // Bookkeeping.
+  NumFnUniqueReturned++;
+
+  // If the assumed unique return value is an argument, annotate it.
+  if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) {
+    AssociatedVal = UniqueRVArg;
+    Changed = AbstractAttribute::manifest(A) | Changed;
+  }
+
+  return Changed;
+}
+
+const std::string AAReturnedValuesImpl::getAsStr() const {
+  return (isAtFixpoint() ? "returns(#" : "may-return(#") +
+         (isValidState() ? std::to_string(getNumReturnValues()) : "?") + ")";
+}
+
+Optional<Value *> AAReturnedValuesImpl::getUniqueReturnValue() const {
+  Optional<Value *> UniqueRV;
+
+  // Check all returned values but ignore call sites as long as we have not
+  // encountered an overdefined one during an update. If there is a unique value
+  // always returned, 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.
+  for (auto &It : ReturnedValues) {
+    Value *RV = It.first;
+
+    ImmutableCallSite ICS(RV);
+    if (ICS && !HasOverdefinedReturnedCalls)
+      continue;
+
+    // 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())))
+      return Optional<Value *>(nullptr);
+
+    // Do not overwrite a value with an undef.
+    if (UniqueRV.hasValue() && isa<UndefValue>(RV))
+      continue;
+
+    UniqueRV = RV;
+  }
+
+  return UniqueRV;
+}
+
+ChangeStatus AAReturnedValuesImpl::updateImpl(Attributor &A) {
+
+  // Check if we know of any values returned by the associated function,
+  // if not, we are done.
+  if (getNumReturnValues() == 0) {
+    indicateOptimisticFixpoint();
+    return ChangeStatus::UNCHANGED;
+  }
+
+  // Check if any of the returned values is a call site we can refine.
+  decltype(ReturnedValues) AddRVs;
+  bool HasCallSite = false;
+
+  // Look at all returned call sites.
+  for (auto &It : ReturnedValues) {
+    SmallPtrSet<ReturnInst *, 2> &ReturnInsts = It.second;
+    Value *RV = It.first;
+    LLVM_DEBUG(dbgs() << "[AAReturnedValues] Potentially returned value " << *RV
+                      << "\n");
+
+    // Only call sites can change during an update, ignore the rest.
+    CallSite RetCS(RV);
+    if (!RetCS)
+      continue;
+
+    // For now, any call site we see will prevent us from directly fixing the
+    // state. However, if the information on the callees is fixed, the call
+    // sites will be removed and we will fix the information for this state.
+    HasCallSite = true;
+
+    // Try to find a unique assumed return value for the called function.
+    auto *RetCSAA = A.getAAFor<AAReturnedValuesImpl>(*this, *RV);
+    if (!RetCSAA || !RetCSAA->isValidState()) {
+      HasOverdefinedReturnedCalls = true;
+      LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned call site (" << *RV
+                        << ") with " << (RetCSAA ? "invalid" : "no")
+                        << " associated state\n");
+      continue;
+    }
+
+    // Try to find a unique assumed return value for the called function.
+    Optional<Value *> AssumedUniqueRV = RetCSAA->getUniqueReturnValue();
+
+    // If no unique assumed return value was found due to the lack of
+    // candidates, we may need to resolve more calls (through more update
+    // iterations) or the called function will not return. Either way, we simply
+    // stick with the call site as return value. Because there were not multiple
+    // possibilities, we do not treat it as overdefined.
+    if (!AssumedUniqueRV.hasValue())
+      continue;
+
+    // If multiple, non-refinable values were found, there cannot be a unique
+    // return value for the called function. The returned call is overdefined!
+    if (!AssumedUniqueRV.getValue()) {
+      HasOverdefinedReturnedCalls = true;
+      LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned call site has multiple "
+                           "potentially returned values\n");
+      continue;
+    }
+
+    LLVM_DEBUG({
+      bool UniqueRVIsKnown = RetCSAA->isAtFixpoint();
+      dbgs() << "[AAReturnedValues] Returned call site "
+             << (UniqueRVIsKnown ? "known" : "assumed")
+             << " unique return value: " << *AssumedUniqueRV << "\n";
+    });
+
+    // The unique assumed return value.
+    Value *AssumedRetVal = AssumedUniqueRV.getValue();
+
+    // If the unique assumed return value is an argument, lookup the matching
+    // call site operand and recursively collect new returned values.
+    // If it is not an argument, it is just put into the set of returned values
+    // as we would have already looked through casts, phis, and similar values.
+    if (Argument *AssumedRetArg = dyn_cast<Argument>(AssumedRetVal))
+      collectValuesRecursively(A,
+                               RetCS.getArgOperand(AssumedRetArg->getArgNo()),
+                               ReturnInsts, AddRVs);
+    else
+      AddRVs[AssumedRetVal].insert(ReturnInsts.begin(), ReturnInsts.end());
+  }
+
+  ChangeStatus Changed = ChangeStatus::UNCHANGED;
+
+  for (auto &It : AddRVs) {
+    assert(!It.second.empty() && "Entry does not add anything.");
+    auto &ReturnInsts = ReturnedValues[It.first];
+    for (ReturnInst *RI : It.second)
+      if (ReturnInsts.insert(RI).second) {
+        LLVM_DEBUG(dbgs() << "[AAReturnedValues] Add new returned value "
+                          << *It.first << " => " << *RI << "\n");
+        Changed = ChangeStatus::CHANGED;
+      }
+  }
+
+  // If there is no call site in the returned values we are done.
+  if (!HasCallSite) {
+    indicateOptimisticFixpoint();
+    return ChangeStatus::CHANGED;
+  }
+
+  return Changed;
+}
+
 /// ----------------------------------------------------------------------------
 ///                               Attributor
 /// ----------------------------------------------------------------------------
 
 ChangeStatus Attributor::run() {
   // Initialize all abstract attributes.
   for (AbstractAttribute *AA : AllAbstractAttributes)
     AA->initialize(*this);
ChangeStatus Attributor::run() {
 
   return ManifestChange;
 }
 
 void Attributor::identifyDefaultAbstractAttributes(
     Function &F, InformationCache &InfoCache,
     DenseSet</* Attribute::AttrKind */ unsigned> *Whitelist) {
 
+  // 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.
+    if (!Whitelist || Whitelist->count(AAReturnedValues::ID))
+      registerAA(*new AAReturnedValuesImpl(F, InfoCache));
+  }
+
   // Walk all instructions to find more attribute opportunities and also
   // interesting instructions that might be queried by abstract attributes
   // during their initialization or update.
   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:
-    //  break;
-    //}
+    switch (I.getOpcode()) {
+    default:
+      break;
+    case Instruction::Ret: // ReturnInst are interesting for AAReturnedValues.
+      IsInterestingOpcode = true;
+    }
     if (IsInterestingOpcode)
       InstOpcodeMap[I.getOpcode()].push_back(&I);
     if (I.mayReadOrWriteMemory())
       ReadOrWriteInsts.push_back(&I);
   }
 }
 
 /// Helpers to ease debugging through output streams and print calls.

llvm/test/Transforms/FunctionAttrs/arg_nocapture.ll

entry:
   %call13 = call i32* @srec16(i32* %call12)
   %call14 = call i32* @srec16(i32* %call13)
   %call15 = call i32* @srec16(i32* %call14)
   ret i32* %call15
 }
 
 ; TEST SCC with various calls, casts, and comparisons agains NULL
 ;
-; FIXME: returned missing for %a
 ; FIXME: no-capture missing for %a
-; CHECK: define float* @scc_A(i32* readnone %a)
+; CHECK: define float* @scc_A(i32* readnone returned %a)
 ;
-; FIXME: returned missing for %a
 ; FIXME: no-capture missing for %a
-; CHECK: define i64* @scc_B(double* readnone %a)
+; CHECK: define i64* @scc_B(double* readnone returned %a)
 ;
-; FIXME: returned missing for %a
 ; FIXME: readnone missing for %s
 ; FIXME: no-capture missing for %a
-; CHECK: define i8* @scc_C(i16* %a)
+; CHECK: define i8* @scc_C(i16* returned %a)
 ;
 ; float *scc_A(int *a) {
 ;   return (float*)(a ? (int*)scc_A((int*)scc_B((double*)scc_C((short*)a))) : a);
 ; }
 ;
 ; long *scc_B(double *a) {
 ;   return (long*)(a ? scc_C((short*)scc_B((double*)scc_A((int*)a))) : a);
 ; }

llvm/test/Transforms/FunctionAttrs/arg_returned.ll

-; RUN: opt -functionattrs -attributor -attributor-disable=false -S < %s | FileCheck %s
-; RUN: opt -functionattrs -attributor -attributor-disable=false -attributor-verify=true -S < %s | FileCheck %s
+; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefix=FNATTR
+; RUN: opt -attributor -attributor-disable=false -S < %s | FileCheck %s --check-prefix=ATTRIBUTOR
+; RUN: opt -attributor -attributor-disable=false -functionattrs -S < %s | FileCheck %s --check-prefix=BOTH
 ;
 ; Test cases specifically designed for the "returned" argument attribute.
 ; We use FIXME's to indicate problems and missing attributes.
 ;
 
 ; TEST SCC test returning an integer value argument
 ;
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK: define i32 @sink_r0(i32 returned %r)
-;
-; FIXME: returned on %r missing:
-; CHECK: Function Attrs: noinline nounwind readnone uwtable
-; CHECK: define i32 @scc_r1(i32 %a, i32 %r, i32 %b)
-;
-; FIXME: returned on %r missing:
-; CHECK: Function Attrs: noinline nounwind readnone uwtable
-; CHECK: define i32 @scc_r2(i32 %a, i32 %b, i32 %r)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH: define i32 @sink_r0(i32 returned %r)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH: define i32 @scc_r1(i32 %a, i32 returned %r, i32 %b)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH: define i32 @scc_r2(i32 %a, i32 %b, i32 returned %r)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
+;
+; FNATTR: define i32 @sink_r0(i32 returned %r)
+; FNATTR: define i32 @scc_r1(i32 %a, i32 %r, i32 %b)
+; FNATTR: define i32 @scc_r2(i32 %a, i32 %b, i32 %r)
+; FNATTR: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
+;
+; ATTRIBUTOR: define i32 @sink_r0(i32 returned %r)
+; ATTRIBUTOR: define i32 @scc_r1(i32 %a, i32 returned %r, i32 %b)
+; ATTRIBUTOR: define i32 @scc_r2(i32 %a, i32 %b, i32 returned %r)
+; ATTRIBUTOR: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
 ;
 ; int scc_r1(int a, int b, int r);
 ; int scc_r2(int a, int b, int r);
 ;
 ; __attribute__((noinline)) int sink_r0(int r) {
 ;   return r;
 ; }
 ;

 return:                                           ; preds = %cond.end, %if.then3, %if.then
   %retval.0 = phi i32 [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
   ret i32 %retval.0
 }
 
 
 ; TEST SCC test returning a pointer value argument
 ;
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK: define double* @ptr_sink_r0(double* readnone returned %r)
-;
-; FIXME: returned on %r missing:
-; CHECK: Function Attrs: noinline nounwind readnone uwtable
-; CHECK: define double* @ptr_scc_r1(double* %a, double* readnone %r, double* nocapture readnone %b)
-;
-; FIXME: returned on %r missing:
-; CHECK: Function Attrs: noinline nounwind readnone uwtable
-; CHECK: define double* @ptr_scc_r2(double* readnone %a, double* readnone %b, double* readnone %r)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH-NEXT: define double* @ptr_sink_r0(double* readnone returned %r)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH-NEXT: define double* @ptr_scc_r1(double* %a, double* readnone returned %r, double* nocapture readnone %b)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH-NEXT: define double* @ptr_scc_r2(double* readnone %a, double* readnone %b, double* readnone returned %r)
+;
+; FNATTR: define double* @ptr_sink_r0(double* readnone returned %r)
+; FNATTR: define double* @ptr_scc_r1(double* %a, double* readnone %r, double* nocapture readnone %b)
+; FNATTR: define double* @ptr_scc_r2(double* readnone %a, double* readnone %b, double* readnone %r)
+;
+; ATTRIBUTOR: define double* @ptr_sink_r0(double* returned %r)
+; ATTRIBUTOR: define double* @ptr_scc_r1(double* %a, double* returned %r, double* %b)
+; ATTRIBUTOR: define double* @ptr_scc_r2(double* %a, double* %b, double* returned %r)
 ;
 ; double* ptr_scc_r1(double* a, double* b, double* r);
 ; double* ptr_scc_r2(double* a, double* b, double* r);
 ;
 ; __attribute__((noinline)) double* ptr_sink_r0(double* r) {
 ;   return r;
 ; }
 ;
cond.end:                                         ; preds = %cond.false, %cond.true
   br label %return
 
 return:                                           ; preds = %cond.end, %if.then3, %if.then
   %retval.0 = phi double* [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
   ret double* %retval.0
 }
 
 
-; TEST a singleton SCC with a lot of recursive calls
+; TEST a no-return singleton SCC
+;
+; int* rt0(int *a) {
+;   return *a ? a : rt0(a);
+; }
+;
+; FIXME: no-return missing
+; FNATTR:  define i32* @rt0(i32* readonly %a)
+; BOTH: Function Attrs: noinline nounwind readonly uwtable
+; BOTH-NEXT:    define i32* @rt0(i32* readonly returned %a)
+define i32* @rt0(i32* %a) #0 {
+entry:
+  %v = load i32, i32* %a, align 4
+  %tobool = icmp ne i32 %v, 0
+  %call = call i32* @rt0(i32* %a)
+  %sel = select i1 %tobool, i32* %a, i32* %call
+  ret i32* %sel
+}
+
+; TEST a no-return singleton SCC
 ;
-; int* ret0(int *a) {
-;   return *a ? a : ret0(ret0(ret0(...ret0(a)...)));
+; int* rt1(int *a) {
+;   return *a ? undef : rt1(a);
 ; }
 ;
-; FIXME: returned on %a missing:
-; CHECK: Function Attrs: noinline nounwind readonly uwtable
-; CHECK: define i32* @ret0(i32* readonly %a)
-define i32* @ret0(i32* %a) #0 {
+; FIXME: no-return missing
+; FNATTR:  define noalias i32* @rt1(i32* nocapture readonly %a)
+; BOTH: Function Attrs: noinline nounwind readonly uwtable
+; BOTH-NEXT:    define noalias i32* @rt1(i32* nocapture readonly %a)
+define i32* @rt1(i32* %a) #0 {
 entry:
   %v = load i32, i32* %a, align 4
   %tobool = icmp ne i32 %v, 0
-  %call = call i32* @ret0(i32* %a)
-  %call1 = call i32* @ret0(i32* %call)
-  %call2 = call i32* @ret0(i32* %call1)
-  %call3 = call i32* @ret0(i32* %call2)
-  %call4 = call i32* @ret0(i32* %call3)
-  %call5 = call i32* @ret0(i32* %call4)
-  %call6 = call i32* @ret0(i32* %call5)
-  %call7 = call i32* @ret0(i32* %call6)
-  %call8 = call i32* @ret0(i32* %call7)
-  %call9 = call i32* @ret0(i32* %call8)
-  %call10 = call i32* @ret0(i32* %call9)
-  %call11 = call i32* @ret0(i32* %call10)
-  %call12 = call i32* @ret0(i32* %call11)
-  %call13 = call i32* @ret0(i32* %call12)
-  %call14 = call i32* @ret0(i32* %call13)
-  %call15 = call i32* @ret0(i32* %call14)
-  %call16 = call i32* @ret0(i32* %call15)
-  %call17 = call i32* @ret0(i32* %call16)
-  %sel = select i1 %tobool, i32* %a, i32* %call17
+  %call = call i32* @rt1(i32* %a)
+  %sel = select i1 %tobool, i32* undef, i32* %call
+  ret i32* %sel
+}
+
+; TEST another SCC test
+;
+; FNATTR:  define i32* @rt2_helper(i32* %a)
+; FNATTR:  define i32* @rt2(i32* readnone %a, i32* readnone %b)
+; BOTH:    define i32* @rt2_helper(i32* %a)
+; BOTH:    define i32* @rt2(i32* readnone %a, i32* readnone %b)
+define i32* @rt2_helper(i32* %a) #0 {
+entry:
+  %call = call i32* @rt2(i32* %a, i32* %a)
+  ret i32* %call
+}
+
+define i32* @rt2(i32* %a, i32 *%b) #0 {
+entry:
+  %cmp = icmp eq i32* %a, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:
+  %call = call i32* @rt2_helper(i32* %a)
+  br label %if.end
+
+if.end:
+  %sel = phi i32* [ %b, %entry], [%call, %if.then]
   ret i32* %sel
 }
 
+; TEST another SCC test
+;
+; FNATTR:  define i32* @rt3_helper(i32* %a, i32* %b)
+; FNATTR:  define i32* @rt3(i32* readnone %a, i32* readnone %b)
+; BOTH:    define i32* @rt3_helper(i32* %a, i32* returned %b)
+; BOTH:    define i32* @rt3(i32* readnone %a, i32* readnone returned %b)
+define i32* @rt3_helper(i32* %a, i32* %b) #0 {
+entry:
+  %call = call i32* @rt3(i32* %a, i32* %b)
+  ret i32* %call
+}
+
+define i32* @rt3(i32* %a, i32 *%b) #0 {
+entry:
+  %cmp = icmp eq i32* %a, null
+  br i1 %cmp, label %if.then, label %if.end
+
+if.then:
+  %call = call i32* @rt3_helper(i32* %a, i32* %b)
+  br label %if.end
+
+if.end:
+  %sel = phi i32* [ %b, %entry], [%call, %if.then]
+  ret i32* %sel
+}
 
 ; TEST address taken function with call to an external functions
 ;
 ;  void unknown_fn(void *);
 ;
 ;  int* calls_unknown_fn(int *r) {
 ;    unknown_fn(&calls_unknown_fn);
 ;    return r;
 ;  }
 ;
-; CHECK: Function Attrs: noinline nounwind uwtable
-; CHECK: declare void @unknown_fn(i32* (i32*)*)
+; BOTH: declare void @unknown_fn(i32* (i32*)*)
 ;
-; CHECK: Function Attrs: noinline nounwind uwtable
-; CHECK: define i32* @calls_unknown_fn(i32* readnone returned %r)
+; BOTH:       Function Attrs: noinline nounwind uwtable
+; BOTH:       define i32* @calls_unknown_fn(i32* readnone returned %r)
+; FNATTR:     define i32* @calls_unknown_fn(i32* readnone returned %r)
+; ATTRIBUTOR: define i32* @calls_unknown_fn(i32* returned %r)
 declare void @unknown_fn(i32* (i32*)*) #0
 
 define i32* @calls_unknown_fn(i32* %r) #0 {
   tail call void @unknown_fn(i32* (i32*)* nonnull @calls_unknown_fn)
   ret i32* %r
 }
 
 

 }
 
 define i32* @calls_maybe_redefined_fn(i32* %r) #0 {
 entry:
   %call = call i32* @maybe_redefined_fn(i32* %r)
   ret i32* %r
 }
 
+; TEST return call to a function that might be redifined at link time
+;
+;  int *maybe_redefined_fn2(int *r) {
+;    return r;
+;  }
+;
+;  int *calls_maybe_redefined_fn2(int *r) {
+;    return maybe_redefined_fn2(r);
+;  }
+;
+; Verify the maybe-redefined function is not annotated:
+;
+; BOTH: Function Attrs: noinline norecurse nounwind uwtable
+; BOTH: define linkonce_odr i32* @maybe_redefined_fn2(i32* %r)
+; FIXME: We should not derive norecurse for potentially redefined functions!
+;        Function Attrs: noinline nounwind uwtable
+;        define linkonce_odr i32* @maybe_redefined_fn2(i32* %r)
+;
+; FNATTR:     define i32* @calls_maybe_redefined_fn2(i32* %r)
+; ATTRIBUTOR: define i32* @calls_maybe_redefined_fn2(i32* %r)
+define linkonce_odr i32* @maybe_redefined_fn2(i32* %r) #0 {
+entry:
+  ret i32* %r
+}
+
+define i32* @calls_maybe_redefined_fn2(i32* %r) #0 {
+entry:
+  %call = call i32* @maybe_redefined_fn2(i32* %r)
+  ret i32* %call
+}
+
 
 ; TEST returned argument goes through select and phi
 ;
 ; double select_and_phi(double b) {
 ;   double x = b;
 ;   if (b > 0)
 ;     x = b;
 ;   return b == 0? b : x;
 ; }
 ;
-; FIXME: returned on %b missing:
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK: define double @select_and_phi(double %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH: define double @select_and_phi(double returned %b)
+;
+; FNATTR:     define double @select_and_phi(double %b)
+; ATTRIBUTOR: define double @select_and_phi(double returned %b)
 define 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;
 ; }
 ;
-; FIXME: returned on %b missing:
-; CHECK: Function Attrs: noinline nounwind readnone uwtable
-; CHECK: define double @recursion_select_and_phi(i32 %a, double %b)
+; BOTH: Function Attrs: noinline nounwind readnone uwtable
+; BOTH: define double @recursion_select_and_phi(i32 %a, double returned %b)
+;
+; FNATTR:     define double @recursion_select_and_phi(i32 %a, double %b)
+; ATTRIBUTOR: define double @recursion_select_and_phi(i32 %a, double returned %b)
 define 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
   %call = call double @recursion_select_and_phi(i32 %dec, double %b)
   br label %if.end
 
 if.end:                                           ; preds = %if.then, %entry
   %phi = phi double [ %call, %if.then ], [ %b, %entry ]
   %cmp1 = fcmp oeq double %b, 0.000000e+00
   %sel = select i1 %cmp1, double %b, double %phi
   ret double %sel
 }
 
 
 ; TEST returned argument goes through bitcasts
 ;
 ; double* bitcast(int* b) {
 ;   return (double*)b;
 ; }
 ;
-; FIXME: returned on %b missing:
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK: define double* @bitcast(i32* readnone %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH:       define double* @bitcast(i32* readnone returned %b)
+;
+; FNATTR:     define double* @bitcast(i32* readnone %b)
+; ATTRIBUTOR: define double* @bitcast(i32* returned %b)
 define double* @bitcast(i32* %b) #0 {
 entry:
   %bc0 = bitcast i32* %b to double*
   ret double* %bc0
 }
 
 
 ; TEST returned argument goes through select and phi interleaved with bitcasts
 ;
 ; double* bitcasts_select_and_phi(int* b) {
 ;   double* x = b;
 ;   if (b == 0)
 ;     x = b;
 ;   return b != 0 ? b : x;
 ; }
 ;
-; FIXME: returned on %b missing:
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK: define double* @bitcasts_select_and_phi(i32* readnone %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH: define double* @bitcasts_select_and_phi(i32* readnone returned %b)
+;
+; FNATTR:     define double* @bitcasts_select_and_phi(i32* readnone %b)
+; ATTRIBUTOR: define double* @bitcasts_select_and_phi(i32* returned %b)
 define 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.then:                                          ; preds = %entry
   %bc1 = bitcast i32* %b to double*

 ; double* ret_arg_arg_undef(int* b) {
 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK:     define double* @ret_arg_arg_undef(i32* readnone %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH:     define double* @ret_arg_arg_undef(i32* readnone returned %b)
+;
+; FNATTR:     define double* @ret_arg_arg_undef(i32* readnone %b)
+; ATTRIBUTOR: define double* @ret_arg_arg_undef(i32* returned %b)
 define 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
 
 ret_arg0:
   %bc1 = bitcast i32* %b to double*

 ; double* ret_undef_arg_arg(int* b) {
 ;   if (b == 0)
 ;     return (double*)b;
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK:     define double* @ret_undef_arg_arg(i32* readnone %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH:       define double* @ret_undef_arg_arg(i32* readnone returned %b)
+;
+; FNATTR:     define double* @ret_undef_arg_arg(i32* readnone %b)
+; ATTRIBUTOR: define double* @ret_undef_arg_arg(i32* returned %b)
 define 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
 
 ret_undef:
   ret double *undef

 ; double* ret_undef_arg_undef(int* b) {
 ;   if (b == 0)
 ;     /* return undef */
 ;   if (b == 0)
 ;     return (double*)b;
 ;   /* return undef */
 ; }
 ;
-; CHECK: Function Attrs: noinline norecurse nounwind readnone uwtable
-; CHECK:     define double* @ret_undef_arg_undef(i32* readnone %b)
+; BOTH: Function Attrs: noinline norecurse nounwind readnone uwtable
+; BOTH:       define double* @ret_undef_arg_undef(i32* readnone returned %b)
+;
+; FNATTR:     define double* @ret_undef_arg_undef(i32* readnone %b)
+; ATTRIBUTOR: define double* @ret_undef_arg_undef(i32* returned %b)
 define 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
 
 ret_undef0:
   ret double *undef
 
 if.end:
   br i1 %cmp, label %ret_arg, label %ret_undef1
 
 ret_arg:
   ret double* %bc0
 
 ret_undef1:
   ret double *undef
 }
 
 ; TEST return argument or unknown call result
 ;
 ; int* ret_arg_or_unknown(int* b) {
 ;   if (b == 0)
 ;     return b;
-;   return unknown(b);
+;   return unknown();
 ; }
 ;
-; Verify we do not assume b is returned>
+; Verify we do not assume b is returned
 ;
-; CHECK:     define i32* @ret_arg_or_unknown(i32* %b)
-; CHECK:     define i32* @ret_arg_or_unknown_through_phi(i32* %b)
+; FNATTR:     define i32* @ret_arg_or_unknown(i32* %b)
+; FNATTR:     define i32* @ret_arg_or_unknown_through_phi(i32* %b)
+; ATTRIBUTOR: define i32* @ret_arg_or_unknown(i32* %b)
+; ATTRIBUTOR: define i32* @ret_arg_or_unknown_through_phi(i32* %b)
+; BOTH:       define i32* @ret_arg_or_unknown(i32* %b)
+; BOTH:       define i32* @ret_arg_or_unknown_through_phi(i32* %b)
 declare i32* @unknown(i32*)
 
 define i32* @ret_arg_or_unknown(i32* %b) #0 {
 entry:
   %cmp = icmp eq i32* %b, null
   br i1 %cmp, label %ret_arg, label %ret_unknown
 
 ret_arg:

 
 r:
   %phi = phi i32* [ %b, %ret_arg ], [ %call, %ret_unknown ]
   ret i32* %phi
 }
 
 attributes #0 = { noinline nounwind uwtable }
 
-; CHECK-NOT: attributes #
-; CHECK-DAG: attributes #{{[0-9]*}} = { noinline norecurse nounwind readnone uwtable }
-; CHECK-DAG: attributes #{{[0-9]*}} = { noinline nounwind readnone uwtable }
-; CHECK-DAG: attributes #{{[0-9]*}} = { noinline nounwind readonly uwtable }
-; CHECK-DAG: attributes #{{[0-9]*}} = { noinline nounwind uwtable }
-; CHECK-DAG: attributes #{{[0-9]*}} = { noinline norecurse nounwind uwtable }
-; CHECK-NOT: attributes #
+; BOTH-NOT: attributes #
+; BOTH-DAG: attributes #{{[0-9]*}} = { noinline norecurse nounwind readnone uwtable }
+; BOTH-DAG: attributes #{{[0-9]*}} = { noinline nounwind readnone uwtable }
+; BOTH-DAG: attributes #{{[0-9]*}} = { noinline nounwind readonly uwtable }
+; BOTH-DAG: attributes #{{[0-9]*}} = { noinline nounwind uwtable }
+; BOTH-DAG: attributes #{{[0-9]*}} = { noinline norecurse nounwind uwtable }
+; BOTH-NOT: attributes #

llvm/test/Transforms/FunctionAttrs/read_write_returned_arguments_scc.ll

 ;   4 - Number of arguments marked readnone
 ;   6 - Number of arguments marked writeonly
 ;   6 - Number of arguments marked readonly
 ;   6 - Number of arguments marked returned
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; CHECK: Function Attrs: nounwind
-; CHECK-NEXT: define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
+; CHECK-NEXT: define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* returned %w0)
 define i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @internal_ret0_nw(i32* %n0, i32* %w0)
   %call1 = call i32* @internal_ret1_rrw(i32* %r0, i32* %r0, i32* %w0)
   %call2 = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call3 = call i32* @internal_ret1_rw(i32* %r0, i32* %w0)
   ret i32* %call3
 }
 
 ; CHECK: Function Attrs: nounwind
-; CHECK-NEXT: define internal i32* @internal_ret0_nw(i32* %n0, i32* %w0)
+; CHECK-NEXT: define internal i32* @internal_ret0_nw(i32* returned %n0, i32* %w0)
 define internal i32* @internal_ret0_nw(i32* %n0, i32* %w0) {
 entry:
   %r0 = alloca i32, align 4
   %r1 = alloca i32, align 4
   %tobool = icmp ne i32* %n0, null
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
if.end:                                           ; preds = %entry
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call5, %if.end ], [ %n0, %if.then ]
   ret i32* %retval.0
 }
 
 ; CHECK: Function Attrs: nounwind
-; CHECK-NEXT: define internal i32* @internal_ret1_rrw(i32* %r0, i32* %r1, i32* %w0)
+; CHECK-NEXT: define internal i32* @internal_ret1_rrw(i32* %r0, i32* returned %r1, i32* %w0)
 define internal i32* @internal_ret1_rrw(i32* %r0, i32* %r1, i32* %w0) {
 entry:
   %0 = load i32, i32* %r0, align 4
   %tobool = icmp ne i32 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
   br label %return
if.end:                                           ; preds = %entry
   store i32 %0, i32* %w0, align 4
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   ret i32* %w0
 }
 
 ; CHECK: Function Attrs: nounwind
-; CHECK-NEXT: define internal i32* @internal_ret1_rw(i32* %r0, i32* %w0)
+; CHECK-NEXT: define internal i32* @internal_ret1_rw(i32* %r0, i32* returned %w0)
 define internal i32* @internal_ret1_rw(i32* %r0, i32* %w0) {
 entry:
   %0 = load i32, i32* %r0, align 4
   %tobool = icmp ne i32 %0, 0
   br i1 %tobool, label %if.end, label %if.then
 
 if.then:                                          ; preds = %entry
   br label %return
if.end:                                           ; preds = %entry
   br label %return
 
 return:                                           ; preds = %if.end, %if.then
   %retval.0 = phi i32* [ %call4, %if.end ], [ %w0, %if.then ]
   ret i32* %retval.0
 }
 
 ; CHECK: Function Attrs: nounwind
-; CHECK-NEXT: define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
+; CHECK-NEXT: define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* returned %w0)
 define i32* @external_source_ret2_nrw(i32* %n0, i32* %r0, i32* %w0) {
 entry:
   %call = call i32* @external_sink_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   %call1 = call i32* @external_ret2_nrw(i32* %n0, i32* %r0, i32* %w0)
   ret i32* %call1
 }
 
 ; Verify that we see only expected attribute sets, the above lines only check
 ; for a subset relation.
 ;
 ; CHECK-NOT: attributes #
 ; CHECK: attributes #{{.*}} = { nounwind }
 ; CHECK: attributes #{{.*}} = { norecurse nounwind }
 ; CHECK-NOT: attributes #