[ObjC][ARC] Ignore operand bundle "clang.arc.attachedcall" on a call if the call's return type is void

[ahatanak]

Summary

Instead of trying hard to prevent global optimization passes such as deadargelim from changing the return type to void, just ignore the bundle if the return type is void. clang currently emits calls to @llvm.objc.clang.arc.noop.use, which consumes the function call result, immediately after the function call to prevent changes to the return type, but optimization passes can delete the call to @llvm.objc.clang.arc.noop.use if the function call doesn't return, which enables deadargelim to change the return type.

rdar://76671438

[ahatanak]

Without this patch, the verifier fails when the following code is compiled:

$ cat test.ll

declare i8* @foo0()
define internal i8* @foo1() #0 {
  %v1 = call i8 * @foo0()
  ret i8* %v1
}

define void @test() {
entry:
  %call1 = call i8* @foo1() #0 [ "clang.arc.attachedcall"(i64 0) ]
  call void (...) @llvm.objc.clang.arc.noop.use(i8* %call1)
  ret void
}

declare i8* @llvm.objc.retain(i8*)
declare void @llvm.objc.clang.arc.noop.use(...)

attributes #0 = { noreturn }

!0 = !{i32 1, !"clang.arc.retainAutoreleasedReturnValueMarker", !"mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue"}

$ opt -S -o - -simplifycfg -deadargelim test.ll

[fhahn]

Makes sense to me! Do we need to update LangRef?

[ahatanak]

Update and modify the explanation of the operand bundle in LangRef.

[fhahn]

LGTM, thanks!

llvm/docs/LangRef.rst

 
 ObjC ARC Attached Call Operand Bundles
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A ``"clang.arc.attachedcall`` operand bundle on a call indicates the call is
 implicitly followed by a marker instruction and a call to an ObjC runtime
 function that uses the result of the call. If the argument passed to the operand
 bundle is 0, ``@objc_retainAutoreleasedReturnValue`` is called. If 1 is passed,
-``@objc_unsafeClaimAutoreleasedReturnValue`` is called. A call with this bundle
-implicitly uses its return value.
+``@objc_unsafeClaimAutoreleasedReturnValue`` is called. The return value of a
+call with this bundle is used by a call to ``@llvm.objc.clang.arc.noop.use``
+unless the called function's return type is void, in which case the operand
+bundle is ignored.
 
 The operand bundle is needed to ensure the call is immediately followed by the
 marker instruction or the ObjC runtime call in the final output.
 
 .. _moduleasm:
 
 Module-Level Inline Assembly
 ----------------------------

llvm/include/llvm/Analysis/ObjCARCUtil.h

 
 enum AttachedCallOperandBundle : unsigned { RVOB_Retain, RVOB_Claim };
 
 inline AttachedCallOperandBundle
 getAttachedCallOperandBundleEnum(bool IsRetain) {
   return IsRetain ? RVOB_Retain : RVOB_Claim;
 }
 
+inline bool hasAttachedCallOpBundle(const CallBase *CB) {
+  // Ignore the bundle if the return type is void. Global optimization passes
+  // can turn the called function's return type to void. That should happen only
+  // if the call doesn't return and the call to @llvm.objc.clang.arc.noop.use
+  // no longer consumes the function return or is deleted. In that case, it's
+  // not necessary to emit the marker instruction or calls to the ARC runtime
+  // functions.
+  return !CB->getFunctionType()->getReturnType()->isVoidTy() &&
+         CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall)
+             .hasValue();
+}
+
 inline bool hasAttachedCallOpBundle(const CallBase *CB, bool IsRetain) {
+  assert(hasAttachedCallOpBundle(CB) &&
+         "call doesn't have operand bundle clang_arc_attachedcall");
   auto B = CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall);
   if (!B.hasValue())
     return false;
   return cast<ConstantInt>(B->Inputs[0])->getZExtValue() ==
          getAttachedCallOperandBundleEnum(IsRetain);
 }
 
-inline bool hasAttachedCallOpBundle(const CallBase *CB) {
-  return CB->getOperandBundle(LLVMContext::OB_clang_arc_attachedcall)
-      .hasValue();
-}
-
 } // end namespace objcarc
 } // end namespace llvm
 
 #endif

