; This test contains extremely tricky call graph structures for the inliner to
; handle correctly. They form cycles where the inliner introduces code that is
; immediately or can eventually be transformed back into the original code. And
; each step changes the call graph and so will trigger iteration. This requires
; some out-of-band way to prevent infinitely re-inlining and re-transforming the
; code.
;
; RUN: opt < %s -passes='cgscc(inline,function(sroa,instcombine))' -inline-threshold=50 -S | FileCheck %s


; The `test1_*` collection of functions form a directly cycling pattern.

define void @test1_a(ptr %ptr) {
; CHECK-LABEL: define void @test1_a(
entry:
  call void @test1_b(ptr @test1_b, i1 false, i32 0)
; Inlining and simplifying this call will reliably produce the exact same call,
; over and over again. However, each inlining increments the count, and so we
; expect this test case to stop after one round of inlining with a final
; argument of '1'.
; CHECK-NOT:     call
; CHECK:         call void @test1_b(ptr nonnull @test1_b, i1 false, i32 1)
; CHECK-NOT:     call

  ret void
}

define void @test1_b(ptr %arg, i1 %flag, i32 %inline_count) {
; CHECK-LABEL: define void @test1_b(
entry:
  %a = alloca ptr
  store ptr %arg, ptr %a
; This alloca and store should remain through any optimization.
; CHECK:         %[[A:.*]] = alloca
; CHECK:         store ptr %arg, ptr %[[A]]

  br i1 %flag, label %bb1, label %bb2

bb1:
  call void @test1_a(ptr %a) noinline
  br label %bb2

bb2:
  %p = load ptr, ptr %a
  %inline_count_inc = add i32 %inline_count, 1
  call void %p(ptr %arg, i1 %flag, i32 %inline_count_inc)
; And we should continue to load and call indirectly through optimization.
; CHECK:         %[[P:.*]] = load ptr, ptr %[[A]]
; CHECK:         call void %[[P]](

  ret void
}

define void @test2_a(ptr %ptr) {
; CHECK-LABEL: define void @test2_a(
entry:
  call void @test2_b(ptr @test2_b, ptr @test2_c, i1 false, i32 0)
; Inlining and simplifying this call will reliably produce the exact same call,
; but only after doing two rounds if inlining, first from @test2_b then
; @test2_c. We check the exact number of inlining rounds before we cut off to
; break the cycle by inspecting the last paramater that gets incremented with
; each inlined function body.
; CHECK-NOT:     call
; CHECK:         call void @test2_b(ptr nonnull @test2_b, ptr nonnull @test2_c, i1 false, i32 2)
; CHECK-NOT:     call
  ret void
}

define void @test2_b(ptr %arg1, ptr %arg2, i1 %flag, i32 %inline_count) {
; CHECK-LABEL: define void @test2_b(
entry:
  %a = alloca ptr
  store ptr %arg2, ptr %a
; This alloca and store should remain through any optimization.
; CHECK:         %[[A:.*]] = alloca
; CHECK:         store ptr %arg2, ptr %[[A]]

  br i1 %flag, label %bb1, label %bb2

bb1:
  call void @test2_a(ptr %a) noinline
  br label %bb2

bb2:
  %p = load ptr, ptr %a
  %inline_count_inc = add i32 %inline_count, 1
  call void %p(ptr %arg1, ptr %arg2, i1 %flag, i32 %inline_count_inc)
; And we should continue to load and call indirectly through optimization.
; CHECK:         %[[P:.*]] = load ptr, ptr %[[A]]
; CHECK:         call void %[[P]](

  ret void
}

define void @test2_c(ptr %arg1, ptr %arg2, i1 %flag, i32 %inline_count) {
; CHECK-LABEL: define void @test2_c(
entry:
  %a = alloca ptr
  store ptr %arg1, ptr %a
; This alloca and store should remain through any optimization.
; CHECK:         %[[A:.*]] = alloca
; CHECK:         store ptr %arg1, ptr %[[A]]

  br i1 %flag, label %bb1, label %bb2

bb1:
  call void @test2_a(ptr %a) noinline
  br label %bb2

bb2:
  %p = load ptr, ptr %a
  %inline_count_inc = add i32 %inline_count, 1
  call void %p(ptr %arg1, ptr %arg2, i1 %flag, i32 %inline_count_inc)
; And we should continue to load and call indirectly through optimization.
; CHECK:         %[[P:.*]] = load ptr, ptr %[[A]]
; CHECK:         call void %[[P]](

  ret void
}

; Another infinite inlining case. The initial callgraph is like following:
;
;         test3_a <---> test3_b
;             |         ^
;             v         |
;         test3_c <---> test3_d
;
; For all the call edges in the call graph, only test3_c and test3_d can be
; inlined into test3_a, and no other call edge can be inlined.
;
; After test3_c is inlined into test3_a, the original call edge test3_a->test3_c
; will be removed, a new call edge will be added and the call graph becomes:
;
;            test3_a <---> test3_b
;                  \      ^
;                   v    /
;     test3_c <---> test3_d
; But test3_a, test3_b, test3_c and test3_d still belong to the same SCC.
;
; Then after test3_a->test3_d is inlined, when test3_a->test3_d is converted to
; a ref edge, the original SCC will be split into two: {test3_c, test3_d} and
; {test3_a, test3_b}, immediately after the newly added ref edge
; test3_a->test3_c will be converted to a call edge, and the two SCCs will be
; merged into the original one again. During this cycle, the original SCC will
; be added into UR.CWorklist again and this creates an infinite loop.

@a = global i64 0
@b = global i64 0

; Check test3_c is inlined into test3_a once and only once.
; CHECK-LABEL: @test3_a(
; CHECK: tail call void @test3_b()
; CHECK-NEXT: tail call void @test3_d(i32 5)
; CHECK-NEXT: %[[LD1:.*]] = load i64, ptr @a
; CHECK-NEXT: %[[ADD1:.*]] = add nsw i64 %[[LD1]], 1
; CHECK-NEXT: store i64 %[[ADD1]], ptr @a
; CHECK-NEXT: %[[LD2:.*]] = load i64, ptr @b
; CHECK-NEXT: %[[ADD2:.*]] = add nsw i64 %[[LD2]], 5
; CHECK-NEXT: store i64 %[[ADD2]], ptr @b
; CHECK-NEXT: ret void

; Function Attrs: noinline
define void @test3_a() #0 {
entry:
  tail call void @test3_b()
  tail call void @test3_c(i32 5)
  %t0 = load i64, ptr @b
  %add = add nsw i64 %t0, 5
  store i64 %add, ptr @b
  ret void
}

; Function Attrs: noinline
define void @test3_b() #0 {
entry:
  tail call void @test3_a()
  %t0 = load i64, ptr @a
  %add = add nsw i64 %t0, 2
  store i64 %add, ptr @a
  ret void
}

define void @test3_d(i32 %i) {
entry:
  %cmp = icmp eq i32 %i, 5
  br i1 %cmp, label %if.end, label %if.then

if.then:                                          ; preds = %entry
  %call = tail call i64 @random()
  %t0 = load i64, ptr @a
  %add = add nsw i64 %t0, %call
  store i64 %add, ptr @a
  br label %if.end

if.end:                                           ; preds = %entry, %if.then
  tail call void @test3_c(i32 %i)
  tail call void @test3_b()
  %t6 = load i64, ptr @a
  %add79 = add nsw i64 %t6, 3
  store i64 %add79, ptr @a
  ret void
}

define void @test3_c(i32 %i) {
entry:
  %cmp = icmp eq i32 %i, 5
  br i1 %cmp, label %if.end, label %if.then

if.then:                                          ; preds = %entry
  %call = tail call i64 @random()
  %t0 = load i64, ptr @a
  %add = add nsw i64 %t0, %call
  store i64 %add, ptr @a
  br label %if.end

if.end:                                           ; preds = %entry, %if.then
  tail call void @test3_d(i32 %i)
  %t6 = load i64, ptr @a
  %add85 = add nsw i64 %t6, 1
  store i64 %add85, ptr @a
  ret void
}

declare i64 @random()

attributes #0 = { noinline }