[CGP] Consider arguments and ret values in dupRetToEnableTailCallOpts

Hint further tail call optimization opportunities when the examined
returned value is either the return value of a call instruction, or
a function argument. Moreover, take into account the cases in which
incoming values from phi-nodes, not directly tail call instructions,
may still be simplified.

Fixes: #75455.

Author: antoniofrighetto

llvm/lib/CodeGen/CodeGenPrepare.cpp

@@ -2524,7 +2524,8 @@ bool CodeGenPrepare::optimizeCallInst(CallInst *CI, ModifyDT &ModifiedDT) {
 }
 
 /// Look for opportunities to duplicate return instructions to the predecessor
-/// to enable tail call optimizations. The case it is currently looking for is:
+/// to enable tail call optimizations. The case it is currently looking for are
+/// simple return of call values, function arguments, or phi nodes as follows:
 /// @code
 /// bb0:
 ///   %tmp0 = tail call i32 @f0()
@@ -2581,7 +2582,7 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB,
     }
 
     PN = dyn_cast<PHINode>(V);
-    if (!PN)
+    if (!PN && !isa<Argument>(V) && !isa<CallInst>(V))
       return false;
   }
 
@@ -2621,8 +2622,38 @@ bool CodeGenPrepare::dupRetToEnableTailCallOpts(BasicBlock *BB,
       // Make sure the phi value is indeed produced by the tail call.
       if (CI && CI->hasOneUse() && CI->getParent() == PredBB &&
           TLI->mayBeEmittedAsTailCall(CI) &&
-          attributesPermitTailCall(F, CI, RetI, *TLI))
+          attributesPermitTailCall(F, CI, RetI, *TLI)) {
         TailCallBBs.push_back(PredBB);
+      } else {
+        /// Consider the cases in which the phi value is indirectly produced by
+        /// the tail call, for example when encountering memset(), memmove(),
+        /// whose return value may have been optimized out.
+        /// @code
+        /// bb0:
+        ///   tail call void @llvm.memset.p0.i64()
+        ///   br label %return
+        /// @endcode
+        if (PredBB && PredBB->getSingleSuccessor() == BB)
+          CI = dyn_cast_or_null<CallInst>(
+              PredBB->getTerminator()->getPrevNonDebugInstruction(true));
+
+        // If we return void from the call site, it must be an intrinsic.
+        if (CI && CI->getType()->isVoidTy() && !isa<IntrinsicInst>(CI))
+          continue;
+
+        /// If we return a value, it must not be used. A valid case may be when
+        /// strcpy()'ing, where its first argument is used in the phi-node.
+        /// @code
+        /// bb0:
+        ///   %1 = tail call ptr @strcpy()
+        ///   br label %return
+        /// @endcode
+        if (CI && CI->use_empty() && CI->hasArgument(IncomingVal) &&
+            IncomingVal == CI->getArgOperand(0) &&
+            TLI->mayBeEmittedAsTailCall(CI) &&
+            attributesPermitTailCall(F, CI, RetI, *TLI))
+          TailCallBBs.push_back(PredBB);
+      }
     }
   } else {
     SmallPtrSet<BasicBlock *, 4> VisitedBBs;

llvm/test/CodeGen/Thumb2/constant-islands-cbz.ll

@@ -8,12 +8,11 @@ define ptr @test(ptr returned %this, i32 %event_size, ptr %event_pointer) {
 ; CHECK-T1-NEXT:    .save {r4, lr}
 ; CHECK-T1-NEXT:    push {r4, lr}
 ; CHECK-T1-NEXT:    mov r4, r0
-; CHECK-T1-NEXT:    movs r0, #0
-; CHECK-T1-NEXT:    str r0, [r4, #4]
-; CHECK-T1-NEXT:    str r0, [r4, #8]
-; CHECK-T1-NEXT:    str r0, [r4, #12]
-; CHECK-T1-NEXT:    str r0, [r4, #16]
-; CHECK-T1-NEXT:    mov r0, r4
+; CHECK-T1-NEXT:    movs r3, #0
+; CHECK-T1-NEXT:    str r3, [r0, #4]
+; CHECK-T1-NEXT:    str r3, [r0, #8]
+; CHECK-T1-NEXT:    str r3, [r0, #12]
+; CHECK-T1-NEXT:    str r3, [r0, #16]
 ; CHECK-T1-NEXT:    cbz r2, .LBB0_2
 ; CHECK-T1-NEXT:  @ %bb.1: @ %if.else
 ; CHECK-T1-NEXT:    bl equeue_create_inplace
@@ -28,11 +27,10 @@ define ptr @test(ptr returned %this, i32 %event_size, ptr %event_pointer) {
 ; CHECK-T2:       @ %bb.0: @ %entry
 ; CHECK-T2-NEXT:    .save {r4, lr}
 ; CHECK-T2-NEXT:    push {r4, lr}
+; CHECK-T2-NEXT:    movs r3, #0
 ; CHECK-T2-NEXT:    mov r4, r0
-; CHECK-T2-NEXT:    movs r0, #0
-; CHECK-T2-NEXT:    strd r0, r0, [r4, #4]
-; CHECK-T2-NEXT:    strd r0, r0, [r4, #12]
-; CHECK-T2-NEXT:    mov r0, r4
+; CHECK-T2-NEXT:    strd r3, r3, [r0, #4]
+; CHECK-T2-NEXT:    strd r3, r3, [r0, #12]
 ; CHECK-T2-NEXT:    cbz r2, .LBB0_2
 ; CHECK-T2-NEXT:  @ %bb.1: @ %if.else
 ; CHECK-T2-NEXT:    bl equeue_create_inplace

llvm/test/CodeGen/X86/tailcall-cgp-dup.ll

@@ -188,18 +188,14 @@ return:
 define ptr @memset_tailc(ptr %ret_val, i64 %sz) {
 ; CHECK-LABEL: memset_tailc:
 ; CHECK:  ## %bb.0: ## %entry
-; CHECK:    pushq %rbx
-; CHECK:    movq %rdi, %rbx
 ; CHECK:    testq %rdi, %rdi
-; CHECK:    je LBB4_2
-; CHECK:  ## %bb.1: ## %if.then
+; CHECK:    je LBB4_1
+; CHECK:  ## %bb.2: ## %if.then
 ; CHECK:    movq %rsi, %rdx
-; CHECK:    movq %rbx, %rdi
 ; CHECK:    xorl %esi, %esi
-; CHECK:    callq _memset
-; CHECK:  LBB4_2: ## %return
-; CHECK:    movq %rbx, %rax
-; CHECK:    popq %rbx
+; CHECK:    jmp _memset ## TAILCALL
+; CHECK:  LBB4_1: ## %return
+; CHECK:    movq %rdi, %rax
 ; CHECK:    retq
 entry:
   %cmp = icmp eq ptr %ret_val, null
@@ -216,21 +212,15 @@ return:
 define ptr @memcpy_tailc(ptr %ret_val, i64 %sz, ptr %src) {
 ; CHECK-LABEL: memcpy_tailc:
 ; CHECK:  ## %bb.0: ## %entry
-; CHECK:    pushq %rbx
 ; CHECK:    testq %rsi, %rsi
 ; CHECK:    je LBB5_1
 ; CHECK:  ## %bb.2: ## %if.then
 ; CHECK:    movq %rsi, %rax
-; CHECK:    movq %rdi, %rbx
 ; CHECK:    movq %rdx, %rsi
 ; CHECK:    movq %rax, %rdx
-; CHECK:    callq _memcpy
-; CHECK:    jmp LBB5_3
-; CHECK:  LBB5_1:
-; CHECK:    movq %rdx, %rbx
-; CHECK:  LBB5_3: ## %return
-; CHECK:    movq %rbx, %rax
-; CHECK:    popq %rbx
+; CHECK:    jmp _memcpy ## TAILCALL
+; CHECK:  LBB5_1: ## %return
+; CHECK:    movq %rdx, %rax
 ; CHECK:    retq
 entry:
   %cmp = icmp eq i64 %sz, 0
@@ -256,13 +246,15 @@ define ptr @strcpy_tailc(i64 %0, ptr %src) {
 ; CHECK:    movl $20, %edi
 ; CHECK:    callq _malloc
 ; CHECK:    testq %r14, %r14
-; CHECK:    je LBB6_2
-; CHECK:  ## %bb.1: ## %if.then
+; CHECK:    je LBB6_1
+; CHECK:  ## %bb.2: ## %if.then
 ; CHECK:    movq %rax, %rdi
 ; CHECK:    movq %rbx, %rsi
-; CHECK:    movq %rax, %rbx
-; CHECK:    callq _strcpy
-; CHECK:  LBB6_2: ## %return
+; CHECK:    addq $8, %rsp
+; CHECK:    popq %rbx
+; CHECK:    popq %r14
+; CHECK:    jmp _strcpy ## TAILCALL
+; CHECK:  LBB6_1: ## %return
 ; CHECK:    movq %rbx, %rax
 ; CHECK:    addq $8, %rsp
 ; CHECK:    popq %rbx

llvm/test/DebugInfo/X86/live-debug-values-expr-conflict.ll

@@ -24,18 +24,18 @@
 ; one in the block two, and none in block three.
 ; CHECK:       ![[BAZVAR:[0-9]+]] = !DILocalVariable(name: "baz",
 ; CHECK-LABEL: bb.0.entry:
-; CHECK:       DBG_VALUE {{[0-9a-zA-Z$%_]*}}, $noreg, ![[BAZVAR]], 
+; CHECK:       DBG_VALUE {{[0-9a-zA-Z$%_]*}}, $noreg, ![[BAZVAR]], 
 ; CHECK-SAME:     !DIExpression()
 ; CHECK-LABEL: bb.1.if.then:
-; CHECK-LABEL: bb.2.if.else:
-; CHECK:       DBG_VALUE {{[0-9a-zA-Z$%_]*}}, $noreg, ![[BAZVAR]], 
+; CHECK-LABEL: bb.3.if.else:
+; CHECK:       DBG_VALUE {{[0-9a-zA-Z$%_]*}}, $noreg, ![[BAZVAR]], 
 ; CHECK-SAME:     !DIExpression()
-; CHECK:       DBG_VALUE_LIST ![[BAZVAR]], 
-; CHECK-SAME:     !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 1, DW_OP_stack_value)
-; CHECK-SAME:     {{[0-9a-zA-Z$%_]*}}
-; CHECK-LABEL: bb.3.if.end:
+; CHECK:       DBG_VALUE_LIST ![[BAZVAR]], 
+; CHECK-SAME:     !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 1, DW_OP_stack_value)
+; CHECK-SAME:     {{[0-9a-zA-Z$%_]*}}
+; CHECK-LABEL: bb.2.if.then:
 ; CHECK-NOT:   DBG_VALUE
-; CHECK-NOT:   DBG_VALUE_LIST
+; CHECK-NOT:   DBG_VALUE_LIST
 
 declare void @escape1(i32)
 declare void @escape2(i32)