; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 -filetype=asm < %s | FileCheck %s --check-prefix=DEFAULT
; RUN: llc -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 -amdgpu-enable-object-linking -filetype=asm < %s | FileCheck %s --check-prefix=OL

declare void @extern_callee()

define void @calls_extern() {
  call void @extern_callee()
  ret void
}

define void @calls_indirect(ptr %fptr) {
  call void %fptr()
  ret void
}

define void @calls_local() {
  ret void
}

define amdgpu_kernel void @my_kernel(ptr %fptr) {
  call void @calls_extern()
  call void @calls_indirect(ptr %fptr)
  call void @calls_local()
  ret void
}

; COM: Default mode: direct-to-extern triggers the conservative "unknown
; COM: callee" path. Register/stack-size symbols include the module-level
; COM: sinks; boolean flags are all forced to 1; HasIndirectCall is set too
; COM: (IsIndirect covers calls to declarations).
; DEFAULT:       .set .Lcalls_extern.num_vgpr, max({{[0-9]+}}, amdgpu.max_num_vgpr)
; DEFAULT:       .set .Lcalls_extern.num_agpr, max({{[0-9]+}}, amdgpu.max_num_agpr)
; DEFAULT:       .set .Lcalls_extern.numbered_sgpr, max({{[0-9]+}}, amdgpu.max_num_sgpr)
; DEFAULT:       .set .Lcalls_extern.num_named_barrier, max({{[0-9]+}}, amdgpu.max_num_named_barrier)
; DEFAULT:       .set .Lcalls_extern.uses_vcc, 1
; DEFAULT:       .set .Lcalls_extern.uses_flat_scratch, 1
; DEFAULT:       .set .Lcalls_extern.has_dyn_sized_stack, 1
; DEFAULT:       .set .Lcalls_extern.has_recursion, 1
; DEFAULT:       .set .Lcalls_extern.has_indirect_call, 1

; COM: Object linking: the same function reports only its own local usage.
; COM: The sinks drop out of the register/stack-size expressions and the
; COM: pessimized boolean flags collapse to the true local values (UsesVCC is
; COM: still 1 here because the call-site lowering on gfx900 genuinely uses
; COM: VCC).
; OL:            .set .Lcalls_extern.num_vgpr, {{[0-9]+}}
; OL:            .set .Lcalls_extern.num_agpr, {{[0-9]+}}
; OL:            .set .Lcalls_extern.numbered_sgpr, {{[0-9]+}}
; OL:            .set .Lcalls_extern.num_named_barrier, {{[0-9]+}}
; OL:            .set .Lcalls_extern.uses_vcc, 1
; OL:            .set .Lcalls_extern.uses_flat_scratch, 0
; OL:            .set .Lcalls_extern.has_dyn_sized_stack, 0
; OL:            .set .Lcalls_extern.has_recursion, 0
; OL:            .set .Lcalls_extern.has_indirect_call, 1

