test/CodeGen/SystemZ/int-div-03.ll

   1 ; Test 64-bit signed division and remainder when the divisor is
   2 ; a signed-extended i32.
   3 ;
   4 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
   5
   6 ; Test register division.  The result is in the second of the two registers.
   7 define void @f1(i64 %dummy, i64 %a, i32 %b, i64 *%dest) {
   8 ; CHECK: f1:
   9 ; CHECK-NOT: {{%r[234]}}
  10 ; CHECK: dsgfr %r2, %r4
  11 ; CHECK: stg %r3, 0(%r5)
  12 ; CHECK: br %r14
  13   %bext = sext i32 %b to i64
  14   %div = sdiv i64 %a, %bext
  15   store i64 %div, i64 *%dest
  16   ret void
  17 }
  18
  19 ; Test register remainder.  The result is in the first of the two registers.
  20 define void @f2(i64 %dummy, i64 %a, i32 %b, i64 *%dest) {
  21 ; CHECK: f2:
  22 ; CHECK-NOT: {{%r[234]}}
  23 ; CHECK: dsgfr %r2, %r4
  24 ; CHECK: stg %r2, 0(%r5)
  25 ; CHECK: br %r14
  26   %bext = sext i32 %b to i64
  27   %rem = srem i64 %a, %bext
  28   store i64 %rem, i64 *%dest
  29   ret void
  30 }
  31
  32 ; Test that division and remainder use a single instruction.
  33 define i64 @f3(i64 %dummy, i64 %a, i32 %b) {
  34 ; CHECK: f3:
  35 ; CHECK-NOT: {{%r[234]}}
  36 ; CHECK: dsgfr %r2, %r4
  37 ; CHECK: ogr %r2, %r3
  38 ; CHECK: br %r14
  39   %bext = sext i32 %b to i64
  40   %div = sdiv i64 %a, %bext
  41   %rem = srem i64 %a, %bext
  42   %or = or i64 %rem, %div
  43   ret i64 %or
  44 }
  45
  46 ; Test register division when the dividend is zero rather than sign extended.
  47 ; We can't use dsgfr here
  48 define void @f4(i64 %dummy, i64 %a, i32 %b, i64 *%dest) {
  49 ; CHECK: f4:
  50 ; CHECK-NOT: dsgfr
  51 ; CHECK: br %r14
  52   %bext = zext i32 %b to i64
  53   %div = sdiv i64 %a, %bext
  54   store i64 %div, i64 *%dest
  55   ret void
  56 }
  57
  58 ; ...likewise remainder.
  59 define void @f5(i64 %dummy, i64 %a, i32 %b, i64 *%dest) {
  60 ; CHECK: f5:
  61 ; CHECK-NOT: dsgfr
  62 ; CHECK: br %r14
  63   %bext = zext i32 %b to i64
  64   %rem = srem i64 %a, %bext
  65   store i64 %rem, i64 *%dest
  66   ret void
  67 }
  68
  69 ; Test memory division with no displacement.
  70 define void @f6(i64 %dummy, i64 %a, i32 *%src, i64 *%dest) {
  71 ; CHECK: f6:
  72 ; CHECK-NOT: {{%r[234]}}
  73 ; CHECK: dsgf %r2, 0(%r4)
  74 ; CHECK: stg %r3, 0(%r5)
  75 ; CHECK: br %r14
  76   %b = load i32 *%src
  77   %bext = sext i32 %b to i64
  78   %div = sdiv i64 %a, %bext
  79   store i64 %div, i64 *%dest
  80   ret void
  81 }
  82
  83 ; Test memory remainder with no displacement.
  84 define void @f7(i64 %dummy, i64 %a, i32 *%src, i64 *%dest) {
  85 ; CHECK: f7:
  86 ; CHECK-NOT: {{%r[234]}}
  87 ; CHECK: dsgf %r2, 0(%r4)
  88 ; CHECK: stg %r2, 0(%r5)
  89 ; CHECK: br %r14
  90   %b = load i32 *%src
  91   %bext = sext i32 %b to i64
  92   %rem = srem i64 %a, %bext
  93   store i64 %rem, i64 *%dest
  94   ret void
  95 }
  96
  97 ; Test both memory division and memory remainder.
  98 define i64 @f8(i64 %dummy, i64 %a, i32 *%src) {
  99 ; CHECK: f8:
 100 ; CHECK-NOT: {{%r[234]}}
 101 ; CHECK: dsgf %r2, 0(%r4)
 102 ; CHECK-NOT: {{dsgf|dsgfr}}
 103 ; CHECK: ogr %r2, %r3
 104 ; CHECK: br %r14
 105   %b = load i32 *%src
 106   %bext = sext i32 %b to i64
 107   %div = sdiv i64 %a, %bext
 108   %rem = srem i64 %a, %bext
 109   %or = or i64 %rem, %div
 110   ret i64 %or
 111 }
 112
 113 ; Check the high end of the DSGF range.
 114 define i64 @f9(i64 %dummy, i64 %a, i32 *%src) {
 115 ; CHECK: f9:
 116 ; CHECK: dsgf %r2, 524284(%r4)
 117 ; CHECK: br %r14
 118   %ptr = getelementptr i32 *%src, i64 131071
 119   %b = load i32 *%ptr
 120   %bext = sext i32 %b to i64
 121   %rem = srem i64 %a, %bext
 122   ret i64 %rem
 123 }
 124
 125 ; Check the next word up, which needs separate address logic.
 126 ; Other sequences besides this one would be OK.
 127 define i64 @f10(i64 %dummy, i64 %a, i32 *%src) {
 128 ; CHECK: f10:
 129 ; CHECK: agfi %r4, 524288
 130 ; CHECK: dsgf %r2, 0(%r4)
 131 ; CHECK: br %r14
 132   %ptr = getelementptr i32 *%src, i64 131072
 133   %b = load i32 *%ptr
 134   %bext = sext i32 %b to i64
 135   %rem = srem i64 %a, %bext
 136   ret i64 %rem
 137 }
 138
 139 ; Check the high end of the negative aligned DSGF range.
 140 define i64 @f11(i64 %dummy, i64 %a, i32 *%src) {
 141 ; CHECK: f11:
 142 ; CHECK: dsgf %r2, -4(%r4)
 143 ; CHECK: br %r14
 144   %ptr = getelementptr i32 *%src, i64 -1
 145   %b = load i32 *%ptr
 146   %bext = sext i32 %b to i64
 147   %rem = srem i64 %a, %bext
 148   ret i64 %rem
 149 }
 150
 151 ; Check the low end of the DSGF range.
 152 define i64 @f12(i64 %dummy, i64 %a, i32 *%src) {
 153 ; CHECK: f12:
 154 ; CHECK: dsgf %r2, -524288(%r4)
 155 ; CHECK: br %r14
 156   %ptr = getelementptr i32 *%src, i64 -131072
 157   %b = load i32 *%ptr
 158   %bext = sext i32 %b to i64
 159   %rem = srem i64 %a, %bext
 160   ret i64 %rem
 161 }
 162
 163 ; Check the next word down, which needs separate address logic.
 164 ; Other sequences besides this one would be OK.
 165 define i64 @f13(i64 %dummy, i64 %a, i32 *%src) {
 166 ; CHECK: f13:
 167 ; CHECK: agfi %r4, -524292
 168 ; CHECK: dsgf %r2, 0(%r4)
 169 ; CHECK: br %r14
 170   %ptr = getelementptr i32 *%src, i64 -131073
 171   %b = load i32 *%ptr
 172   %bext = sext i32 %b to i64
 173   %rem = srem i64 %a, %bext
 174   ret i64 %rem
 175 }
 176
 177 ; Check that DSGF allows an index.
 178 define i64 @f14(i64 %dummy, i64 %a, i64 %src, i64 %index) {
 179 ; CHECK: f14:
 180 ; CHECK: dsgf %r2, 524287(%r5,%r4)
 181 ; CHECK: br %r14
 182   %add1 = add i64 %src, %index
 183   %add2 = add i64 %add1, 524287
 184   %ptr = inttoptr i64 %add2 to i32 *
 185   %b = load i32 *%ptr
 186   %bext = sext i32 %b to i64
 187   %rem = srem i64 %a, %bext
 188   ret i64 %rem
 189 }