[Attributor] Provide easier checkForallReturnedValues functionality

[jdoerfert]

Summary

So far, whenever one wants to look at returned values, one had to deal
with the AAReturnedValues and potentially with the AAIsDead attribute.
In the same spirit as other checkForAllXXX methods, we add this
functionality now to the Attributor. By adopting the use sites we got
better results when return instructions were dead.

[sstefan1]

This looks good. Just one comment inlined:

llvm/lib/Transforms/IPO/Attributor.cpp

1001 ↗

(On Diff #213275)

Shouldn't AANonNullReturned also use A.checkForAllReturnedValuesAndReturnInsts(Pred))?

[jdoerfert]

llvm/lib/Transforms/IPO/Attributor.cpp

1001 ↗

(On Diff #213275)

It should. I fixed it for the commit.

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

struct Attributor {
   /// This method is the only (supported) way an abstract attribute can retrieve
   /// information from another abstract attribute. As an example, take an
   /// abstract attribute that determines the memory access behavior for a
   /// argument (readnone, readonly, ...). It should use `getAAFor` to get the
   /// most optimistic information for other abstract attributes in-flight, e.g.
   /// the one reasoning about the "captured" state for the argument or the one
   /// reasoning on the memory access behavior of the function as a whole.
   template <typename AAType>
-  const AAType *getAAFor(AbstractAttribute &QueryingAA, const Value &V,
+  const AAType *getAAFor(const AbstractAttribute &QueryingAA, const Value &V,
                          int ArgNo = -1) {
     static_assert(std::is_base_of<AbstractAttribute, AAType>::value,
                   "Cannot query an attribute with a type not derived from "
                   "'AbstractAttribute'!");
 
     // Determine the argument number automatically for llvm::Arguments if none
     // is set. Do not override a given one as it could be a use of the argument
     // in a call site.
const AAType *getAAFor(const AbstractAttribute &QueryingAA, const Value &V,
     // Lookup the abstract attribute of type AAType. If found, return it after
     // registering a dependence of QueryingAA on the one returned attribute.
     const auto &KindToAbstractAttributeMap = AAMap.lookup({&V, ArgNo});
     if (AAType *AA = static_cast<AAType *>(
             KindToAbstractAttributeMap.lookup(&AAType::ID))) {
       // Do not return an attribute with an invalid state. This minimizes checks
       // at the calls sites and allows the fallback below to kick in.
       if (AA->getState().isValidState()) {
-        QueryMap[AA].insert(&QueryingAA);
+        QueryMap[AA].insert(const_cast<AbstractAttribute *>(&QueryingAA));
         return AA;
       }
     }
 
     // If no abstract attribute was found and we look for a call site argument,
     // defer to the actual argument instead.
     ImmutableCallSite ICS(&V);
     if (ICS && ICS.getCalledValue())
void identifyDefaultAbstractAttributes(
       DenseSet<const char *> *Whitelist = nullptr);
 
   /// Check \p Pred on all function call sites.
   ///
   /// This method will evaluate \p Pred on call sites and return
   /// true if \p Pred holds in every call sites. However, this is only possible
   /// all call sites are known, hence the function has internal linkage.
   bool checkForAllCallSites(Function &F, std::function<bool(CallSite)> &Pred,
-                            AbstractAttribute &QueryingAA,
+                            const AbstractAttribute &QueryingAA,
                             bool RequireAllCallSites);
 
+  /// Check \p Pred on all values potentially returned by \p F.
+  ///
+  /// This method will evaluate \p Pred on all values potentially returned by
+  /// \p F associated to their respective return instructions. Return true if
+  /// \p Pred holds on all of them.
+  bool checkForAllReturnedValuesAndReturnInsts(
+      const Function &F,
+      const function_ref<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)>
+          &Pred,
+      const AbstractAttribute &QueryingAA);
+
+  /// Check \p Pred on all values potentially returned by \p F.
+  ///
+  /// This is the context insensitive version of the method above.
+  bool checkForAllReturnedValues(const Function &F,
+                                 const function_ref<bool(Value &)> &Pred,
+                                 const AbstractAttribute &QueryingAA);
+
   /// Check \p Pred on all instructions with an opcode present in \p Opcodes.
   ///
   /// This method will evaluate \p Pred on all instructions with an opcode
   /// present in \p Opcode and return true if \p Pred holds on all of them.
-  bool checkForAllInstructions(
-      const Function &F, const llvm::function_ref<bool(Instruction &)> &Pred,
-      AbstractAttribute &QueryingAA, InformationCache &InfoCache,
+  bool checkForAllInstructions(const Function &F,
+                               const function_ref<bool(Instruction &)> &Pred,
+                               const AbstractAttribute &QueryingAA,
+                               InformationCache &InfoCache,
                                const ArrayRef<unsigned> &Opcodes);
 
   /// Check \p Pred on all call-like instructions (=CallBased derived).
   ///
   /// See checkForAllCallLikeInstructions(...) for more information.
   bool checkForAllCallLikeInstructions(
-      const Function &F, const llvm::function_ref<bool(Instruction &)> &Pred,
-      AbstractAttribute &QueryingAA, InformationCache &InfoCache) {
+      const Function &F, const function_ref<bool(Instruction &)> &Pred,
+      const AbstractAttribute &QueryingAA, InformationCache &InfoCache) {
     return checkForAllInstructions(F, Pred, QueryingAA, InfoCache,
                                    {(unsigned)Instruction::Invoke,
                                     (unsigned)Instruction::CallBr,
                                     (unsigned)Instruction::Call});
   }
 
   /// Check \p Pred on all Read/Write instructions.
   ///
struct AAReturnedValues
     : public IRAttribute<Attribute::Returned, AbstractAttribute> {
   IRPositionConstructorForward(AAReturnedValues, IRAttribute);
 
   /// Check \p Pred on all returned values.
   ///
   /// This method will evaluate \p Pred on returned values and return
   /// true if (1) all returned values are known, and (2) \p Pred returned true
   /// for all returned values.
-  virtual bool checkForallReturnedValues(
-      std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> &Pred)
-      const = 0;
+  ///
+  /// Note: Unlike the Attributor::checkForAllReturnedValuesAndReturnInsts
+  /// method, this one will not filter dead return instructions.
+  virtual bool checkForAllReturnedValuesAndReturnInsts(
+      const function_ref<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)>
+          &Pred) const = 0;
 
   /// Unique ID (due to the unique address)
   static const char ID;
 };
 
 struct AANoUnwind : public IRAttribute<Attribute::NoUnwind, AbstractAttribute> {
   IRPositionConstructorForward(AANoUnwind, IRAttribute);
 

llvm/trunk/lib/Transforms/IPO/Attributor.cpp

 
 /// --------------------- 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.
+///
+/// TODO: We should use liveness during construction of the returned values map
+///       and before we set HasOverdefinedReturnedCalls.
 class AAReturnedValuesImpl : public AAReturnedValues, public 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
   ///
public:
   /// Return the number of potential return values, -1 if unknown.
   size_t getNumReturnValues() const {
     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(const AAIsDead *LivenessAA) const;
+  Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
 
-  /// See AbstractState::checkForallReturnedValues(...).
-  bool checkForallReturnedValues(
-      std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> &Pred)
-      const override;
+  /// See AbstractState::checkForAllReturnedValues(...).
+  bool checkForAllReturnedValuesAndReturnInsts(
+      const function_ref<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)>
+          &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().

 
 ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) {
   ChangeStatus Changed = ChangeStatus::UNCHANGED;
 
   // Bookkeeping.
   assert(isValidState());
   NumFnKnownReturns++;
 
-  auto *LivenessAA = A.getAAFor<AAIsDead>(*this, getAnchorScope());
-
   // Check if we have an assumed unique return value that we could manifest.
-  Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(LivenessAA);
+  Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);
 
   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())) {
     setAssociatedValue(UniqueRVArg);
     setAttributeIdx(UniqueRVArg->getArgNo() + AttributeList::FirstArgIndex);
     Changed = IRAttribute::manifest(A) | Changed;
   }
 
   return Changed;
 }
 
 const std::string AAReturnedValuesImpl::getAsStr() const {
   return (isAtFixpoint() ? "returns(#" : "may-return(#") +
          (isValidState() ? std::to_string(getNumReturnValues()) : "?") +
          ")[OD: " + std::to_string(HasOverdefinedReturnedCalls) + "]";
 }
 
-Optional<Value *> AAReturnedValuesImpl::getAssumedUniqueReturnValue(
-    const AAIsDead *LivenessAA) const {
-  // If checkForallReturnedValues provides a unique value, ignoring potential
+Optional<Value *>
+AAReturnedValuesImpl::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;
 
-  std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
-      [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &RetInsts) -> bool {
-    // If all ReturnInsts are dead, then ReturnValue is dead as well
-    // and can be ignored.
-    if (LivenessAA &&
-        !LivenessAA->isLiveInstSet(RetInsts.begin(), RetInsts.end()))
-      return true;
-
+  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 (!checkForallReturnedValues(Pred))
+  if (!A.checkForAllReturnedValues(getAnchorScope(), Pred, *this))
     UniqueRV = nullptr;
 
   return UniqueRV;
 }
 
-bool AAReturnedValuesImpl::checkForallReturnedValues(
-    std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> &Pred)
-    const {
+bool AAReturnedValuesImpl::checkForAllReturnedValuesAndReturnInsts(
+    const function_ref<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)>
+        &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;
     const SmallPtrSetImpl<ReturnInst *> &RetInsts = It.second;
if (!RetCSAA) {
         Changed = ChangeStatus::CHANGED;
       HasOverdefinedReturnedCalls = true;
       LLVM_DEBUG(dbgs() << "[AAReturnedValues] Returned call site (" << *RV
                         << ") with " << (RetCSAA ? "invalid" : "no")
                         << " associated state\n");
       continue;
     }
 
-    auto *LivenessCSAA = A.getAAFor<AAIsDead>(*this, RetCSAA->getAnchorScope());
-
     // Try to find a assumed unique return value for the called function.
-    Optional<Value *> AssumedUniqueRV =
-        RetCSAA->getAssumedUniqueReturnValue(LivenessCSAA);
+    Optional<Value *> AssumedUniqueRV = RetCSAA->getAssumedUniqueReturnValue(A);
 
     // If no assumed unique 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 sites as return values. Because there were not
     // multiple possibilities, we do not treat it as overdefined.
     if (!AssumedUniqueRV.hasValue())
       continue;
struct AANonNullReturned : AANonNullImpl {
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 ChangeStatus AANonNullReturned::updateImpl(Attributor &A,
                                            InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
-  auto *AARetVal = A.getAAFor<AAReturnedValues>(*this, F);
-  if (!AARetVal)
-    return indicatePessimisticFixpoint();
-
   std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
       this->generatePredicate(A);
 
-  if (!AARetVal->checkForallReturnedValues(Pred))
+  if (!A.checkForAllReturnedValuesAndReturnInsts(F, Pred, *this))
     return indicatePessimisticFixpoint();
   return ChangeStatus::UNCHANGED;
 }
 
 /// NonNull attribute for function argument.
 struct AANonNullArgument : AANonNullImpl {
 
   AANonNullArgument(Argument &A) : AANonNullImpl(A) {}
struct AANoAliasReturned : AANoAliasImpl {
   virtual ChangeStatus updateImpl(Attributor &A,
                                   InformationCache &InfoCache) override;
 };
 
 ChangeStatus AANoAliasReturned::updateImpl(Attributor &A,
                                            InformationCache &InfoCache) {
   Function &F = getAnchorScope();
 
-  auto *AARetValImpl = A.getAAFor<AAReturnedValuesImpl>(*this, F);
-  if (!AARetValImpl)
-    return indicatePessimisticFixpoint();
-
-  std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
-      [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &RetInsts) -> bool {
+  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;
 
+    if (!ICS.returnDoesNotAlias()) {
       auto *NoAliasAA = A.getAAFor<AANoAlias>(*this, RV);
-
-    if (!ICS.returnDoesNotAlias() &&
-        (!NoAliasAA || !NoAliasAA->isAssumedNoAlias()))
+      if (!NoAliasAA || !NoAliasAA->isAssumedNoAlias())
         return false;
+    }
 
     /// FIXME: We can improve capture check in two ways:
     /// 1. Use the AANoCapture facilities.
     /// 2. Use the location of return insts for escape queries.
     if (PointerMayBeCaptured(&RV, /* ReturnCaptures */ false,
                              /* StoreCaptures */ true))
       return false;
 
     return true;
   };
 
-  if (!AARetValImpl->checkForallReturnedValues(Pred))
+  if (!A.checkForAllReturnedValues(F, CheckReturnValue, *this))
     return indicatePessimisticFixpoint();
 
   return ChangeStatus::UNCHANGED;
 }
 
 /// -------------------AAIsDead Function Attribute-----------------------
 
 struct AAIsDeadImpl : public AAIsDead, BooleanState {

 ChangeStatus
 AADereferenceableReturned::updateImpl(Attributor &A,
                                       InformationCache &InfoCache) {
   Function &F = getAnchorScope();
   auto BeforeState = static_cast<DerefState>(*this);
 
   syncNonNull(A.getAAFor<AANonNull>(*this, F));
 
-  auto *AARetVal = A.getAAFor<AAReturnedValues>(*this, F);
-  if (!AARetVal)
-    return indicatePessimisticFixpoint();
-
   bool IsNonNull = isAssumedNonNull();
   bool IsGlobal = isAssumedGlobal();
 
-  std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
-      [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &RetInsts) -> bool {
+  auto CheckReturnValue = [&](Value &RV) -> bool {
     takeAssumedDerefBytesMinimum(
         computeAssumedDerefenceableBytes(A, RV, IsNonNull, IsGlobal));
     return isValidState();
   };
 
-  if (AARetVal->checkForallReturnedValues(Pred)) {
+  if (A.checkForAllReturnedValues(F, CheckReturnValue, *this)) {
     updateAssumedNonNullGlobalState(IsNonNull, IsGlobal);
     return BeforeState == static_cast<DerefState>(*this)
                ? ChangeStatus::UNCHANGED
                : ChangeStatus::CHANGED;
   }
   return indicatePessimisticFixpoint();
 }
 
struct AAAlignReturned final : AAAlignImpl {
 
   /// See AbstractAttribute::updateImpl(...).
   ChangeStatus updateImpl(Attributor &A, InformationCache &InfoCache) override;
 };
 
 ChangeStatus AAAlignReturned::updateImpl(Attributor &A,
                                          InformationCache &InfoCache) {
   Function &F = getAnchorScope();
-  auto *AARetValImpl = A.getAAFor<AAReturnedValuesImpl>(*this, F);
-  if (!AARetValImpl)
-    return indicatePessimisticFixpoint();
 
   // Currently, align<n> is deduced if alignments in return values are assumed
   // as greater than n. We reach pessimistic fixpoint if any of the return value
   // wouldn't have align. If no assumed state was used for reasoning, an
   // optimistic fixpoint is reached earlier.
 
   base_t BeforeState = getAssumed();
-  std::function<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)> Pred =
+  auto CheckReturnValue =
       [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &RetInsts) -> bool {
     auto *AlignAA = A.getAAFor<AAAlign>(*this, RV);
 
     if (AlignAA)
       takeAssumedMinimum(AlignAA->getAssumedAlign());
     else
       // Use IR information.
       takeAssumedMinimum(RV.getPointerAlignment(
           getAnchorScope().getParent()->getDataLayout()));
 
     return isValidState();
   };
 
-  if (!AARetValImpl->checkForallReturnedValues(Pred))
+  if (!A.checkForAllReturnedValuesAndReturnInsts(F, CheckReturnValue, *this))
     return indicatePessimisticFixpoint();
 
   return (getAssumed() != BeforeState) ? ChangeStatus::CHANGED
                                        : ChangeStatus::UNCHANGED;
 }
 
 /// Align attribute for function argument.
 struct AAAlignArgument final : AAAlignImpl {

 };
 
 /// ----------------------------------------------------------------------------
 ///                               Attributor
 /// ----------------------------------------------------------------------------
 
 bool Attributor::checkForAllCallSites(Function &F,
                                       std::function<bool(CallSite)> &Pred,
-                                      AbstractAttribute &QueryingAA,
+                                      const AbstractAttribute &QueryingAA,
                                       bool RequireAllCallSites) {
   // 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.
   if (RequireAllCallSites && !F.hasInternalLinkage()) {
     LLVM_DEBUG(
         dbgs()
         << "Attributor: Function " << F.getName()
for (const Use &U : F.uses()) {
     LLVM_DEBUG(dbgs() << "Attributor: Call site callback failed for "
                       << *CS.getInstruction() << "\n");
     return false;
   }
 
   return true;
 }
 
+bool Attributor::checkForAllReturnedValuesAndReturnInsts(
+    const Function &F,
+    const function_ref<bool(Value &, const SmallPtrSetImpl<ReturnInst *> &)>
+        &Pred,
+    const AbstractAttribute &QueryingAA) {
+
+  auto *AARetVal = getAAFor<AAReturnedValues>(QueryingAA, F);
+  if (!AARetVal)
+    return false;
+
+  auto *LivenessAA = getAAFor<AAIsDead>(QueryingAA, F);
+  if (!LivenessAA)
+    return AARetVal->checkForAllReturnedValuesAndReturnInsts(Pred);
+
+  auto LivenessFilter = [&](Value &RV,
+                            const SmallPtrSetImpl<ReturnInst *> &ReturnInsts) {
+    SmallPtrSet<ReturnInst *, 4> FilteredReturnInsts;
+    for (ReturnInst *RI : ReturnInsts)
+      if (!LivenessAA->isAssumedDead(RI))
+        FilteredReturnInsts.insert(RI);
+    if (!FilteredReturnInsts.empty())
+      return Pred(RV, FilteredReturnInsts);
+    return true;
+  };
+
+  return AARetVal->checkForAllReturnedValuesAndReturnInsts(LivenessFilter);
+}
+
+bool Attributor::checkForAllReturnedValues(
+    const Function &F, const function_ref<bool(Value &)> &Pred,
+    const AbstractAttribute &QueryingAA) {
+
+  auto *AARetVal = getAAFor<AAReturnedValues>(QueryingAA, F);
+  if (!AARetVal)
+    return false;
+
+  auto *LivenessAA = getAAFor<AAIsDead>(QueryingAA, F);
+  if (!LivenessAA)
+    return AARetVal->checkForAllReturnedValuesAndReturnInsts(
+        [&](Value &RV, const SmallPtrSetImpl<ReturnInst *> &) {
+          return Pred(RV);
+        });
+
+  auto LivenessFilter = [&](Value &RV,
+                            const SmallPtrSetImpl<ReturnInst *> &ReturnInsts) {
+    if (LivenessAA->isLiveInstSet(ReturnInsts.begin(), ReturnInsts.end()))
+      return Pred(RV);
+    return true;
+  };
+
+  return AARetVal->checkForAllReturnedValuesAndReturnInsts(LivenessFilter);
+}
+
 bool Attributor::checkForAllInstructions(
     const Function &F, const llvm::function_ref<bool(Instruction &)> &Pred,
-    AbstractAttribute &QueryingAA, InformationCache &InfoCache,
+    const AbstractAttribute &QueryingAA, InformationCache &InfoCache,
     const ArrayRef<unsigned> &Opcodes) {
 
   auto *LivenessAA = getAAFor<AAIsDead>(QueryingAA, F);
 
   auto &OpcodeInstMap = InfoCache.getOpcodeInstMapForFunction(F);
   for (unsigned Opcode : Opcodes) {
     for (Instruction *I : OpcodeInstMap[Opcode]) {
       // Skip dead instructions.

llvm/trunk/test/Transforms/FunctionAttrs/arg_nocapture.ll

 
 ; TEST singleton SCC
 ;
 ; double *srec0(double *a) {
 ;   srec0(a);
 ;   return 0;
 ; }
 ;
-; CHECK: define noalias double* @srec0(double* nocapture readnone %a)
+; CHECK: define noalias nonnull align 536870912 dereferenceable(4294967295) double* @srec0(double* nocapture readnone %a)
 define double* @srec0(double* %a) #0 {
 entry:
   %call = call double* @srec0(double* %a)
   ret double* null
 }
 
 ; TEST singleton SCC with lots of nested recursive calls
 ;

llvm/trunk/test/Transforms/FunctionAttrs/arg_returned.ll

 ; TEST a no-return singleton SCC
 ;
 ; int* rt0(int *a) {
 ;   return *a ? a : rt0(a);
 ; }
 ;
 ; FNATTR:  define i32* @rt0(i32* readonly %a)
 ; BOTH: Function Attrs: nofree noinline noreturn nosync nounwind readonly uwtable
-; BOTH-NEXT:    define i32* @rt0(i32* readonly %a)
+; BOTH-NEXT:    define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @rt0(i32* readonly %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* rt1(int *a) {
 ;   return *a ? undef : rt1(a);
 ; }
 ;
 ; FNATTR:  define noalias i32* @rt1(i32* nocapture readonly %a)
 ; BOTH: Function Attrs: nofree noinline noreturn nosync nounwind readonly uwtable
-; BOTH-NEXT:    define noalias i32* @rt1(i32* nocapture readonly %a)
+; BOTH-NEXT:    define noalias nonnull align 536870912 dereferenceable(4294967295) 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* @rt1(i32* %a)
   %sel = select i1 %tobool, i32* undef, i32* %call
   ret i32* %sel
 }