[AArch64][GlobalISel] Implement support for clang.arc.attachedcall call operand bundles.

[aemerson]

Summary

This is a straightforward port of the existing SDAG implementation.

[paquette]

Looks straightforward to me?

[fhahn]

Thanks for adding GISel support!

llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AArch64CallLowering.h"
 #include "AArch64ISelLowering.h"
 #include "AArch64MachineFunctionInfo.h"
 #include "AArch64Subtarget.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/ObjCARCUtil.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/CallingConvLower.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 #include "llvm/CodeGen/GlobalISel/Utils.h"
 #include "llvm/CodeGen/LowLevelType.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
bool AArch64CallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
   std::tie(AssignFnFixed, AssignFnVarArg) =
       getAssignFnsForCC(Info.CallConv, TLI);
 
   MachineInstrBuilder CallSeqStart;
   CallSeqStart = MIRBuilder.buildInstr(AArch64::ADJCALLSTACKDOWN);
 
   // Create a temporarily-floating call instruction so we can add the implicit
   // uses of arg registers.
-  unsigned Opc = getCallOpcode(MF, Info.Callee.isReg(), false);
+
+  // Calls with operand bundle "clang.arc.attachedcall" are special. They should
+  // be expanded to the call, directly followed by a special marker sequence and
+  // a call to an ObjC library function.
+  unsigned Opc = 0;
+  if (Info.CB && objcarc::hasAttachedCallOpBundle(Info.CB))
+    Opc = AArch64::BLR_RVMARKER;
+  else
+    Opc = getCallOpcode(MF, Info.Callee.isReg(), false);
 
   auto MIB = MIRBuilder.buildInstrNoInsert(Opc);
+  if (Opc == AArch64::BLR_RVMARKER) {
+    // Add a target global address for the retainRV/claimRV runtime function
+    // just before the call target.
+    Function *ARCFn = *objcarc::getAttachedARCFunction(Info.CB);
+    MIB.addGlobalAddress(ARCFn);
+  }
   MIB.add(Info.Callee);
 
   // Tell the call which registers are clobbered.
   const uint32_t *Mask;
   const AArch64Subtarget &Subtarget = MF.getSubtarget<AArch64Subtarget>();
   const auto *TRI = Subtarget.getRegisterInfo();
 
   AArch64OutgoingValueAssigner Assigner(AssignFnFixed, AssignFnVarArg,

llvm/test/CodeGen/AArch64/call-rv-marker.ll

 
 @g = dso_local global i8* null, align 8
 @fptr = dso_local global i8* ()* null, align 8
 
 define dso_local i8* @rv_marker_1_retain() {
 ; CHECK-LABEL:    rv_marker_1_retain:
 ; CHECK:           .cfi_offset w30, -16
 ; CHECK-NEXT:      bl foo1
-; SELDAG-NEXT:     mov x29, x29
-; SELDAG-NEXT:     bl objc_retainAutoreleasedReturnValue
-; GISEL-NOT:       mov x29, x29
+; CHECK-NEXT:     mov x29, x29
+; CHECK-NEXT:     bl objc_retainAutoreleasedReturnValue
 ;
 entry:
   %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   ret i8* %call
 }
 
 define dso_local i8* @rv_marker_1_unsafeClaim() {
 ; CHECK-LABEL:    rv_marker_1_unsafeClaim:
 ; CHECK:           .cfi_offset w30, -16
 ; CHECK-NEXT:      bl foo1
-; SELDAG-NEXT:     mov x29, x29
-; SELDAG-NEXT:     bl objc_unsafeClaimAutoreleasedReturnValue
-; GISEL-NOT:       mov x29, x29
+; CHECK-NEXT:     mov x29, x29
+; CHECK-NEXT:     bl objc_unsafeClaimAutoreleasedReturnValue
 ;
 entry:
   %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_unsafeClaimAutoreleasedReturnValue) ]
   ret i8* %call
 }
 
 define dso_local void @rv_marker_2_select(i32 %c) {
 ; CHECK-LABEL: rv_marker_2_select:
 ; SELDAG:        cinc  w0, w8, eq
 ; GISEL:         csinc w0, w8, wzr, eq
 ; CHECK-NEXT:    bl  foo0
-; SELDAG-NEXT:   mov x29, x29
-; SELDAG-NEXT:   bl objc_retainAutoreleasedReturnValue
+; CHECK-NEXT:   mov x29, x29
+; CHECK-NEXT:   bl objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT:    ldr x30, [sp], #16
 ; CHECK-NEXT:    b  foo2
 ;
 entry:
   %tobool.not = icmp eq i32 %c, 0
   %.sink = select i1 %tobool.not, i32 2, i32 1
   %call1 = call i8* @foo0(i32 %.sink) [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   tail call void @foo2(i8* %call1)
   ret void
 }
 
 define dso_local void @rv_marker_3() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: rv_marker_3
 ; CHECK:         .cfi_offset w30, -32
 ; CHECK-NEXT:    bl  foo1
-; SELDAG-NEXT:   mov x29, x29
-; SELDAG-NEXT:   bl objc_retainAutoreleasedReturnValue
+; CHECK-NEXT:   mov x29, x29
+; CHECK-NEXT:   bl objc_retainAutoreleasedReturnValue
 ;
 entry:
   %call = call i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   invoke void @objc_object(i8* %call) #5
           to label %invoke.cont unwind label %lpad
 
 invoke.cont:                                      ; preds = %entry
   tail call void @llvm.objc.release(i8* %call)
   ret void
 
 lpad:                                             ; preds = %entry
   %0 = landingpad { i8*, i32 }
           cleanup
   tail call void @llvm.objc.release(i8* %call)
   resume { i8*, i32 } %0
 }
 
 define dso_local void @rv_marker_4() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
 ; CHECK-LABEL: rv_marker_4
 ; CHECK:       .Ltmp3:
 ; CHECK-NEXT:     bl  foo1