; COM: True indirect call: same DEFAULT-vs-OL behavior as the direct-to-extern
; COM: case above. In DEFAULT mode all the flags are pessimized; with object
; COM: linking only HasIndirectCall is preserved (the linker sees the call
; COM: site's typeid and address-taken set and handles propagation).
; DEFAULT:       .set .Lcalls_indirect.uses_vcc, 1
; DEFAULT:       .set .Lcalls_indirect.uses_flat_scratch, 1
; DEFAULT:       .set .Lcalls_indirect.has_dyn_sized_stack, 1
; DEFAULT:       .set .Lcalls_indirect.has_recursion, 1
; DEFAULT:       .set .Lcalls_indirect.has_indirect_call, 1

; OL:            .set .Lcalls_indirect.uses_vcc, 1
; OL:            .set .Lcalls_indirect.uses_flat_scratch, 0
; OL:            .set .Lcalls_indirect.has_dyn_sized_stack, 0
; OL:            .set .Lcalls_indirect.has_recursion, 0
; OL:            .set .Lcalls_indirect.has_indirect_call, 1

; COM: Baseline: a function that makes no calls outside itself reports the
; COM: same all-zero local flags in both modes.
; DEFAULT:       .set .Lcalls_local.uses_vcc, 0
; DEFAULT:       .set .Lcalls_local.uses_flat_scratch, 0
; DEFAULT:       .set .Lcalls_local.has_dyn_sized_stack, 0
; DEFAULT:       .set .Lcalls_local.has_recursion, 0
; DEFAULT:       .set .Lcalls_local.has_indirect_call, 0

; OL:            .set .Lcalls_local.uses_vcc, 0
; OL:            .set .Lcalls_local.uses_flat_scratch, 0
; OL:            .set .Lcalls_local.has_dyn_sized_stack, 0
; OL:            .set .Lcalls_local.has_recursion, 0
; OL:            .set .Lcalls_local.has_indirect_call, 0

; COM: Kernel side of the DEFAULT-vs-OL comparison. DEFAULT mode emits
; COM: call-graph-propagation expressions (max()/or() over every callee's
; COM: symbols) so the kernel picks up its callees' pessimized values; object
; COM: linking emits concrete literals and leaves cross-TU aggregation to the
; COM: linker.
; DEFAULT:       .set .Lmy_kernel.num_vgpr, max({{[0-9]+}}, .Lcalls_extern.num_vgpr, .Lcalls_indirect.num_vgpr, .Lcalls_local.num_vgpr)
; DEFAULT:       .set .Lmy_kernel.num_agpr, max({{[0-9]+}}, .Lcalls_extern.num_agpr, .Lcalls_indirect.num_agpr, .Lcalls_local.num_agpr)
; DEFAULT:       .set .Lmy_kernel.num_named_barrier, max({{[0-9]+}}, .Lcalls_extern.num_named_barrier, .Lcalls_indirect.num_named_barrier, .Lcalls_local.num_named_barrier)
; DEFAULT:       .set .Lmy_kernel.private_seg_size, {{[0-9]+}}+max(.Lcalls_extern.private_seg_size, .Lcalls_indirect.private_seg_size, .Lcalls_local.private_seg_size)
; DEFAULT:       .set .Lmy_kernel.uses_vcc, or({{[0-9]+}}, .Lcalls_extern.uses_vcc, .Lcalls_indirect.uses_vcc, .Lcalls_local.uses_vcc)
; DEFAULT:       .set .Lmy_kernel.uses_flat_scratch, or({{[0-9]+}}, .Lcalls_extern.uses_flat_scratch, .Lcalls_indirect.uses_flat_scratch, .Lcalls_local.uses_flat_scratch)
; DEFAULT:       .set .Lmy_kernel.has_dyn_sized_stack, or({{[0-9]+}}, .Lcalls_extern.has_dyn_sized_stack, .Lcalls_indirect.has_dyn_sized_stack, .Lcalls_local.has_dyn_sized_stack)
; DEFAULT:       .set .Lmy_kernel.has_recursion, or({{[0-9]+}}, .Lcalls_extern.has_recursion, .Lcalls_indirect.has_recursion, .Lcalls_local.has_recursion)
; DEFAULT:       .set .Lmy_kernel.has_indirect_call, or({{[0-9]+}}, .Lcalls_extern.has_indirect_call, .Lcalls_indirect.has_indirect_call, .Lcalls_local.has_indirect_call)

; OL:            .set .Lmy_kernel.num_vgpr, {{[0-9]+}}
; OL:            .set .Lmy_kernel.num_agpr, {{[0-9]+}}
; OL:            .set .Lmy_kernel.num_named_barrier, {{[0-9]+}}
; OL:            .set .Lmy_kernel.private_seg_size, {{[0-9]+}}
; OL:            .set .Lmy_kernel.uses_vcc, {{[01]}}
; OL:            .set .Lmy_kernel.uses_flat_scratch, {{[01]}}
; OL:            .set .Lmy_kernel.has_dyn_sized_stack, 0
; OL:            .set .Lmy_kernel.has_recursion, 0
; OL:            .set .Lmy_kernel.has_indirect_call, 0