[Attributor] Use undef for calls with unused arguments.

[jdoerfert]

Summary

If an argument is unused, we can pass in undef instead of the original
value to remove the use of the original value completely.

[jdoerfert]

Update tests, keep it in ValueSimplify for now

[sstefan1]

I have no problem with this going in as is. I have one question though. Why do we have to wait for ValueSimplify to finish? Wouldn't it be useful for AAIsDead to have isDeadArg(Arg) and then ValueSimplify could use that to decide whether to simplify or not?

[jdoerfert]

In D68626#1707223, @sstefan1 wrote:

I have no problem with this going in as is. I have one question though. Why do we have to wait for ValueSimplify to finish? Wouldn't it be useful for AAIsDead to have isDeadArg(Arg) and then ValueSimplify could use that to decide whether to simplify or not?

You are right. I'll replace it with a AAIsDead solution instead shortly.

[jdoerfert]

Dropped in favor of D68925.

llvm/lib/Transforms/IPO/Attributor.cpp

struct AAValueSimplifyImpl : AAValueSimplify {
   void trackStatistics() const override {}
 
   /// See AAValueSimplify::getAssumedSimplifiedValue()
   Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
     if (!getAssumed())
       return const_cast<Value *>(&getAssociatedValue());
     return SimplifiedAssociatedValue;
   }
-  void initialize(Attributor &A) override {}
+
+  void initialize(Attributor &A) override {
+    // TODO: This should live in a separata AA, probably AAIsDead.
+    if (getAssociatedFunction()->isDeclaration())
+      indicatePessimisticFixpoint();
+    if (getAssociatedValue().getNumUses() == 0)
+      indicateOptimisticFixpoint();
+  }
 
   /// Helper function for querying AAValueSimplify and updating candicate.
   /// \param QueryingValue Value trying to unify with SimplifiedValue
   /// \param AccumulatedSimplifiedValue Current simplification result.
   static bool checkAndUpdate(Attributor &A, const AbstractAttribute &QueryingAA,
                              Value &QueryingValue,
                              Optional<Value *> &AccumulatedSimplifiedValue) {
     // FIXME: Add a typecast support.
ChangeStatus manifest(Attributor &A) override {
 
     if (!SimplifiedAssociatedValue.hasValue() ||
         !SimplifiedAssociatedValue.getValue())
       return Changed;
 
     if (auto *C = dyn_cast<Constant>(SimplifiedAssociatedValue.getValue())) {
       // We can replace the AssociatedValue with the constant.
       Value &V = getAssociatedValue();
-      if (!V.user_empty() && &V != C && V.getType() == C->getType()) {
+      if (!isa<UndefValue>(V) && !V.user_empty() && &V != C &&
+          V.getType() == C->getType()) {
         LLVM_DEBUG(dbgs() << "[Attributor][ValueSimplify] " << V << " -> " << *C
                           << "\n");
         V.replaceAllUsesWith(C);
         Changed = ChangeStatus::CHANGED;
       }
     }
 
     return Changed | AAValueSimplify::manifest(A);
if (!A.checkForAllCallSites(PredForCallSite, *this, true))
       return indicatePessimisticFixpoint();
 
     // If a candicate was found in this update, return CHANGED.
     return HasValueBefore == SimplifiedAssociatedValue.hasValue()
                ? ChangeStatus::UNCHANGED
                : ChangeStatus ::CHANGED;
   }
 
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    Argument &Arg = *getAssociatedArgument();
+    ChangeStatus Changed = AAValueSimplifyImpl::manifest(A);
+
+    // TODO: This should live in a separata AA, probably AAIsDead. However, to
+    //       keep the patch small we prototype it here and move it in a separate
+    //       step. The AAIsDead impl. will also depend on the simplified value
+    //       result as a simplified value means we replace the uses.
+    if (Changed == ChangeStatus::CHANGED || Arg.getNumUses() == 0) {
+      SmallVector<std::pair<CallSite, unsigned>, 4> CallSiteOpReplacements;
+      auto RplArgOpWithUndef = [&](AbstractCallSite ACS) {
+        // Check if we have an associated argument or not (which can happen
+        // for callback calls).
+        int CSArgNo = ACS.getCallArgOperandNo(getArgNo());
+        if (CSArgNo >= 0)
+          CallSiteOpReplacements.push_back({ACS.getCallSite(), CSArgNo});
+        return true;
+      };
+      A.checkForAllCallSites(RplArgOpWithUndef, *this, false);
+
+      // Replace the values after we are done iterating uses.
+      Value *UndefV = UndefValue::get(getAssociatedValue().getType());
+      for (auto &It : CallSiteOpReplacements)
+        It.first->setOperand(It.second, UndefV);
+    }
+
+    return Changed;
+  }
+
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_ARG_ATTR(value_simplify)
   }
 };
 
 struct AAValueSimplifyReturned : AAValueSimplifyImpl {
   AAValueSimplifyReturned(const IRPosition &IRP) : AAValueSimplifyImpl(IRP) {}

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) "no-capture-maybe-returned" %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call align 8 i8* @f2(i8* nonnull align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR: %4 = tail call align 8 i8* @f2(i8* nonnull align 8 dereferenceable(1) undef)
   %4 = tail call i8* @f2(i8* nonnull @a1)
 ; ATTRIBUTOR: %l = load i8, i8* %4, align 8
   %l = load i8, i8* %4
   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) "no-capture-maybe-returned" %0)
