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

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