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

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