; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=sparc -verify-machineinstrs | FileCheck %s --check-prefix=V8
; RUN: llc < %s -mtriple=sparcv9 -verify-machineinstrs | FileCheck %s --check-prefix=V9

define i32 @simple_leaf(i32 %i) #0 {
; V8-LABEL: simple_leaf:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    mov %o7, %g1
; V8-NEXT:    call foo
; V8-NEXT:    mov %g1, %o7
;
; V9-LABEL: simple_leaf:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    mov %o7, %g1
; V9-NEXT:    call foo
; V9-NEXT:    mov %g1, %o7
entry:
  %call = tail call i32 @foo(i32 %i)
  ret i32 %call
}

define i32 @simple_standard(i32 %i) #1 {
; V8-LABEL: simple_standard:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -96, %sp
; V8-NEXT:    call foo
; V8-NEXT:    restore
;
; V9-LABEL: simple_standard:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -128, %sp
; V9-NEXT:    call foo
; V9-NEXT:    restore
entry:
  %call = tail call i32 @foo(i32 %i)
  ret i32 %call
}

define i32 @extra_arg_leaf(i32 %i) #0 {
; V8-LABEL: extra_arg_leaf:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    mov 12, %o1
; V8-NEXT:    mov %o7, %g1
; V8-NEXT:    call foo2
; V8-NEXT:    mov %g1, %o7
;
; V9-LABEL: extra_arg_leaf:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    mov 12, %o1
; V9-NEXT:    mov %o7, %g1
; V9-NEXT:    call foo2
; V9-NEXT:    mov %g1, %o7
entry:
  %call = tail call i32 @foo2(i32 %i, i32 12)
  ret i32 %call
}

define i32 @extra_arg_standard(i32 %i) #1 {
; V8-LABEL: extra_arg_standard:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -96, %sp
; V8-NEXT:    call foo2
; V8-NEXT:    restore %g0, 12, %o1
;
; V9-LABEL: extra_arg_standard:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -128, %sp
; V9-NEXT:    call foo2
; V9-NEXT:    restore %g0, 12, %o1
entry:
  %call = tail call i32 @foo2(i32 %i, i32 12)
  ret i32 %call
}

; Perform tail call optimization for external symbol.

define void @caller_extern(ptr %src) optsize #0 {
; V8-LABEL: caller_extern:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    sethi %hi(dest), %o1
; V8-NEXT:    add %o1, %lo(dest), %o1
; V8-NEXT:    mov 7, %o2
; V8-NEXT:    mov %o0, %o3
; V8-NEXT:    mov %o1, %o0
; V8-NEXT:    mov %o3, %o1
; V8-NEXT:    mov %o7, %g1
; V8-NEXT:    call memcpy
; V8-NEXT:    mov %g1, %o7
;
; V9-LABEL: caller_extern:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    sethi %h44(dest), %o1
; V9-NEXT:    add %o1, %m44(dest), %o1
; V9-NEXT:    sllx %o1, 12, %o1
; V9-NEXT:    add %o1, %l44(dest), %o1
; V9-NEXT:    mov 7, %o2
; V9-NEXT:    mov %o0, %o3
; V9-NEXT:    mov %o1, %o0
; V9-NEXT:    mov %o3, %o1
; V9-NEXT:    mov %o7, %g1
; V9-NEXT:    call memcpy
; V9-NEXT:    mov %g1, %o7
entry:
  tail call void @llvm.memcpy.p0.p0.i32(
    ptr @dest,
    ptr %src, i32 7, i1 false)
  ret void
}

; Perform tail call optimization for function pointer.

define i32 @func_ptr_test(ptr nocapture %func_ptr) #0 {
; V8-LABEL: func_ptr_test:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    jmp %o0
; V8-NEXT:    nop
;
; V9-LABEL: func_ptr_test:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    jmp %o0
; V9-NEXT:    nop
entry:
  %call = tail call i32 %func_ptr() #1
  ret i32 %call
}

define i32 @func_ptr_test2(ptr nocapture %func_ptr,
; V8-LABEL: func_ptr_test2:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -96, %sp
; V8-NEXT:    mov 10, %i3
; V8-NEXT:    mov %i0, %i4
; V8-NEXT:    mov %i1, %i0
; V8-NEXT:    jmp %i4
; V8-NEXT:    restore %g0, %i3, %o1
;
; V9-LABEL: func_ptr_test2:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -128, %sp
; V9-NEXT:    mov 10, %i3
; V9-NEXT:    mov %i0, %i4
; V9-NEXT:    mov %i1, %i0
; V9-NEXT:    jmp %i4
; V9-NEXT:    restore %g0, %i3, %o1
                           i32 %r, i32 %q) #1 {
entry:
  %call = tail call i32 %func_ptr(i32 %r, i32 10, i32 %q) #1
  ret i32 %call
}


; Do not tail call optimize if stack is used to pass parameters.

