<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/104770>104770</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Unnecessary return statement generated by EmitFunctionEpiloge in musttail cases. 
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            clang,
            clang:codegen
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
            kiran-isaac
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          kiran-isaac
      </td>
    </tr>
</table>

<pre>
    When clang::musttail is used, and -O is not set, an extra "function epiloge" return case is generated. This seems to be optimized out at any -O level, and automatially optimized out by the backend. I believe this is the case for all musttail calls, but I have attatched a repro example for conveniance.

Reproduce: 
```cpp
int F1(signed short P0);
int F2(signed short P0) {
  [[clang::musttail]] return F1(2);
}
```
```bash
clang -S -emit-llvm
```
```
define dso_local noundef i32 @_Z2F2s(i16 noundef signext %P0) #0 {
entry:
 %P0.addr = alloca i16, align 2
  store i16 %P0, ptr %P0.addr, align 2
 %call = musttail call noundef i32 @_Z2F1s(i16 noundef signext 2)
  ret i32 %call

0:                                                ; No predecessors!
  ret i32 undef
}
```
The two calls to CreateRet are here:
`CodeGenFunction::EmitCall`
```c++
  // If this is a musttail call, return immediately. We do not branch to the
  // epilogue in this case.
  if (IsMustTail) {
    for (auto it = EHStack.find(CurrentCleanupScopeDepth); it != EHStack.end();
 ++it) {
      EHCleanupScope *Cleanup = dyn_cast<EHCleanupScope>(&*it);
      if (!(Cleanup && Cleanup->getCleanup()->isRedundantBeforeReturn()))
 CGM.ErrorUnsupported(MustTailCall, "tail call skipping over cleanups");
 }
    if (CI->getType()->isVoidTy())
 Builder.CreateRetVoid();
    else
      Builder.CreateRet(CI);
 Builder.ClearInsertionPoint();
    EnsureInsertPoint();
    return GetUndefRValue(RetTy);
  }
```
and here
`CodeGenFunction::EmitFunctionEpilog`
```c++
case ABIArgInfo::IndirectAliased:
    llvm_unreachable("Invalid ABI kind for return argument");
  }

  llvm::Instruction *Ret;
  if (RV) {
    if (CurFuncDecl && CurFuncDecl->hasAttr<CmseNSEntryAttr>()) {
 // For certain return types, clear padding bits, as they may reveal
 // sensitive information.
      // Small struct/union types are passed as integers.
      auto *ITy = dyn_cast<llvm::IntegerType>(RV->getType());
      if (ITy != nullptr && isa<RecordType>(RetTy.getCanonicalType()))
        RV = EmitCMSEClearRecord(RV, ITy, RetTy);
    }
 EmitReturnValueCheck(RV);
    Ret = Builder.CreateRet(RV);
  } else {
    Ret = Builder.CreateRetVoid();
  }
```