+; ATTRIBUTOR: icmp eq i8* @a1, null
   %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) "no-capture-maybe-returned" @a1)
   %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 i8* @f3(i8* nonnull align 16 dereferenceable(1) undef)
   %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* nocapture nonnull readnone align 16 dereferenceable(1) %0)
+; ATTRIBUTOR: icmp eq i8* @a2, null
   %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)
   %4 = tail call i8* @f1(i8* nonnull @a2)
   br label %5
 

 
 ; TEST 8
 define void @test8_helper() {
   %ptr0 = tail call i32* @unknown()
   %ptr1 = tail call align 4 i32* @unknown()
   %ptr2 = tail call align 8 i32* @unknown()
 
   tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
-; ATTRIBUTOR: tail call void @test8(i32* align 4 %ptr1, i32* align 4 %ptr1, i32* %ptr0)
+; ATTRIBUTOR: tail call void @test8(i32* align 4 undef, i32* align 4 undef, i32* undef)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 8 undef, i32* align 4 undef, i32* align 4 undef)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 8 undef, i32* align 4 undef, i32* align 4 undef)
   ret void
 }
 
 define internal void @test8(i32* %a, i32* %b, i32* %c) {
 ; ATTRIBUTOR: define internal void @test8(i32* nocapture readnone align 4 %a, i32* nocapture readnone align 4 %b, i32* nocapture readnone %c)
   ret void
 }
 

llvm/test/Transforms/FunctionAttrs/callbacks.ll

 ; CHECK:       @t0_caller(i32* [[A:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 32
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32*, align 64
 ; CHECK-NEXT:    [[PTR:%.*]] = alloca i32, align 128
 ; CHECK-NEXT:    [[TMP0:%.*]] = bitcast i32* [[B]] to i8*
 ; CHECK-NEXT:    store i32 42, i32* [[B]], align 32
 ; CHECK-NEXT:    store i32* [[B]], i32** [[C]], align 64
-; CHECK-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias null, i32* nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* [[A:%.*]], i64 99, i32** nonnull align 64 dereferenceable(8) [[C]])
+; CHECK-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t0_callback_broker(i32* noalias null, i32* nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t0_callback_callee to void (i32*, i32*, ...)*), i32* [[A:%.*]], i64 undef, i32** nonnull align 64 dereferenceable(8) [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %b = alloca i32, align 32
   %c = alloca i32*, align 64
   %ptr = alloca i32, align 128
   %0 = bitcast i32* %b to i8*
   store i32 42, i32* %b, align 4

llvm/test/Transforms/FunctionAttrs/internal-noalias.ll

-; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=5 < %s | FileCheck %s
+; RUN: opt -S -passes=attributor -aa-pipeline='basic-aa' -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=4 < %s | FileCheck %s
 
 define dso_local i32 @visible(i32* noalias %A, i32* noalias %B) #0 {
 entry:
   %call1 = call i32 @noalias_args(i32* %A, i32* %B)
   %call2 = call i32 @noalias_args_argmem(i32* %A, i32* %B)
   %add = add nsw i32 %call1, %call2
   ret i32 %add
 }

llvm/test/Transforms/FunctionAttrs/noalias_returned.ll

define void @test10_helper_2(i8* noalias %a) {
   ret void
 }
 define void @test10(i8* noalias %a) {
 ; CHECK: define void @test10(i8* noalias %a)
 ; FIXME: missing noalias
 ; CHECK-NEXT:   tail call void @test10_helper_1(i8* %a)
   tail call void @test10_helper_1(i8* %a)
 
-; CHECK-NEXT:   tail call void @test10_helper_2(i8* noalias %a)
+; CHECK-NEXT:   tail call void @test10_helper_2(i8* noalias undef)
   tail call void @test10_helper_2(i8* %a)
   ret void
 }
 
 ; TEST 11
 ; CallSite Test
 
 declare void @test11_helper(i8* %a, i8 *%b)