define i32 @caller_args() #0 {
; V8-LABEL: caller_args:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -104, %sp
; V8-NEXT:    mov 6, %i0
; V8-NEXT:    mov 1, %o1
; V8-NEXT:    mov 2, %o2
; V8-NEXT:    mov 3, %o3
; V8-NEXT:    mov 4, %o4
; V8-NEXT:    mov 5, %o5
; V8-NEXT:    st %i0, [%sp+92]
; V8-NEXT:    call foo7
; V8-NEXT:    mov %g0, %o0
; V8-NEXT:    ret
; V8-NEXT:    restore %g0, %o0, %o0
;
; V9-LABEL: caller_args:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -192, %sp
; V9-NEXT:    mov 6, %i0
; V9-NEXT:    mov 1, %o1
; V9-NEXT:    mov 2, %o2
; V9-NEXT:    mov 3, %o3
; V9-NEXT:    mov 4, %o4
; V9-NEXT:    mov 5, %o5
; V9-NEXT:    stx %i0, [%sp+2223]
; V9-NEXT:    call foo7
; V9-NEXT:    mov %g0, %o0
; V9-NEXT:    ret
; V9-NEXT:    restore %g0, %o0, %o0
entry:
  %r = tail call i32 @foo7(i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6)
  ret i32 %r
}

; Byval parameters hand the function a pointer directly into the stack area
; we want to reuse during a tail call. Do not tail call optimize functions with
; byval parameters.

define i32 @caller_byval() #0 {
; V8-LABEL: caller_byval:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -104, %sp
; V8-NEXT:    ld [%fp+-4], %i0
; V8-NEXT:    st %i0, [%fp+-8]
; V8-NEXT:    call callee_byval
; V8-NEXT:    add %fp, -8, %o0
; V8-NEXT:    ret
; V8-NEXT:    restore %g0, %o0, %o0
;
; V9-LABEL: caller_byval:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -192, %sp
; V9-NEXT:    call callee_byval
; V9-NEXT:    add %fp, 2039, %o0
; V9-NEXT:    ret
; V9-NEXT:    restore %g0, %o0, %o0
entry:
  %a = alloca ptr
  %r = tail call i32 @callee_byval(ptr byval(ptr) %a)
  ret i32 %r
}

; Perform tail call optimization for sret function.

define void @sret_test(ptr noalias sret(%struct.a) %agg.result) #0 {
; V8-LABEL: sret_test:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    mov %o7, %g1
; V8-NEXT:    call sret_func
; V8-NEXT:    mov %g1, %o7
;
; V9-LABEL: sret_test:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    mov %o7, %g1
; V9-NEXT:    call sret_func
; V9-NEXT:    mov %g1, %o7
entry:
  tail call void @sret_func(ptr sret(%struct.a) %agg.result)
  ret void
}

; Do not tail call if either caller or callee returns
; a struct and the other does not. Returning a large
; struct will generate a memcpy as the tail function.

define void @ret_large_struct(ptr noalias sret(%struct.big) %agg.result) #0 {
; V8-LABEL: ret_large_struct:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    save %sp, -96, %sp
; V8-NEXT:    ld [%fp+64], %i0
; V8-NEXT:    sethi %hi(bigstruct), %i1
; V8-NEXT:    add %i1, %lo(bigstruct), %o1
; V8-NEXT:    mov 400, %o2
; V8-NEXT:    call memcpy
; V8-NEXT:    mov %i0, %o0
; V8-NEXT:    jmp %i7+12
; V8-NEXT:    restore
;
; V9-LABEL: ret_large_struct:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    save %sp, -176, %sp
; V9-NEXT:    sethi %h44(bigstruct), %i1
; V9-NEXT:    add %i1, %m44(bigstruct), %i1
; V9-NEXT:    sllx %i1, 12, %i1
; V9-NEXT:    add %i1, %l44(bigstruct), %o1
; V9-NEXT:    mov 400, %o2
; V9-NEXT:    call memcpy
; V9-NEXT:    mov %i0, %o0
; V9-NEXT:    ret
; V9-NEXT:    restore
entry:
  %0 = bitcast ptr %agg.result to ptr
  tail call void @llvm.memcpy.p0.p0.i32(ptr align 4 %0, ptr align 4 @bigstruct, i32 400, i1 false)
  ret void
}

; Test register + immediate pattern.

define void @addri_test(i32 %ptr) #0 {
; V8-LABEL: addri_test:
; V8:       ! %bb.0: ! %entry
; V8-NEXT:    jmp %o0+4
; V8-NEXT:    nop
;
; V9-LABEL: addri_test:
; V9:       ! %bb.0: ! %entry
; V9-NEXT:    add %o0, 4, %o0
; V9-NEXT:    srl %o0, 0, %o0
; V9-NEXT:    jmp %o0
; V9-NEXT:    nop
entry:
  %add = add nsw i32 %ptr, 4
  %0 = inttoptr i32 %add to ptr
  tail call void %0() #1
  ret void
}

%struct.a = type { i32, i32 }
@dest = global [2 x i8] zeroinitializer

%struct.big = type { [100 x i32] }
@bigstruct = global %struct.big zeroinitializer

declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1)
declare void @sret_func(ptr sret(%struct.a))
declare i32 @callee_byval(ptr byval(ptr) %a)
declare i32 @foo(i32)
declare i32 @foo2(i32, i32)
declare i32 @foo7(i32, i32, i32, i32, i32, i32, i32)

attributes #0 = { nounwind "disable-tail-calls"="false"
                  "frame-pointer"="none" }
attributes #1 = { nounwind "disable-tail-calls"="false"
                  "frame-pointer"="all" }