[Attributor][NFCI] Avoid lookups when resolving returned values

[jdoerfert]

Summary

If the number of potentially returned values not change since the last
traversal we do not need to visit the returned values again. This works
as we only add values to the returned values set now.

[jdoerfert]

Remove accidentally included code

[jdoerfert]

Use the call site as a key for the cache

[sstefan1]

LGTM

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

struct AAReturnedValues
   /// for all returned values.
   ///
   /// 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;
 
-  using iterator = DenseMap<Value *, SmallPtrSet<ReturnInst *, 2>>::iterator;
   using const_iterator =
       DenseMap<Value *, SmallPtrSet<ReturnInst *, 2>>::const_iterator;
-  virtual llvm::iterator_range<iterator> returned_values() = 0;
   virtual llvm::iterator_range<const_iterator> returned_values() const = 0;
 
   virtual size_t getNumReturnValues() const = 0;
   virtual const SmallPtrSetImpl<CallBase *> &getUnresolvedCalls() const = 0;
 
   /// Create an abstract attribute view for the position \p IRP.
   static AAReturnedValues &createForPosition(const IRPosition &IRP,
                                              Attributor &A);

llvm/lib/Transforms/IPO/Attributor.cpp

 /// 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 : 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;
 
+  /// Mapping to remember the number of returned values for a AAReturnedValues
+  /// object such that we can avoid updates if nothing changed.
+  DenseMap<const AAReturnedValues *, unsigned> NumReturnedValuesPerKnownAA;
+
+  /// Set of unresolved calls returned by the associated function.
   SmallPtrSet<CallBase *, 8> UnresolvedCalls;
 
   /// State flags
   ///
   ///{