-; SELDAG-NEXT:    mov x29, x29
-; SELDAG-NEXT:    bl objc_retainAutoreleasedReturnValue
+; CHECK-NEXT:    mov x29, x29
+; CHECK-NEXT:    bl objc_retainAutoreleasedReturnValue
 ; CHECK-NEXT: .Ltmp4:
 ;
 entry:
   %s = alloca %struct.S, align 1
   %0 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0
   call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %0) #2
   %call = invoke i8* @foo1() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
           to label %invoke.cont unwind label %lpad
ehcleanup:                                        ; preds = %lpad1, %lpad
   call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %0)
   resume { i8*, i32 } %.pn
 }
 
 define dso_local i8* @rv_marker_5_indirect_call() {
 ; CHECK-LABEL: rv_marker_5_indirect_call
 ; CHECK:         ldr [[ADDR:x[0-9]+]], [
 ; CHECK-NEXT:    blr [[ADDR]]
-; SELDAG-NEXT:   mov x29, x29
-; SELDAG-NEXT:   bl objc_retainAutoreleasedReturnValue
-; GISEL-NOT:     mov x29, x29
-;
+; CHECK-NEXT:   mov x29, x29
+; CHECK-NEXT:   bl objc_retainAutoreleasedReturnValue
 entry:
   %0 = load i8* ()*, i8* ()** @fptr, align 8
   %call = call i8* %0() [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   tail call void @foo2(i8* %call)
   ret i8* %call
 }
 
 declare i8* @foo(i64, i64, i64)
 
 define dso_local void @rv_marker_multiarg(i64 %a, i64 %b, i64 %c) {
 ; CHECK-LABEL: rv_marker_multiarg
 ; CHECK:        mov [[TMP:x[0-9]+]], x0
 ; CHECK-NEXT:   mov x0, x2
 ; CHECK-NEXT:   mov x2, [[TMP]]
 ; CHECK-NEXT:   bl  foo
-; SELDAG-NEXT:  mov x29, x29
-; SELDAG-NEXT:  bl objc_retainAutoreleasedReturnValue
-; GISEL-NOT:    mov x29, x29
+; CHECK-NEXT:  mov x29, x29
+; CHECK-NEXT:  bl objc_retainAutoreleasedReturnValue
   call i8* @foo(i64 %c, i64 %b, i64 %a) [ "clang.arc.attachedcall"(i8* (i8*)* @objc_retainAutoreleasedReturnValue) ]
   ret void
 }
 
 declare i8* @objc_retainAutoreleasedReturnValue(i8*)
 declare i8* @objc_unsafeClaimAutoreleasedReturnValue(i8*)
 declare i32 @__gxx_personality_v0(...)