test/Transforms/Inline/inline-tail.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=inline -S | FileCheck %s

; We have to apply the less restrictive TailCallKind of the call site being
; inlined and any call sites cloned into the caller.

; No tail marker after inlining, since test_capture_c captures an alloca.
declare void @test_capture_c(ptr)
define internal void @test_capture_b(ptr %P) {
  tail call void @test_capture_c(ptr %P)
  ret void
}
define void @test_capture_a() {
; CHECK-LABEL: define void @test_capture_a() {
; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
; CHECK-NEXT:    call void @test_capture_c(ptr [[A]])
; CHECK-NEXT:    ret void
;
  %A = alloca i32  		; captured by test_capture_b
  call void @test_capture_b(ptr %A)
  ret void
}

; No musttail marker after inlining, since the prototypes don't match.
declare void @test_proto_mismatch_c(ptr)
define internal void @test_proto_mismatch_b(ptr %p) {
  musttail call void @test_proto_mismatch_c(ptr %p)
  ret void
}
define void @test_proto_mismatch_a() {
; CHECK-LABEL: define void @test_proto_mismatch_a() {
; CHECK-NEXT:    call void @test_proto_mismatch_c(ptr null)
; CHECK-NEXT:    ret void
;
  call void @test_proto_mismatch_b(ptr null)
  ret void
}

; After inlining through a musttail call site, we need to keep musttail markers
; to prevent unbounded stack growth.
declare void @test_musttail_basic_c(ptr %p)
define internal void @test_musttail_basic_b(ptr %p) {
  musttail call void @test_musttail_basic_c(ptr %p)
  ret void
}
define void @test_musttail_basic_a(ptr %p) {
; CHECK-LABEL: define void @test_musttail_basic_a
; CHECK-SAME: (ptr [[P:%.*]]) {
; CHECK-NEXT:    musttail call void @test_musttail_basic_c(ptr [[P]])
; CHECK-NEXT:    ret void
;
  musttail call void @test_musttail_basic_b(ptr %p)
  ret void
}

; Don't insert lifetime end markers here, the lifetime is trivially over due
; the return.
declare void @test_byval_c(ptr byval(i32) %p)
define internal void @test_byval_b(ptr byval(i32) %p) {
  musttail call void @test_byval_c(ptr byval(i32) %p)
  ret void
}
define void @test_byval_a(ptr byval(i32) %p) {
; CHECK-LABEL: define void @test_byval_a
; CHECK-SAME: (ptr byval(i32) [[P:%.*]]) {
; CHECK-NEXT:    [[P1:%.*]] = alloca i32, align 4
; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[P1]])
; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[P1]], ptr align 1 [[P]], i64 4, i1 false)
; CHECK-NEXT:    musttail call void @test_byval_c(ptr byval(i32) [[P1]])
; CHECK-NEXT:    ret void
;
  musttail call void @test_byval_b(ptr byval(i32) %p)
  ret void
}

