[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) {
+      // We can replace the call site arguments with undef because the value is
+      // not used.
+      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);
+
+      Changed =
+          CallSiteOpReplacements.empty() ? Changed : ChangeStatus::CHANGED;
+    }
+
+    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
 

 ; ATTRIBUTOR: tail call void @test8(i32* align 4 %ptr1, i32* align 4 %ptr1, i32* %ptr0)
   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)
   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)
   ret void
 }
 
+declare void @user_i32_ptr(i32*) readnone nounwind
 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)
+  call void @user_i32_ptr(i32* %a)
+  call void @user_i32_ptr(i32* %b)
+  call void @user_i32_ptr(i32* %c)
   ret void
 }
 
 declare void @test9_helper(i32* %A)
 define void @test9_traversal(i1 %c, i32* align 4 %B, i32* align 8 %C) {
   %sel = select i1 %c, i32* %B, i32* %C
   call void @test9_helper(i32* %sel)
   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** noalias nocapture 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** noalias nocapture 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

 ; CHECK:       @t1_caller(i32* noalias nocapture [[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*, ...)*, ...) @t1_callback_broker(i32* noalias null, i32* noalias nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* noalias nocapture [[A:%.*]], i64 99, i32** noalias nocapture nonnull align 64 dereferenceable(8) [[C]])
+; CHECK-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t1_callback_broker(i32* noalias null, i32* noalias nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t1_callback_callee to void (i32*, i32*, ...)*), i32* noalias nocapture [[A:%.*]], i64 undef, i32** noalias nocapture 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

 ; CHECK:       @t2_caller(i32* noalias nocapture [[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*, ...)*, ...) @t2_callback_broker(i32* noalias null, i32* noalias nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture [[A:%.*]], i64 99, i32** noalias nocapture nonnull align 64 dereferenceable(8) [[C]])
+; CHECK-NEXT:    call void (i32*, i32*, void (i32*, i32*, ...)*, ...) @t2_callback_broker(i32* noalias null, i32* noalias nonnull align 128 dereferenceable(4) [[PTR]], void (i32*, i32*, ...)* nonnull bitcast (void (i32*, i32*, i32*, i64, i32**)* @t2_callback_callee to void (i32*, i32*, ...)*), i32* nocapture [[A:%.*]], i64 undef, i32** noalias nocapture 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/liveness.ll

 ;
 ; char* f3(char* a){
 ;     return a?&a1: f1(&a2);
 ; }
 
 @a1 = common global i8 0, align 8
 @a2 = common global i8 0, align 16
 
+; CHECK-NOT: @f1
 define internal i8* @f1(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal i8* @f1(i8* readnone %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* undef(i8* nonnull align 8 @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
 }
 
+; CHECK-NOT: @f2
 define internal i8* @f2(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal i8* @f2(i8* readnone %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
-; ATTRIBUTOR: %4 = tail call i8* undef(i8* nonnull align 8 %0)
   %4 = tail call i8* @f1(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
-; ATTRIBUTOR: %6 = tail call i8* undef(i8* nonnull align 16 @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
 }
 
+; CHECK-NOT: @f3
 define internal i8* @f3(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal i8* @f3(i8* readnone %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* undef(i8* nonnull align 16 @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
 }
 
lp1:
   %lp = landingpad { i8*, i32 } catch i8* null
   invoke void @blowup() to label %live_with_dead_entry unwind label %lp2
 lp2:
   %0 = landingpad { i8*, i32 } catch i8* null
   br label %live_with_dead_entry
 live_with_dead_entry:
   ret void
 }
+
+; CHECK: define internal void @useless_arg_sink(i32* nocapture readnone %a)
+define internal void @useless_arg_sink(i32* %a) {
+  ret void
+}
+
+; Check we do not annotate the function interface of this weak function.
+; CHECK: define weak_odr void @useless_arg_ext(i32* %a)
+define weak_odr void @useless_arg_ext(i32* %a) {
+; CHECK: call void @useless_arg_sink(i32* undef)
+  call void @useless_arg_sink(i32* %a)
+  ret void
+}
+
+; FIXME: We should remove the argument and pass undef.
+; CHECK: define internal void @useless_arg_ext_int(i32* %a)
+define internal void @useless_arg_ext_int(i32* %a) {
+; CHECK: call void @useless_arg_ext(i32* %a)
+  call void @useless_arg_ext(i32* %a)
+  ret void
+}
+
+define void @useless_arg_ext_int_ext(i32* %a) {
+; FIXME: We should remove the argument.
+; CHECK: call void @useless_arg_ext_int(i32* %a)
+  call void @useless_arg_ext_int(i32* %a)
+  ret void
+}
+

llvm/test/Transforms/FunctionAttrs/noalias_returned.ll

4:                                                ; preds = %1
   br label %5
 
 5:                                                ; preds = %1, %4
   ret i8* %2
 }
 
 ; TEST 9
 ; Simple Argument Test
-define internal void @test9(i8* %a, i8* %b) {
-; CHECK: define internal void @test9(i8* noalias nocapture readnone %a, i8* nocapture readnone %b)
+declare void @use_i8(i8* nocapture) readnone
+define internal void @test9a(i8* %a, i8* %b) {
+; CHECK: define internal void @test9a(i8* noalias nocapture readnone %a, i8* nocapture readnone %b)
+  ret void
+}
+define internal void @test9b(i8* %a, i8* %b) {
+; CHECK: define internal void @test9b(i8* noalias nocapture readnone %a, i8* nocapture readnone %b)
+  call void @use_i8(i8* %a)
+  call void @use_i8(i8* %b)
   ret void
 }
 define void @test9_helper(i8* %a, i8* %b) {
-  tail call void @test9(i8* noalias %a, i8* %b)
-  tail call void @test9(i8* noalias %b, i8* noalias %a)
+; CHECK: define void @test9_helper(i8* nocapture readnone %a, i8* nocapture readnone %b)
+; CHECK:  tail call void @test9a(i8* noalias nocapture undef, i8* nocapture undef)
+; CHECK:  tail call void @test9a(i8* noalias nocapture undef, i8* noalias nocapture undef)
+; CHECK:  tail call void @test9b(i8* noalias nocapture %a, i8* nocapture %b)
+; CHECK:  tail call void @test9b(i8* noalias nocapture %b, i8* noalias nocapture %a)
+  tail call void @test9a(i8* noalias %a, i8* %b)
+  tail call void @test9a(i8* noalias %b, i8* noalias %a)
+  tail call void @test9b(i8* noalias %a, i8* %b)
+  tail call void @test9b(i8* noalias %b, i8* noalias %a)
   ret void
 }
 
 
 ; TEST 10
 ; Simple CallSite Test
 
 declare void @test10_helper_1(i8* %a)
 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)

llvm/test/Transforms/FunctionAttrs/nonnull.ll

 declare i8* @unknown()
 define void @test13_helper() {
   %nonnullptr = tail call i8* @ret_nonnull()
   %maybenullptr = tail call i8* @unknown()
   tail call void @test13(i8* %nonnullptr, i8* %nonnullptr, i8* %maybenullptr)
   tail call void @test13(i8* %nonnullptr, i8* %maybenullptr, i8* %nonnullptr)
   ret void
 }
+declare void @use_i8_ptr(i8* readnone nocapture)
 define internal void @test13(i8* %a, i8* %b, i8* %c) {
 ; ATTRIBUTOR: define internal void @test13(i8* nocapture nonnull readnone %a, i8* nocapture readnone %b, i8* nocapture readnone %c) 
+  call void @use_i8_ptr(i8* %a)
+  call void @use_i8_ptr(i8* %b)
+  call void @use_i8_ptr(i8* %c)
   ret void
 }
 
 declare nonnull i8* @nonnull()
 
 ; TEST 14
 ; Complex propagation
 ; Argument of f1, f2, f3 can be marked with nonnull.
define internal i32* @g2() {
   ret i32* inttoptr (i64 4 to i32*)
 }
 
 define  i32* @g1() {
  %c = call i32* @g2()
   ret i32* %c
 }
 
+declare void @use_i32_ptr(i32*) readnone nounwind
 ; ATTRIBUTOR: define internal void @called_by_weak(i32* nocapture nonnull readnone %a)
 define internal void @called_by_weak(i32* %a) {
+  call void @use_i32_ptr(i32* %a)
   ret void
 }
 
 ; Check we do not annotate the function interface of this weak function.
 ; ATTRIBUTOR: define weak_odr void @weak_caller(i32* nonnull %a)
 define weak_odr void @weak_caller(i32* nonnull %a) {
   call void @called_by_weak(i32* %a)
   ret void
 }
 
 attributes #0 = { "null-pointer-is-valid"="true" }