llvm/test/CodeGen/LoongArch/tail-calls.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc --mtriple=loongarch64 < %s | FileCheck %s
   3
   4 ;; Perform tail call optimization for global address.
   5 declare i32 @callee_tail(i32 %i)
   6 define i32 @caller_tail(i32 %i) nounwind {
   7 ; CHECK-LABEL: caller_tail:
   8 ; CHECK:       # %bb.0: # %entry
   9 ; CHECK-NEXT:    b %plt(callee_tail)
  10 entry:
  11   %r = tail call i32 @callee_tail(i32 %i)
  12   ret i32 %r
  13 }
  14
  15 ;; Perform tail call optimization for external symbol.
  16 ;; Bytes copied should be large enough, otherwise the memcpy call would be optimized to multiple ld/st insns.
  17 @dest = global [2 x i8] zeroinitializer
  18 declare void @llvm.memcpy.p0i8.p0i8.i32(ptr, ptr, i32, i1)
  19 define void @caller_extern(ptr %src) optsize {
  20 ; CHECK-LABEL: caller_extern:
  21 ; CHECK:       # %bb.0: # %entry
  22 ; CHECK-NEXT:    move $a1, $a0
  23 ; CHECK-NEXT:    pcalau12i $a0, %got_pc_hi20(dest)
  24 ; CHECK-NEXT:    ld.d $a0, $a0, %got_pc_lo12(dest)
  25 ; CHECK-NEXT:    ori $a2, $zero, 33
  26 ; CHECK-NEXT:    b %plt(memcpy)
  27 entry:
  28   tail call void @llvm.memcpy.p0i8.p0i8.i32(ptr getelementptr inbounds ([2 x i8], ptr @dest, i32 0, i32 0), ptr %src, i32 33, i1 false)
  29   ret void
  30 }
  31
  32 ;; Perform indirect tail call optimization (for function pointer call).
  33 declare void @callee_indirect1()
  34 declare void @callee_indirect2()
  35 define void @caller_indirect_tail(i32 %a) nounwind {
  36 ; CHECK-LABEL: caller_indirect_tail:
  37 ; CHECK:       # %bb.0: # %entry
  38 ; CHECK-NEXT:    addi.w $a0, $a0, 0
  39 ; CHECK-NEXT:    sltui $a0, $a0, 1
  40 ; CHECK-NEXT:    pcalau12i $a1, %got_pc_hi20(callee_indirect2)
  41 ; CHECK-NEXT:    ld.d $a1, $a1, %got_pc_lo12(callee_indirect2)
  42 ; CHECK-NEXT:    masknez $a1, $a1, $a0
  43 ; CHECK-NEXT:    pcalau12i $a2, %got_pc_hi20(callee_indirect1)
  44 ; CHECK-NEXT:    ld.d $a2, $a2, %got_pc_lo12(callee_indirect1)
  45 ; CHECK-NEXT:    maskeqz $a0, $a2, $a0
  46 ; CHECK-NEXT:    or $a0, $a0, $a1
  47 ; CHECK-NEXT:    jr $a0
  48 entry:
  49   %tobool = icmp eq i32 %a, 0
  50   %callee = select i1 %tobool, ptr @callee_indirect1, ptr @callee_indirect2
  51   tail call void %callee()
  52   ret void
  53 }
  54
  55 ;; Do not tail call optimize functions with varargs passed by stack.
  56 declare i32 @callee_varargs(i32, ...)
  57 define void @caller_varargs(i32 %a, i32 %b) nounwind {
  58 ; CHECK-LABEL: caller_varargs:
  59 ; CHECK:       # %bb.0: # %entry
  60 ; CHECK-NEXT:    addi.d $sp, $sp, -16
  61 ; CHECK-NEXT:    st.d $ra, $sp, 8 # 8-byte Folded Spill
  62 ; CHECK-NEXT:    st.d $a0, $sp, 0
  63 ; CHECK-NEXT:    move $a2, $a1
  64 ; CHECK-NEXT:    move $a3, $a0
  65 ; CHECK-NEXT:    move $a4, $a0
  66 ; CHECK-NEXT:    move $a5, $a1
  67 ; CHECK-NEXT:    move $a6, $a1
  68 ; CHECK-NEXT:    move $a7, $a0
  69 ; CHECK-NEXT:    bl %plt(callee_varargs)
  70 ; CHECK-NEXT:    ld.d $ra, $sp, 8 # 8-byte Folded Reload
  71 ; CHECK-NEXT:    addi.d $sp, $sp, 16
  72 ; CHECK-NEXT:    ret
  73 entry:
  74   %call = tail call i32 (i32, ...) @callee_varargs(i32 %a, i32 %b, i32 %b, i32 %a, i32 %a, i32 %b, i32 %b, i32 %a, i32 %a)
  75   ret void
  76 }
  77
  78 ;; Do not tail call optimize if stack is used to pass parameters.
  79 declare i32 @callee_args(i32 %a, i32 %b, i32 %c, i32 %dd, i32 %e, i32 %ff, i32 %g, i32 %h, i32 %i)
  80 define i32 @caller_args(i32 %a, i32 %b, i32 %c, i32 %dd, i32 %e, i32 %ff, i32 %g, i32 %h, i32 %i) nounwind {
  81 ; CHECK-LABEL: caller_args:
  82 ; CHECK:       # %bb.0: # %entry
  83 ; CHECK-NEXT:    addi.d $sp, $sp, -16
  84 ; CHECK-NEXT:    st.d $ra, $sp, 8 # 8-byte Folded Spill
  85 ; CHECK-NEXT:    ld.d $t0, $sp, 16
  86 ; CHECK-NEXT:    st.d $t0, $sp, 0
  87 ; CHECK-NEXT:    bl %plt(callee_args)
  88 ; CHECK-NEXT:    ld.d $ra, $sp, 8 # 8-byte Folded Reload
  89 ; CHECK-NEXT:    addi.d $sp, $sp, 16
  90 ; CHECK-NEXT:    ret
  91 entry:
  92   %r = tail call i32 @callee_args(i32 %a, i32 %b, i32 %c, i32 %dd, i32 %e, i32 %ff, i32 %g, i32 %h, i32 %i)
  93   ret i32 %r
  94 }
  95
  96 ;; Do not tail call optimize if parameters need to be passed indirectly.
  97 declare i32 @callee_indirect_args(i256 %a)
  98 define void @caller_indirect_args() nounwind {
  99 ; CHECK-LABEL: caller_indirect_args:
 100 ; CHECK:       # %bb.0: # %entry
 101 ; CHECK-NEXT:    addi.d $sp, $sp, -48
 102 ; CHECK-NEXT:    st.d $ra, $sp, 40 # 8-byte Folded Spill
 103 ; CHECK-NEXT:    st.d $zero, $sp, 24
 104 ; CHECK-NEXT:    st.d $zero, $sp, 16
 105 ; CHECK-NEXT:    st.d $zero, $sp, 8
 106 ; CHECK-NEXT:    ori $a0, $zero, 1
 107 ; CHECK-NEXT:    st.d $a0, $sp, 0
 108 ; CHECK-NEXT:    addi.d $a0, $sp, 0
 109 ; CHECK-NEXT:    bl %plt(callee_indirect_args)
 110 ; CHECK-NEXT:    ld.d $ra, $sp, 40 # 8-byte Folded Reload
 111 ; CHECK-NEXT:    addi.d $sp, $sp, 48
 112 ; CHECK-NEXT:    ret
 113 entry:
 114   %call = tail call i32 @callee_indirect_args(i256 1)
 115   ret void
 116 }
 117
 118 ;; Do not tail call optimize if byval parameters need to be passed.
 119 declare i32 @callee_byval(ptr byval(ptr) %a)
 120 define i32 @caller_byval() nounwind {
 121 ; CHECK-LABEL: caller_byval:
 122 ; CHECK:       # %bb.0: # %entry
 123 ; CHECK-NEXT:    addi.d $sp, $sp, -32
 124 ; CHECK-NEXT:    st.d $ra, $sp, 24 # 8-byte Folded Spill
 125 ; CHECK-NEXT:    ld.d $a0, $sp, 16
 126 ; CHECK-NEXT:    st.d $a0, $sp, 8
 127 ; CHECK-NEXT:    addi.d $a0, $sp, 8
 128 ; CHECK-NEXT:    bl %plt(callee_byval)
 129 ; CHECK-NEXT:    ld.d $ra, $sp, 24 # 8-byte Folded Reload
 130 ; CHECK-NEXT:    addi.d $sp, $sp, 32
 131 ; CHECK-NEXT:    ret
 132 entry:
 133   %a = alloca ptr
 134   %r = tail call i32 @callee_byval(ptr byval(ptr) %a)
 135   ret i32 %r
 136 }
 137
 138 ;; Do not tail call optimize if callee uses structret semantics.
 139 %struct.A = type { i32 }
 140 @a = global %struct.A zeroinitializer
 141
 142 declare void @callee_struct(ptr sret(%struct.A) %a)
 143 define void @caller_nostruct() nounwind {
 144 ; CHECK-LABEL: caller_nostruct:
 145 ; CHECK:       # %bb.0: # %entry
 146 ; CHECK-NEXT:    addi.d $sp, $sp, -16
 147 ; CHECK-NEXT:    st.d $ra, $sp, 8 # 8-byte Folded Spill
 148 ; CHECK-NEXT:    pcalau12i $a0, %got_pc_hi20(a)
 149 ; CHECK-NEXT:    ld.d $a0, $a0, %got_pc_lo12(a)
 150 ; CHECK-NEXT:    bl %plt(callee_struct)
 151 ; CHECK-NEXT:    ld.d $ra, $sp, 8 # 8-byte Folded Reload
 152 ; CHECK-NEXT:    addi.d $sp, $sp, 16
 153 ; CHECK-NEXT:    ret
 154 entry:
 155   tail call void @callee_struct(ptr sret(%struct.A) @a)
 156   ret void
 157 }
 158
 159 ;; Do not tail call optimize if caller uses structret semantics.
 160 declare void @callee_nostruct()
 161 define void @caller_struct(ptr sret(%struct.A) %a) nounwind {
 162 ; CHECK-LABEL: caller_struct:
 163 ; CHECK:       # %bb.0: # %entry
 164 ; CHECK-NEXT:    addi.d $sp, $sp, -16
 165 ; CHECK-NEXT:    st.d $ra, $sp, 8 # 8-byte Folded Spill
 166 ; CHECK-NEXT:    bl %plt(callee_nostruct)
 167 ; CHECK-NEXT:    ld.d $ra, $sp, 8 # 8-byte Folded Reload
 168 ; CHECK-NEXT:    addi.d $sp, $sp, 16
 169 ; CHECK-NEXT:    ret
 170 entry:
 171   tail call void @callee_nostruct()
 172   ret void
 173 }
 174
 175 ;; Do not tail call optimize if disabled.
 176 define i32 @disable_tail_calls(i32 %i) nounwind "disable-tail-calls"="true" {
 177 ; CHECK-LABEL: disable_tail_calls:
 178 ; CHECK:       # %bb.0: # %entry
 179 ; CHECK-NEXT:    addi.d $sp, $sp, -16
 180 ; CHECK-NEXT:    st.d $ra, $sp, 8 # 8-byte Folded Spill
 181 ; CHECK-NEXT:    bl %plt(callee_tail)
 182 ; CHECK-NEXT:    ld.d $ra, $sp, 8 # 8-byte Folded Reload
 183 ; CHECK-NEXT:    addi.d $sp, $sp, 16
 184 ; CHECK-NEXT:    ret
 185 entry:
 186   %rv = tail call i32 @callee_tail(i32 %i)
 187   ret i32 %rv
 188 }