test/Transforms/Inline/inline_call.ll

; Check the optimizer doesn't crash at inlining the function top and all of its callees are inlined.
; RUN: opt < %s -O3 -S | FileCheck %s

define dso_local ptr @second(ptr %p) {
entry:
  %p.addr = alloca ptr, align 8
  store ptr %p, ptr %p.addr, align 8
  %tmp = load ptr, ptr %p.addr, align 8
  %tmp1 = load ptr, ptr %tmp, align 8
  ret ptr %tmp1
}

define dso_local void @top()  {
entry:
  ; CHECK: {{.*}} = {{.*}} call {{.*}} @ext
  ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @third
  ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @second
  ; CHECK-NOT: {{.*}} = {{.*}} call {{.*}} @wrapper
  %q = alloca ptr, align 8
  store ptr @third, ptr %q, align 8
  %tmp = call ptr @second(ptr %q)
  ; The call to 'wrapper' here is to ensure that its function attributes
  ; i.e., returning its parameter and having no side effect, will be decuded
  ; before the next round of inlining happens to 'top' to expose the bug.
  %call =  call ptr @wrapper(ptr %tmp) 
  ; The indirect call here is to confuse the alias analyzer so that
  ; an incomplete graph will be built during the first round of inlining.
  ; This allows the current function to be processed before the actual 
  ; callee, i.e., the function 'run', is processed. Once it's simplified to 
  ; a direct call, it also enables an additional round of inlining with all
  ; function attributes deduced. 
  call void (...) %call()
  ret void
}

define dso_local ptr @gen() {
entry:
  %call = call ptr (...) @ext()
  ret ptr %call
}

declare dso_local ptr @ext(...) 

define dso_local ptr @wrapper(ptr %fn) {
entry:
  ret ptr %fn
}

define dso_local void @run(ptr %fn) {
entry:
  %fn.addr = alloca ptr, align 8
  %f = alloca ptr, align 8
  store ptr %fn, ptr %fn.addr, align 8
  %tmp = load ptr, ptr %fn.addr, align 8
  %call = call ptr @wrapper(ptr %tmp)
  store ptr %call, ptr %f, align 8
  %tmp1 = load ptr, ptr %f, align 8
  call void (...) %tmp1()
  ret void
}

define dso_local void @third() {
entry:
  %f = alloca ptr, align 8
  %call = call ptr @gen()
  store ptr %call, ptr %f, align 8
  %tmp = load ptr, ptr %f, align 8
  call void @run(ptr %tmp)
  ret void
}