; Don't insert a stack restore, we're about to return.
declare void @escape(ptr %buf)
declare void @test_dynalloca_c(ptr byval(i32) %p, i32 %n)
define internal void @test_dynalloca_b(ptr byval(i32) %p, i32 %n) alwaysinline {
  %buf = alloca i8, i32 %n              ; dynamic alloca
  call void @escape(ptr %buf)           ; escape it
  musttail call void @test_dynalloca_c(ptr byval(i32) %p, i32 %n)
  ret void
}
define void @test_dynalloca_a(ptr byval(i32) %p, i32 %n) {
; CHECK-LABEL: define void @test_dynalloca_a
; CHECK-SAME: (ptr byval(i32) [[P:%.*]], i32 [[N:%.*]]) {
; CHECK-NEXT:    [[P1:%.*]] = alloca i32, align 4
; CHECK-NEXT:    [[SAVEDSTACK:%.*]] = call ptr @llvm.stacksave.p0()
; CHECK-NEXT:    call void @llvm.lifetime.start.p0(i64 4, ptr [[P1]])
; CHECK-NEXT:    call void @llvm.memcpy.p0.p0.i64(ptr align 1 [[P1]], ptr align 1 [[P]], i64 4, i1 false)
; CHECK-NEXT:    [[BUF_I:%.*]] = alloca i8, i32 [[N]], align 1
; CHECK-NEXT:    call void @escape(ptr [[BUF_I]])
; CHECK-NEXT:    musttail call void @test_dynalloca_c(ptr byval(i32) [[P1]], i32 [[N]])
; CHECK-NEXT:    ret void
;
  musttail call void @test_dynalloca_b(ptr byval(i32) %p, i32 %n)
  ret void
}

; We can't merge the returns.
declare void @test_multiret_c(i1 zeroext %b)
declare void @test_multiret_d(i1 zeroext %b)
define internal void @test_multiret_b(i1 zeroext %b) {
  br i1 %b, label %c, label %d
c:
  musttail call void @test_multiret_c(i1 zeroext %b)
  ret void
d:
  musttail call void @test_multiret_d(i1 zeroext %b)
  ret void
}
define void @test_multiret_a(i1 zeroext %b) {
; CHECK-LABEL: define void @test_multiret_a
; CHECK-SAME: (i1 zeroext [[B:%.*]]) {
; CHECK-NEXT:    br i1 [[B]], label [[C_I:%.*]], label [[D_I:%.*]]
; CHECK:       c.i:
; CHECK-NEXT:    musttail call void @test_multiret_c(i1 zeroext [[B]])
; CHECK-NEXT:    ret void
; CHECK:       d.i:
; CHECK-NEXT:    musttail call void @test_multiret_d(i1 zeroext [[B]])
; CHECK-NEXT:    ret void
;
  musttail call void @test_multiret_b(i1 zeroext %b)
  ret void
}

; We have to avoid bitcast chains.
declare ptr @test_retptr_c()
define internal ptr @test_retptr_b() {
  %rv = musttail call ptr @test_retptr_c()
  ret ptr %rv
}
define ptr @test_retptr_a() {
; CHECK-LABEL: define ptr @test_retptr_a() {
; CHECK-NEXT:    [[RV_I:%.*]] = musttail call ptr @test_retptr_c()
; CHECK-NEXT:    ret ptr [[RV_I]]
;
  %rv = musttail call ptr @test_retptr_b()
  ret ptr %rv
}

; Combine the last two cases: multiple returns with pointer bitcasts.
declare ptr @test_multiptrret_c(i1 zeroext %b)
declare ptr @test_multiptrret_d(i1 zeroext %b)
define internal ptr @test_multiptrret_b(i1 zeroext %b) {
  br i1 %b, label %c, label %d
c:
  %c_rv = musttail call ptr @test_multiptrret_c(i1 zeroext %b)
  ret ptr %c_rv
d:
  %d_rv = musttail call ptr @test_multiptrret_d(i1 zeroext %b)
  ret ptr %d_rv
}
define ptr @test_multiptrret_a(i1 zeroext %b) {
; CHECK-LABEL: define ptr @test_multiptrret_a
; CHECK-SAME: (i1 zeroext [[B:%.*]]) {
; CHECK-NEXT:    br i1 [[B]], label [[C_I:%.*]], label [[D_I:%.*]]
; CHECK:       c.i:
; CHECK-NEXT:    [[C_RV_I:%.*]] = musttail call ptr @test_multiptrret_c(i1 zeroext [[B]])
; CHECK-NEXT:    ret ptr [[C_RV_I]]
; CHECK:       d.i:
; CHECK-NEXT:    [[D_RV_I:%.*]] = musttail call ptr @test_multiptrret_d(i1 zeroext [[B]])
; CHECK-NEXT:    ret ptr [[D_RV_I]]
;
  %rv = musttail call ptr @test_multiptrret_b(i1 zeroext %b)
  ret ptr %rv
}

; Inline a musttail call site which contains a normal return and a musttail call.
declare i32 @test_mixedret_c(i1 zeroext %b)
declare i32 @test_mixedret_d(i1 zeroext %b)
define internal i32 @test_mixedret_b(i1 zeroext %b) {
  br i1 %b, label %c, label %d
c:
  %c_rv = musttail call i32 @test_mixedret_c(i1 zeroext %b)
  ret i32 %c_rv
d:
  %d_rv = call i32 @test_mixedret_d(i1 zeroext %b)
  %d_rv1 = add i32 1, %d_rv
  ret i32 %d_rv1
}
define i32 @test_mixedret_a(i1 zeroext %b) {
; CHECK-LABEL: define i32 @test_mixedret_a
; CHECK-SAME: (i1 zeroext [[B:%.*]]) {
; CHECK-NEXT:    br i1 [[B]], label [[C_I:%.*]], label [[TEST_MIXEDRET_B_EXIT:%.*]]
; CHECK:       c.i:
; CHECK-NEXT:    [[C_RV_I:%.*]] = musttail call i32 @test_mixedret_c(i1 zeroext [[B]])
; CHECK-NEXT:    ret i32 [[C_RV_I]]
; CHECK:       test_mixedret_b.exit:
; CHECK-NEXT:    [[D_RV_I:%.*]] = call i32 @test_mixedret_d(i1 zeroext [[B]])
; CHECK-NEXT:    [[D_RV1_I:%.*]] = add i32 1, [[D_RV_I]]
; CHECK-NEXT:    ret i32 [[D_RV1_I]]
;
  %rv = musttail call i32 @test_mixedret_b(i1 zeroext %b)
  ret i32 %rv
}

declare i32 @donttailcall()

define i32 @notail() {
; CHECK-LABEL: define i32 @notail() {
; CHECK-NEXT:    [[RV:%.*]] = notail call i32 @donttailcall()
; CHECK-NEXT:    ret i32 [[RV]]
;
  %rv = notail call i32 @donttailcall()
  ret i32 %rv
}

define i32 @test_notail() {
; CHECK-LABEL: define i32 @test_notail() {
; CHECK-NEXT:    [[RV_I:%.*]] = notail call i32 @donttailcall()
; CHECK-NEXT:    ret i32 [[RV_I]]
;
  %rv = tail call i32 @notail()
  ret i32 %rv
}

; PR31014: Inlining a musttail call through a notail call site should remove
; any tail marking, otherwise we break verifier invariants.

declare void @do_ret(i32)

define void @test_notail_inline_musttail(i32 %a) {
; CHECK-LABEL: define void @test_notail_inline_musttail
; CHECK-SAME: (i32 [[A:%.*]]) {
; CHECK-NEXT:    call void @do_ret(i32 [[A]])
; CHECK-NEXT:    musttail call void @do_ret(i32 [[A]])
; CHECK-NEXT:    ret void
;
  notail call void @inline_musttail(i32 %a)
  musttail call void @do_ret(i32 %a)
  ret void
}

define internal void @inline_musttail(i32 %a) {
  musttail call void @do_ret(i32 %a)
  ret void
}