-  bool IsFixed;
-  bool IsValidState;
+  bool IsFixed = false;
+  bool IsValidState = true;
   ///}
 
 public:
   AAReturnedValuesImpl(const IRPosition &IRP) : AAReturnedValues(IRP) {}
 
   /// See AbstractAttribute::initialize(...).
   void initialize(Attributor &A) override {
     // Reset the state.
public:
   AbstractState &getState() override { return *this; }
 
   /// See AbstractAttribute::getState(...).
   const AbstractState &getState() const override { return *this; }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   ChangeStatus updateImpl(Attributor &A) override;
 
-  llvm::iterator_range<iterator> returned_values() override {
-    return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
-  }
-
   llvm::iterator_range<const_iterator> returned_values() const override {
     return llvm::make_range(ReturnedValues.begin(), ReturnedValues.end());
   }
 
   const SmallPtrSetImpl<CallBase *> &getUnresolvedCalls() const override {
     return UnresolvedCalls;
   }
 
public:
   bool isAtFixpoint() const override { return IsFixed; }
 
   /// See AbstractState::isValidState().
   bool isValidState() const override { return IsValidState; }
 
   /// See AbstractState::indicateOptimisticFixpoint(...).
   ChangeStatus indicateOptimisticFixpoint() override {
     IsFixed = true;
-    IsValidState &= true;
     return ChangeStatus::UNCHANGED;
   }
 
   ChangeStatus indicatePessimisticFixpoint() override {
     IsFixed = true;
     IsValidState = false;
     return ChangeStatus::CHANGED;
   }
for (auto &RetValAAIt : RetValAA.returned_values()) {
       UnresolvedCalls.insert(CB);
       Unresolved = true;
       break;
     }
 
     if (Unresolved)
       continue;
 
+    // Now track transitively returned values.
+    unsigned &NumRetAA = NumReturnedValuesPerKnownAA[&RetValAA];
+    if (NumRetAA == RetValAA.getNumReturnValues()) {
+      LLVM_DEBUG(dbgs() << "[AAReturnedValues] Skip RetValAA as it has not "
+                           "changed since it was seen last\n");
+      continue;
+    }
+    NumRetAA = RetValAA.getNumReturnValues();
+
     for (auto &RetValAAIt : RetValAA.returned_values()) {
       Value *RetVal = RetValAAIt.first;
       if (Argument *Arg = dyn_cast<Argument>(RetVal)) {
         // Arguments are mapped to call site operands and we begin the traversal
         // again.
         bool Unused = false;
         RVState RVS({NewRVsMap, Unused, RetValAAIt.second});
         VisitReturnedValue(*CB->getArgOperand(Arg->getArgNo()), RVS);
ChangeStatus manifest(Attributor &A) override {
     // callee is nounwind. This is not possible if the personality of the
     // function allows to catch asynchronous exceptions.
     bool Invoke2CallAllowed = !mayCatchAsynchronousExceptions(F);
 
     for (const Instruction *NRC : NoReturnCalls) {
       Instruction *I = const_cast<Instruction *>(NRC);
       BasicBlock *BB = I->getParent();
       Instruction *SplitPos = I->getNextNode();
+      // TODO: mark stuff before unreachable instructions as dead.
+      if (!I->isTerminator() && isa<UnreachableInst>(SplitPos))
+        continue;
 
       if (auto *II = dyn_cast<InvokeInst>(I)) {
         // If we keep the invoke the split position is at the beginning of the
         // normal desitination block (it invokes a noreturn function after all).
         BasicBlock *NormalDestBB = II->getNormalDest();
         SplitPos = &NormalDestBB->front();
 
         /// Invoke is replaced with a call and unreachable is placed after it if
         /// the callee is nounwind and noreturn. Otherwise, we keep the invoke
         /// and only place an unreachable in the normal successor.
         if (Invoke2CallAllowed) {
           if (Function *Callee = II->getCalledFunction()) {
             const IRPosition &IPos = IRPosition::callsite_function(*II);
             const auto &AANoUnw = A.getAAFor<AANoUnwind>(*this, IPos);
             if (AANoUnw.isAssumedNoUnwind()) {
               LLVM_DEBUG(dbgs()
                          << "[AAIsDead] Replace invoke with call inst\n");
+
               // We do not need an invoke (II) but instead want a call followed
               // by an unreachable. However, we do not remove II as other
               // abstract attributes might have it cached as part of their
               // results. Given that we modify the CFG anyway, we simply keep II
               // around but in a new dead block. To avoid II being live through
               // a different edge we have to ensure the block we place it in is
               // only reached from the current block of II and then not reached
               // at all when we insert the unreachable.
for (Instruction &I : instructions(&F)) {
     }
     if (IsInterestingOpcode)
       InstOpcodeMap[I.getOpcode()].push_back(&I);
     if (I.mayReadOrWriteMemory())
       ReadOrWriteInsts.push_back(&I);
 
     CallSite CS(&I);
     if (CS && CS.getCalledFunction()) {
+      Function *Callee = CS.getCalledFunction();
+      Type *ReturnType = Callee->getReturnType();
+      if (!ReturnType->isVoidTy()) {
+
+        checkAndRegisterAA<AAReturnedValuesCallSite>(
+            IRPosition::callsite_function(CS), *this, Whitelist);
+
+        if (ReturnType->isPointerTy()) {
+          IRPosition RetPos = IRPosition::callsite_returned(CS);
+
+          // Every function with pointer call site return type might be marked
+          // align.
+          checkAndRegisterAA<AAAlignCallSiteReturned>(RetPos, *this, Whitelist);
+
+          // Every function with pointer call site return type might be marked
+          // nonnull.
+          checkAndRegisterAA<AANonNullCallSiteReturned>(RetPos, *this,
+                                                        Whitelist);
+
+          // Every function with pointer call site return type might be marked
+          // noalias.
+          checkAndRegisterAA<AANoAliasCallSiteReturned>(RetPos, *this,
+                                                        Whitelist);
+
+          // Every function with pointer call site return type might be marked
+          // dereferenceable.
+          checkAndRegisterAA<AADereferenceableCallSiteReturned>(RetPos, *this,
+                                                                Whitelist);
+        }
+      }
+
       for (int i = 0, e = CS.getCalledFunction()->arg_size(); i < e; i++) {
         if (!CS.getArgument(i)->getType()->isPointerTy())
           continue;
         IRPosition CSArgPos = IRPosition::callsite_argument(CS, i);
 
         // Call site argument attribute "non-null".
         checkAndRegisterAA<AANonNullCallSiteArgument>(CSArgPos, *this,
                                                       Whitelist);

llvm/test/Transforms/FunctionAttrs/align.ll

 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f1(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f1(i8* nonnull readnone align 8 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* @f2(i8* nonnull align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR: %4 = tail call nonnull align 8 dereferenceable(1) i8* @f2(i8* nonnull align 8 dereferenceable(1) @a1)
   %4 = tail call i8* @f2(i8* nonnull @a1)
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
   ret i8* %6
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f2(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f2(i8* nonnull readnone align 8 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
-; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 8 dereferenceable(1) %0)
+; ATTRIBUTOR: %4 = tail call nonnull align 8 dereferenceable(1) i8* @f1(i8* nonnull align 8 dereferenceable(1) %0)
   %4 = tail call i8* @f1(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
-; ATTRIBUTOR: %6 = tail call i8* @f3(i8* nonnull align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR: %6 = tail call nonnull align 8 dereferenceable(1) i8* @f3(i8* nonnull align 16 dereferenceable(1) @a2)
   %6 = tail call i8* @f3(i8* nonnull @a2)
   br label %7
 
 ; <label>:7:                                      ; preds = %5, %3
   %8 = phi i8* [ %4, %3 ], [ %6, %5 ]
   ret i8* %8
 }
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f3(i8* readnone %0) local_unnamed_addr #0 {
 ; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f3(i8* nonnull readnone align 16 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR: %4 = tail call nonnull align 8 dereferenceable(1) i8* @f1(i8* nonnull align 16 dereferenceable(1) @a2)
   %4 = tail call i8* @f1(i8* nonnull @a2)
   br label %5
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 

llvm/test/Transforms/FunctionAttrs/arg_nocapture.ll

 ; }
 ;
 ; Other arguments are possible here due to the no-return behavior.
 ;
 ; CHECK: define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @srec16(i32* nocapture readnone %a)
 define i32* @srec16(i32* %a) #0 {
 entry:
   %call = call i32* @srec16(i32* %a)
-; CHECK:      %call = call i32* @srec16(i32* %a)
+; CHECK:      %call = call noalias nonnull align 536870912 dereferenceable(4294967295) i32* @srec16(i32* %a)
 ; CHECK-NEXT: unreachable
   %call1 = call i32* @srec16(i32* %call)
   %call2 = call i32* @srec16(i32* %call1)
   %call3 = call i32* @srec16(i32* %call2)
   %call4 = call i32* @srec16(i32* %call3)
   %call5 = call i32* @srec16(i32* %call4)
   %call6 = call i32* @srec16(i32* %call5)
   %call7 = call i32* @srec16(i32* %call6)

llvm/test/Transforms/FunctionAttrs/liveness.ll

 ; RUN: opt -attributor --attributor-disable=false -S < %s | FileCheck %s
 
 declare void @no_return_call() nofree noreturn nounwind readnone
 
 declare void @normal_call() readnone
 
 declare i32 @foo()
 
 declare i32 @foo_noreturn_nounwind() noreturn nounwind
 
 declare i32 @foo_noreturn() noreturn
 
 declare i32 @bar() nosync readnone
 
-; CHECK: Function Attrs: nofree norecurse nounwind uwtable willreturn
-define i32 @volatile_load(i32*) norecurse nounwind uwtable {
-  %2 = load volatile i32, i32* %0, align 4
-  ret i32 %2
-}
-
-; CHECK: Function Attrs: nofree norecurse nosync nounwind uwtable willreturn
-; CHECK-NEXT: define internal i32 @internal_load(i32* nonnull %0)
-define internal i32 @internal_load(i32*) norecurse nounwind uwtable {
-  %2 = load i32, i32* %0, align 4
-  ret i32 %2
-}
-; TEST 1: Only first block is live.
-
-; CHECK: Function Attrs: nofree noreturn nosync nounwind
-; CHECK-NEXT: define i32 @first_block_no_return(i32 %a, i32* nonnull %ptr1, i32* %ptr2)
-define i32 @first_block_no_return(i32 %a, i32* nonnull %ptr1, i32* %ptr2) #0 {
-entry:
-  call i32 @internal_load(i32* %ptr1)
-  ; CHECK: call i32 @internal_load(i32* nonnull %ptr1)
-  call void @no_return_call()
-  ; CHECK: call void @no_return_call()
-  ; CHECK-NEXT: unreachable
-  %cmp = icmp eq i32 %a, 0
-  br i1 %cmp, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %entry
-  call i32 @internal_load(i32* %ptr2)
-  ; CHECK: call i32 @internal_load(i32* %ptr2)
-  %load = call i32 @volatile_load(i32* %ptr1)
-  call void @normal_call()
-  %call = call i32 @foo()
-  br label %cond.end
-
-cond.false:                                       ; preds = %entry
-  call void @normal_call()
-  %call1 = call i32 @bar()
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %cond.true
-  %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
-  ret i32 %cond
-}
-
-; TEST 2: cond.true is dead, but cond.end is not, since cond.false is live
-
-; This is just an example. For example we can put a sync call in a
-; dead block and check if it is deduced.
-
-; CHECK: Function Attrs: nosync
-; CHECK-NEXT: define i32 @dead_block_present(i32 %a, i32* %ptr1)
-define i32 @dead_block_present(i32 %a, i32* %ptr1) #0 {
-entry:
-  %cmp = icmp eq i32 %a, 0
-  br i1 %cmp, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %entry
-  call void @no_return_call()
-  ; CHECK: call void @no_return_call()
-  ; CHECK-NEXT: unreachable
-  %call = call i32 @volatile_load(i32* %ptr1)
-  br label %cond.end
-
-cond.false:                                       ; preds = %entry
-  call void @normal_call()
-  %call1 = call i32 @bar()
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %cond.true
-  %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
-  ret i32 %cond
-}
-
-; TEST 3: both cond.true and cond.false are dead, therfore cond.end is dead as well.
-
-define i32 @all_dead(i32 %a) #0 {
-entry:
-  %cmp = icmp eq i32 %a, 0
-  br i1 %cmp, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %entry
-  call void @no_return_call()
-  ; CHECK: call void @no_return_call()
-  ; CHECK-NEXT: unreachable
-  %call = call i32 @foo()
-  br label %cond.end
-
-cond.false:                                       ; preds = %entry
-  call void @no_return_call()
-  ; CHECK: call void @no_return_call()
-  ; CHECK-NEXT: unreachable
-  %call1 = call i32 @bar()
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %cond.true
-  %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
-  ret i32 %cond
-}
 
 declare i32 @__gxx_personality_v0(...)
 
-; TEST 4: All blocks are live.
-
-; CHECK: define i32 @all_live(i32 %a)
-define i32 @all_live(i32 %a) #0 {
-entry:
-  %cmp = icmp eq i32 %a, 0
-  br i1 %cmp, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %entry
-  call void @normal_call()
-  %call = call i32 @foo_noreturn()
-  br label %cond.end
-
-cond.false:                                       ; preds = %entry
-  call void @normal_call()
-  %call1 = call i32 @bar()
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %cond.true
-  %cond = phi i32 [ %call, %cond.true ], [ %call1, %cond.false ]
-  ret i32 %cond
-}
-
 ; TEST 5 noreturn invoke instruction with a unreachable normal successor block.
 
 ; CHECK: define i32 @invoke_noreturn(i32 %a)
 define i32 @invoke_noreturn(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 entry:
   %cmp = icmp eq i32 %a, 0
   br i1 %cmp, label %cond.true, label %cond.false
 
continue:
   br label %cond.end
 
 cleanup:
   %res = landingpad { i8*, i32 }
   catch i8* null
   ret i32 0
 }
 
-; TEST 4.1 noreturn invoke instruction replaced by a call and an unreachable instruction
-; put after it.
-
-; CHECK: define i32 @invoke_noreturn_nounwind(i32 %a)
-define i32 @invoke_noreturn_nounwind(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
-entry:
-  %cmp = icmp eq i32 %a, 0
-  br i1 %cmp, label %cond.true, label %cond.false
-
-cond.true:                                        ; preds = %entry
-  call void @normal_call()
-  %call = invoke i32 @foo_noreturn_nounwind() to label %continue
-            unwind label %cleanup
-  ; CHECK:      call void @normal_call()
-  ; CHECK-NEXT: call i32 @foo_noreturn_nounwind()
-  ; CHECK-NEXT: unreachable
-
-  ; We keep the invoke around as other attributes might have references to it.
-  ; CHECK:       cond.true.split:                                  ; No predecessors!
-  ; CHECK-NEXT:      invoke i32 @foo_noreturn_nounwind()
-
-cond.false:                                       ; preds = %entry
-  call void @normal_call()
-  %call1 = call i32 @bar()
-  br label %cond.end
-
-cond.end:                                         ; preds = %cond.false, %continue
-  %cond = phi i32 [ %call, %continue ], [ %call1, %cond.false ]
-  ret i32 %cond
-
-continue:
-  br label %cond.end
-
-cleanup:
-  %res = landingpad { i8*, i32 }
-  catch i8* null
-  ret i32 0
-}
-
-; TEST 6: Undefined behvior, taken from LangRef.
-; FIXME: Should be able to detect undefined behavior.
-
-; CHECK: define void @ub(i32* %0)
-define void @ub(i32* %0) {
-  %poison = sub nuw i32 0, 1           ; Results in a poison value.
-  %still_poison = and i32 %poison, 0   ; 0, but also poison.
-  %poison_yet_again = getelementptr i32, i32* %0, i32 %still_poison
-  store i32 0, i32* %poison_yet_again  ; Undefined behavior due to store to poison.
-  ret void
-}
-
-define void @inf_loop() #0 {
-entry:
-  br label %while.body
-
-while.body:                                       ; preds = %entry, %while.body
-  br label %while.body
-}
-
-; TEST 7: Infinite loop.
-; FIXME: Detect infloops, and mark affected blocks dead.
-
-define i32 @test5(i32, i32) #0 {
-  %3 = icmp sgt i32 %0, %1
-  br i1 %3, label %cond.if, label %cond.elseif
-
-cond.if:                                                ; preds = %2
-  %4 = tail call i32 @bar()
-  br label %cond.end
-
-cond.elseif:                                                ; preds = %2
-  call void @inf_loop()
-  %5 = icmp slt i32 %0, %1
-  br i1 %5, label %cond.end, label %cond.else
-
-cond.else:                                                ; preds = %cond.elseif
-  %6 = tail call i32 @foo()
-  br label %cond.end
-
-cond.end:                                               ; preds = %cond.if, %cond.else, %cond.elseif
-  %7 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ]
-  ret i32 %7
-}
-
-define void @rec() #0 {
-entry:
-  call void @rec()
-  ret void
-}
-
-; TEST 8: Recursion
-; FIXME: everything after first block should be marked dead
-; and unreachable should be put after call to @rec().
-
-define i32 @test6(i32, i32) #0 {
-  call void @rec()
-  %3 = icmp sgt i32 %0, %1
-  br i1 %3, label %cond.if, label %cond.elseif
-
-cond.if:                                                ; preds = %2
-  %4 = tail call i32 @bar()
-  br label %cond.end
-
-cond.elseif:                                                ; preds = %2
-  call void @rec()
-  %5 = icmp slt i32 %0, %1
-  br i1 %5, label %cond.end, label %cond.else
-
-cond.else:                                                ; preds = %cond.elseif
-  %6 = tail call i32 @foo()
-  br label %cond.end
-
-cond.end:                                               ; preds = %cond.if, %cond.else, %cond.elseif
-  %7 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ]
-  ret i32 %7
-}
-; TEST 9: Recursion
-; FIXME: contains recursive call to itself in cond.elseif block
-
-define i32 @test7(i32, i32) #0 {
-  %3 = icmp sgt i32 %0, %1
-  br i1 %3, label %cond.if, label %cond.elseif
-
-cond.if:                                                ; preds = %2
-  %4 = tail call i32 @bar()
-  br label %cond.end
-
-cond.elseif:                                                ; preds = %2
-  %5 = tail call i32 @test7(i32 %0, i32 %1)
-  %6 = icmp slt i32 %0, %1
-  br i1 %6, label %cond.end, label %cond.else
-
-cond.else:                                                ; preds = %cond.elseif
-  %7 = tail call i32 @foo()
-  br label %cond.end
-
-cond.end:                                               ; preds = %cond.if, %cond.else, %cond.elseif
-  %8 = phi i32 [ %1, %cond.elseif ], [ 0, %cond.else ], [ 0, %cond.if ]
-  ret i32 %8
-}

llvm/test/Transforms/FunctionAttrs/nonnull.ll

 
 bb1:                                              ; preds = %bb
   %tmp2 = load i32, i32* %arg, align 4
   %tmp3 = icmp eq i32 %tmp2, 0
   br i1 %tmp3, label %bb6, label %bb4
 
 bb4:                                              ; preds = %bb1
   %tmp5 = getelementptr inbounds i32, i32* %arg, i64 1
-; ATTRIBUTOR: %tmp5b = tail call i32* @f3(i32* nonnull %tmp5)
+; ATTRIBUTOR: %tmp5b = tail call noalias i32* @f3(i32* nonnull %tmp5)
   %tmp5b = tail call i32* @f3(i32* %tmp5)
   br label %bb9
 
 bb6:                                              ; preds = %bb1
 ; FIXME: missing nonnull. It should be @f2(i32* nonnull %arg)
 ; ATTRIBUTOR: %tmp7 = tail call nonnull i32* @f2(i32* %arg)
   %tmp7 = tail call i32* @f2(i32* %arg)
   ret i32* %tmp7
; ATTRIBUTOR:   %tmp = tail call nonnull i32* @f1(i32* %arg)
   ret i32* %tmp
 }
 
 define dso_local noalias i32* @f3(i32* %arg) {
 ; FIXME: missing nonnull. It should be nonnull @f3(i32* nonnull %arg) 
 ; ATTRIBUTOR: define dso_local noalias i32* @f3(i32* %arg)
 bb:
 ; FIXME: missing nonnull. It should be @f1(i32* nonnull %arg) 
-; ATTRIBUTOR:   %tmp = call i32* @f1(i32* %arg)
+; ATTRIBUTOR:   %tmp = call nonnull i32* @f1(i32* %arg)
   %tmp = call i32* @f1(i32* %arg)
   ret i32* null
 }
 
 ; TEST 15
 define void @f15(i8* %arg) {
 ; ATTRIBUTOR:   tail call void @use1(i8* nonnull dereferenceable(4) %arg)