I suggest that EmitFunctionEpilog should not be called for a musttail function, as the body definitely already contains a return.
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJyUV19v6rgS_zTmZdQIHAr0gQca4CwPZ--K9nSl-3LkxAPxrbEje8I93E9_ZTtAKO2uNopAceaPZ_z7zUyE92pvEOfs8Zlx_q6cMA_KC1ExztnjciBaqq2b914MSitP8z9rNFBpYfYsX7B8cWg9kVAalIfWo2S8AGEkPPwrrBhL4JHSIuAvcgIY57vWVKSsAWyUtntknINDap2BSngMmns06AShzOC1Vh484sEDWSgRbEPqoP6HEmxLIAiEOQWHGo-ozxsQLdmDICW0Pn3QKE9ANUIpqnc0MoMNlKgVHhEouFI-vo472VkHQmu4hFkJrX3wUbYEG6jFEUEQCapqlCDAYeMs4C9xaHRSr6w5olHCVJix4ZINF-l3GyRlWyHLF9C9mAzTXTVNWlGGYD1ifBaPS4KvrSP4Y8j4E8ufezL8Uxlg004IIJz04_MnR8cel-xxeT6A6I337bPp8sP2PjyWwtdpKVqHhxd4wIOiB62Ph79WTY8Sd8ogSG9_alsJDca2RuIOVM6BjYc__83X3DM-U6PJ5V2M9hcB449drDwfXgNGQ-4UAk3hR6lMSOmA5ctwprYSoEaTiBet9gb4OVOerMPw7my7gIZcz8S9DuOPARnR9g1WPgtl9FUoMe3dJhxS0kmW-8gZBsT8w4vlz_C7hcahxAq9t84zPvroLG7nr0_9tUag_9pEhEDIwqEg3CKBcAg1OrxknU2GhZX4Dc26Y3xC3uqgqAhB3eGhYvw53GfM8jXja9jsLswUt-kNJ9EBVx0OKJUg1KcM_kSQNpaf0glT1WGjVOMHu6n8tAjKJAeB89lZSO2A8dnGf289vQae3PIJIrsZn4VKA4ri2a9-eyFRvWc7ZSTjs6J1Dg0VGoVpm5fKNrjEhupEr6jER309jGp99kHKiKI79wCr3_qWgfFF9xz3Ik_mZyU8sby4FWT5KjqZML6Idq_O4pUCDzvjs4vBID2B7vGB5as9nuNKOw5rym9RtkYKQ8-4sy7AonWmCyndyVHx7Xu2cs66H8a3TWMdhd4xO-e66M6WcX6lkn9XTaPMHuwRHVTJuQ8N6yZfZ-BeQyk23YZfTw32d_tmlXw9XbeX9J5bpSW67ILsIPbxWAAAtcd-3u70ousbrYuIRuE2xqMLrPjDKkOfOFgZ3zpMYl_JdOj_hvQjkHf7JnQbYtyGaG-Fv6J0aJeRt39L2vPKKhLnb-gbG-jiebNw-43Z2WRlY6RyWNFCKxHGhUuBBoDQLn62xqGoalHqdFJ8Y45CKxkswbsyMtKui1q4fXvAkBf-VajdQmxF3Q48uTbNH4wvwjFd9RJetm93ZOuA1LqQgiVW-sKI61LAVC38gsixvCgOHn9_WYU2lFZWF5z1THeVaB0GBXQklDnHRqcG46QRgO6gEVIG7JeK4qqIU8oJDuIEDo8o9K1Fj8YrUsdQ3HbWhVHImqwP107w5RC5FXPC-Lo1ITHReSzojfA-TDYelCHco_M3RmLxY3yxeT19LDr9lEfNyL6Yhu3bHSG_KkPRcCqSptU6NeKYeeUFy4stVtbJnulgNAvFSRhrVCX0rY9rh03X9i0V7tCSvr-sIjGTzQ4IBWwCkQr4hFE9oEULqdxFChY1Vu9nLN2ohFYZXH5WLj5Ks-kylplbMH5p4dNC9eX8Fn834Nv9Hj0B1YLgnuVhnmy1TM0UYyXGRMJeLz5P9FdkQvhcgDjZqdCTQWiHQp7CPBxg7uOwHNKVDeQ8l0_5kxjgfDTl4-F0lD9OB_U8n5azp52sRPVUTnYyr3aTSVlNRmM-3pWzp3yg5nzIx8PZ6GnExzyfZnmOs3EleM53vOTjCRsP8SCUzgIYM-v2A-V9i_PRcDydDgdalKh99xGURuNQSYrLU76orMQ9mu6zyM2DoYey3Xs2HmrlyV9NkyKN8x_GxAlLuNOZyp4EYahT18-a8BFyn-s4ifQGHI8-g0Hr9LwmanxgUyTtXlHdllllD4yvI8_S30Pj7H8w8jjG6Rlfd6Ee5_z_AQAA___fcykM">