llvm/lib/IR/Verifier.cpp

for (unsigned i = 0, e = Call.getNumOperandBundles(); i < e; ++i) {
     } else if (Tag == LLVMContext::OB_clang_arc_attachedcall) {
       Assert(!FoundAttachedCallBundle,
              "Multiple \"clang.arc.attachedcall\" operand bundles", Call);
       FoundAttachedCallBundle = true;
     }
   }
 
   if (FoundAttachedCallBundle)
-    Assert(FTy->getReturnType()->isPointerTy(),
+    Assert((FTy->getReturnType()->isPointerTy() ||
+            (Call.doesNotReturn() && FTy->getReturnType()->isVoidTy())),
            "a call with operand bundle \"clang.arc.attachedcall\" must call a "
-           "function returning a pointer",
+           "function returning a pointer or a non-returning function that has "
+           "a void return type",
            Call);
 
   // Verify that each inlinable callsite of a debug-info-bearing function in a
   // debug-info-bearing function has a debug location attached to it. Failure to
   // do so causes assertion failures when the inliner sets up inline scope info.
   if (Call.getFunction()->getSubprogram() && Call.getCalledFunction() &&
       Call.getCalledFunction()->getSubprogram())
     AssertDI(Call.getDebugLoc(),

llvm/test/Transforms/ObjCARC/contract-rv-attr.ll

if.end:
   %call3 = invoke i8* @foo() [ "clang.arc.attachedcall"(i64 0) ]
           to label %cleanup unwind label %lpad
 
 cleanup:
   %retval.0 = phi i8* [ %call1, %if.then ], [ %call3, %if.end ]
   ret i8* %retval.0
 }
 
+; CHECK-LABEL: define void @test3(
+; CHECK: call void @foo2() #[[ATTR1:.*]] [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK-NEXT: ret void
+
+define void @test3() {
+  call void @foo2() #0 [ "clang.arc.attachedcall"(i64 0) ]
+  ret void
+}
+
 declare i8* @foo()
+declare void @foo2()
 declare i32 @__gxx_personality_v0(...)
 
 !llvm.module.flags = !{!0}
 
+; CHECK: attributes #[[ATTR1]] = { noreturn }
+attributes #0 = { noreturn }
+
 !0 = !{i32 1, !"clang.arc.retainAutoreleasedReturnValueMarker", !"mov\09fp, fp\09\09// marker for objc_retainAutoreleaseReturnValue"}

llvm/test/Verifier/operand-bundles.ll

 ; RUN: not opt -verify < %s 2>&1 | FileCheck %s
 
 %0 = type opaque
 declare void @g()
 declare %0* @foo0()
 declare i8 @foo1()
+declare void @noreturn_func()
 
 ; Operand bundles uses are like regular uses, and need to be dominated
 ; by their defs.
 
 define void @f0(i32* %ptr) {
 ; CHECK: Instruction does not dominate all uses!
 ; CHECK-NEXT:  %x = add i32 42, 1
 ; CHECK-NEXT:  call void @g() [ "foo"(i32 42, i64 100, i32 %x), "bar"(float 0.000000e+00, i64 100, i32 %l) ]
entry:
   ret void
 }
 
 define void @f_clang_arc_attachedcall() {
 ; CHECK: Multiple "clang.arc.attachedcall" operand bundles
 ; CHECK-NEXT: call %0* @foo0() [ "clang.arc.attachedcall"(i64 0), "clang.arc.attachedcall"(i64 0) ]
 ; CHECK-NEXT: must call a function returning a pointer
 ; CHECK-NEXT: call i8 @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+; CHECK-NEXT: or a non-returning function
+; CHECK-NEXT: call void @g() [ "clang.arc.attachedcall"(i64 0) ]
 
   call %0* @foo0() [ "clang.arc.attachedcall"(i64 0) ]
   call %0* @foo0() [ "clang.arc.attachedcall"(i64 0), "clang.arc.attachedcall"(i64 0) ]
   call i8 @foo1() [ "clang.arc.attachedcall"(i64 0) ]
+  call void @noreturn_func() #0 [ "clang.arc.attachedcall"(i64 0) ]
+  call void @g() [ "clang.arc.attachedcall"(i64 0) ]
   ret void
 }
+
+attributes #0 = { noreturn }