test/CodeGen/SystemZ/call-03.ll

   1 ; Test sibling calls.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
   4
   5 declare void @ok(i8 %r2, i16 %r3, i32 %r4, i64 %r5, float %f0, double %f2,
   6                  float %f4, double %f6)
   7 declare void @uses_r6(i8 %r2, i16 %r3, i32 %r4, i64 %r5, i64 %r6)
   8 declare void @uses_indirect(fp128 %r2)
   9 declare void @uses_stack(float %f0, float %f2, float %f4, float %f6,
  10                          float %stack)
  11 declare i32 @returns_i32()
  12 declare i64 @returns_i64()
  13
  14 ; Check the maximum number of arguments that we can pass and still use
  15 ; a sibling call.
  16 define void @f1() {
  17 ; CHECK-LABEL: f1:
  18 ; CHECK-DAG: lzer %f0
  19 ; CHECK-DAG: lzdr %f2
  20 ; CHECK-DAG: lhi %r2, 1
  21 ; CHECK-DAG: lhi %r3, 2
  22 ; CHECK-DAG: lhi %r4, 3
  23 ; CHECK-DAG: lghi %r5, 4
  24 ; CHECK-DAG: {{ler %f4, %f0|lzer %f4}}
  25 ; CHECK-DAG: {{ldr %f6, %f2|lzdr %f6}}
  26 ; CHECK: jg ok@PLT
  27   tail call void @ok(i8 1, i16 2, i32 3, i64 4, float 0.0, double 0.0,
  28                      float 0.0, double 0.0)
  29   ret void
  30 }
  31
  32 ; Check a call that uses %r6 to pass an argument.  At the moment we don't
  33 ; use sibling calls in that case.
  34 define void @f2() {
  35 ; CHECK-LABEL: f2:
  36 ; CHECK: brasl %r14, uses_r6@PLT
  37 ; CHECK: br %r14
  38   tail call void @uses_r6(i8 1, i16 2, i32 3, i64 4, i64 5)
  39   ret void
  40 }
  41
  42 ; Check a call that passes indirect arguments.  We can't use sibling
  43 ; calls in that case.
  44 define void @f3() {
  45 ; CHECK-LABEL: f3:
  46 ; CHECK: brasl %r14, uses_indirect@PLT
  47 ; CHECK: br %r14
  48   tail call void @uses_indirect(fp128 0xL00000000000000000000000000000000)
  49   ret void
  50 }
  51
  52 ; Check a call that uses direct stack arguments, which again prevents
  53 ; sibling calls
  54 define void @f4() {
  55 ; CHECK-LABEL: f4:
  56 ; CHECK: brasl %r14, uses_stack@PLT
  57 ; CHECK: br %r14
  58   tail call void @uses_stack(float 0.0, float 0.0, float 0.0, float 0.0,
  59                              float 0.0)
  60   ret void
  61 }
  62
  63 ; Check an indirect call.  In this case the only acceptable choice for
  64 ; the target register is %r1.
  65 define void @f5(void(i32, i32, i32, i32) *%foo) {
  66 ; CHECK-LABEL: f5:
  67 ; CHECK: lgr %r1, %r2
  68 ; CHECK-DAG: lhi %r2, 1
  69 ; CHECK-DAG: lhi %r3, 2
  70 ; CHECK-DAG: lhi %r4, 3
  71 ; CHECK-DAG: lhi %r5, 4
  72 ; CHECK: br %r1
  73   tail call void %foo(i32 1, i32 2, i32 3, i32 4)
  74   ret void
  75 }
  76
  77 ; Check an indirect call that will be forced into a call-saved GPR
  78 ; (which should be %r13, the highest GPR not used for anything else).
  79 define void @f6(void(i32) *%foo) {
  80 ; CHECK-LABEL: f6:
  81 ; CHECK: stmg %r13, %r15, 104(%r15)
  82 ; CHECK: lgr %r13, %r2
  83 ; CHECK: brasl %r14, returns_i32
  84 ; CHECK: lgr %r1, %r13
  85 ; CHECK: lmg %r13, %r15, 264(%r15)
  86 ; CHECK: br %r1
  87   %arg = call i32 @returns_i32()
  88   tail call void %foo(i32 %arg)
  89   ret void
  90 }
  91
  92 ; Test a function that returns a value.
  93 define i64 @f7() {
  94 ; CHECK-LABEL: f7:
  95 ; CHECK: jg returns_i64@PLT
  96   %res = tail call i64 @returns_i64()
  97   ret i64 %res
  98 }
  99
 100 ; Test a function that returns a value truncated from i64 to i32.
 101 define i32 @f8() {
 102 ; CHECK-LABEL: f8:
 103 ; CHECK: jg returns_i64@PLT
 104   %res = tail call i64 @returns_i64()
 105   %trunc = trunc i64 %res to i32
 106   ret i32 %trunc
 107 }
 108
 109 ; Test a function that returns a value truncated from i64 to i7.
 110 define i7 @f9() {
 111 ; CHECK-LABEL: f9:
 112 ; CHECK: jg returns_i64@PLT
 113   %res = tail call i64 @returns_i64()
 114   %trunc = trunc i64 %res to i7
 115   ret i7 %trunc
 116 }
 117
 118 ; Test a function that returns a value truncated from i32 to i8.
 119 define i8 @f10() {
 120 ; CHECK-LABEL: f10:
 121 ; CHECK: jg returns_i32@PLT
 122   %res = tail call i32 @returns_i32()
 123   %trunc = trunc i32 %res to i8
 124   ret i8 %trunc
 125 }