llvm/test/CodeGen/SystemZ/rnsbg-01.ll

   1 ; Test sequences that can use RNSBG.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
   4
   5 ; Test a simple mask, which is a wrap-around case.
   6 define i32 @f1(i32 %a, i32 %b) {
   7 ; CHECK-LABEL: f1:
   8 ; CHECK: rnsbg %r2, %r3, 59, 56, 0
   9 ; CHECK: br %r14
  10   %orb = or i32 %b, 96
  11   %and = and i32 %a, %orb
  12   ret i32 %and
  13 }
  14
  15 ; ...and again with i64.
  16 define i64 @f2(i64 %a, i64 %b) {
  17 ; CHECK-LABEL: f2:
  18 ; CHECK: rnsbg %r2, %r3, 59, 56, 0
  19 ; CHECK: br %r14
  20   %orb = or i64 %b, 96
  21   %and = and i64 %a, %orb
  22   ret i64 %and
  23 }
  24
  25 ; Test a case where no wraparound is needed.
  26 define i32 @f3(i32 %a, i32 %b) {
  27 ; CHECK-LABEL: f3:
  28 ; CHECK: rnsbg %r2, %r3, 58, 61, 0
  29 ; CHECK: br %r14
  30   %orb = or i32 %b, -61
  31   %and = and i32 %a, %orb
  32   ret i32 %and
  33 }
  34
  35 ; ...and again with i64.
  36 define i64 @f4(i64 %a, i64 %b) {
  37 ; CHECK-LABEL: f4:
  38 ; CHECK: rnsbg %r2, %r3, 58, 61, 0
  39 ; CHECK: br %r14
  40   %orb = or i64 %b, -61
  41   %and = and i64 %a, %orb
  42   ret i64 %and
  43 }
  44
  45 ; Test a case with just a left shift.  This can't use RNSBG.
  46 define i32 @f6(i32 %a, i32 %b) {
  47 ; CHECK-LABEL: f6:
  48 ; CHECK: sll {{%r[0-5]}}
  49 ; CHECK: nr {{%r[0-5]}}
  50 ; CHECK: br %r14
  51   %shrb = shl i32 %b, 20
  52   %and = and i32 %a, %shrb
  53   ret i32 %and
  54 }
  55
  56 ; ...and again with i64.
  57 define i64 @f7(i64 %a, i64 %b) {
  58 ; CHECK-LABEL: f7:
  59 ; CHECK: sllg {{%r[0-5]}}
  60 ; CHECK: ngr {{%r[0-5]}}
  61 ; CHECK: br %r14
  62   %shrb = shl i64 %b, 20
  63   %and = and i64 %a, %shrb
  64   ret i64 %and
  65 }
  66
  67 ; Test a case with just a rotate.  This can't use RNSBG.
  68 define i32 @f8(i32 %a, i32 %b) {
  69 ; CHECK-LABEL: f8:
  70 ; CHECK: rll {{%r[0-5]}}
  71 ; CHECK: nr {{%r[0-5]}}
  72 ; CHECK: br %r14
  73   %shlb = shl i32 %b, 22
  74   %shrb = lshr i32 %b, 10
  75   %rotlb = or i32 %shlb, %shrb
  76   %and = and i32 %a, %rotlb
  77   ret i32 %and
  78 }
  79
  80 ; ...and again with i64, which can.
  81 define i64 @f9(i64 %a, i64 %b) {
  82 ; CHECK-LABEL: f9:
  83 ; CHECK: rnsbg %r2, %r3, 0, 63, 44
  84 ; CHECK: br %r14
  85   %shlb = shl i64 %b, 44
  86   %shrb = lshr i64 %b, 20
  87   %rotlb = or i64 %shlb, %shrb
  88   %and = and i64 %a, %rotlb
  89   ret i64 %and
  90 }
  91
  92 ; Test a case with a left shift and OR, where the OR covers all shifted bits.
  93 ; We can do the whole thing using RNSBG.
  94 define i32 @f10(i32 %a, i32 %b) {
  95 ; CHECK-LABEL: f10:
  96 ; CHECK: rnsbg %r2, %r3, 32, 56, 7
  97 ; CHECK: br %r14
  98   %shlb = shl i32 %b, 7
  99   %orb = or i32 %shlb, 127
 100   %and = and i32 %a, %orb
 101   ret i32 %and
 102 }
 103
 104 ; ...and again with i64.
 105 define i64 @f11(i64 %a, i64 %b) {
 106 ; CHECK-LABEL: f11:
 107 ; CHECK: rnsbg %r2, %r3, 0, 56, 7
 108 ; CHECK: br %r14
 109   %shlb = shl i64 %b, 7
 110   %orb = or i64 %shlb, 127
 111   %and = and i64 %a, %orb
 112   ret i64 %and
 113 }
 114
 115 ; Test a case with a left shift and OR, where the OR doesn't cover all
 116 ; shifted bits.  We can't use RNSBG for the shift, but we can for the OR
 117 ; and AND.
 118 define i32 @f12(i32 %a, i32 %b) {
 119 ; CHECK-LABEL: f12:
 120 ; CHECK: sll %r3, 7
 121 ; CHECK: rnsbg %r2, %r3, 32, 57, 0
 122 ; CHECK: br %r14
 123   %shlb = shl i32 %b, 7
 124   %orb = or i32 %shlb, 63
 125   %and = and i32 %a, %orb
 126   ret i32 %and
 127 }
 128
 129 ; ...and again with i64.
 130 define i64 @f13(i64 %a, i64 %b) {
 131 ; CHECK-LABEL: f13:
 132 ; CHECK: sllg [[REG:%r[01345]]], %r3, 7
 133 ; CHECK: rnsbg %r2, [[REG]], 0, 57, 0
 134 ; CHECK: br %r14
 135   %shlb = shl i64 %b, 7
 136   %orb = or i64 %shlb, 63
 137   %and = and i64 %a, %orb
 138   ret i64 %and
 139 }
 140
 141 ; Test a case with a right shift and OR, where the OR covers all the shifted
 142 ; bits.  The whole thing can be done using RNSBG.
 143 define i32 @f14(i32 %a, i32 %b) {
 144 ; CHECK-LABEL: f14:
 145 ; CHECK: rnsbg %r2, %r3, 60, 63, 37
 146 ; CHECK: br %r14
 147   %shrb = lshr i32 %b, 27
 148   %orb = or i32 %shrb, -16
 149   %and = and i32 %a, %orb
 150   ret i32 %and
 151 }
 152
 153 ; ...and again with i64.
 154 define i64 @f15(i64 %a, i64 %b) {
 155 ; CHECK-LABEL: f15:
 156 ; CHECK: rnsbg %r2, %r3, 60, 63, 5
 157 ; CHECK: br %r14
 158   %shrb = lshr i64 %b, 59
 159   %orb = or i64 %shrb, -16
 160   %and = and i64 %a, %orb
 161   ret i64 %and
 162 }
 163
 164 ; Test a case with a right shift and OR, where the OR doesn't cover all the
 165 ; shifted bits.  The shift needs to be done separately, but the OR and AND
 166 ; can use RNSBG.
 167 define i32 @f16(i32 %a, i32 %b) {
 168 ; CHECK-LABEL: f16:
 169 ; CHECK: srl %r3, 29
 170 ; CHECK: rnsbg %r2, %r3, 60, 63, 0
 171 ; CHECK: br %r14
 172   %shrb = lshr i32 %b, 29
 173   %orb = or i32 %shrb, -16
 174   %and = and i32 %a, %orb
 175   ret i32 %and
 176 }
 177
 178 ; ...and again with i64.
 179 define i64 @f17(i64 %a, i64 %b) {
 180 ; CHECK-LABEL: f17:
 181 ; CHECK: srlg [[REG:%r[01345]]], %r3, 61
 182 ; CHECK: rnsbg %r2, [[REG]], 60, 63, 0
 183 ; CHECK: br %r14
 184   %shrb = lshr i64 %b, 61
 185   %orb = or i64 %shrb, -16
 186   %and = and i64 %a, %orb
 187   ret i64 %and
 188 }
 189
 190 ; Test a combination involving an ASHR in which the sign bits matter.
 191 ; We can't use RNSBG for the ASHR in that case, but we can for the rest.
 192 define i32 @f18(i32 %a, i32 %b, ptr %dest) {
 193 ; CHECK-LABEL: f18:
 194 ; CHECK: sra %r3, 4
 195 ; CHECK: rnsbg %r2, %r3, 32, 62, 1
 196 ; CHECK: br %r14
 197   %ashrb = ashr i32 %b, 4
 198   store i32 %ashrb, ptr %dest
 199   %shlb = shl i32 %ashrb, 1
 200   %orb = or i32 %shlb, 1
 201   %and = and i32 %a, %orb
 202   ret i32 %and
 203 }
 204
 205 ; ...and again with i64.
 206 define i64 @f19(i64 %a, i64 %b, ptr %dest) {
 207 ; CHECK-LABEL: f19:
 208 ; CHECK: srag [[REG:%r[0145]]], %r3, 34
 209 ; CHECK: rnsbg %r2, [[REG]], 0, 62, 1
 210 ; CHECK: br %r14
 211   %ashrb = ashr i64 %b, 34
 212   store i64 %ashrb, ptr %dest
 213   %shlb = shl i64 %ashrb, 1
 214   %orb = or i64 %shlb, 1
 215   %and = and i64 %a, %orb
 216   ret i64 %and
 217 }
 218
 219 ; Test a combination involving an ASHR in which the sign bits don't matter.
 220 define i32 @f20(i32 %a, i32 %b, ptr %dest) {
 221 ; CHECK-LABEL: f20:
 222 ; CHECK-NOT: lr
 223 ; CHECK: rnsbg %r2, %r3, 48, 62, 1
 224 ; CHECK: br %r14
 225   %ashrb = ashr i32 %b, 17
 226   store i32 %ashrb, ptr %dest
 227   %shlb = shl i32 %ashrb, 1
 228   %orb = or i32 %shlb, -65535
 229   %and = and i32 %a, %orb
 230   ret i32 %and
 231 }
 232
 233 ; ...and again with i64.
 234 define i64 @f21(i64 %a, i64 %b, ptr %dest) {
 235 ; CHECK-LABEL: f21:
 236 ; CHECK: rnsbg %r2, %r0, 48, 62, 1
 237 ; CHECK: br %r14
 238   %ashrb = ashr i64 %b, 49
 239   store i64 %ashrb, ptr %dest
 240   %shlb = shl i64 %ashrb, 1
 241   %orb = or i64 %shlb, -65535
 242   %and = and i64 %a, %orb
 243   ret i64 %and
 244 }
 245
 246 ; Test a case with a shift, OR, and rotate where the OR covers all shifted bits.
 247 define i64 @f22(i64 %a, i64 %b) {
 248 ; CHECK-LABEL: f22:
 249 ; CHECK: rnsbg %r2, %r3, 60, 54, 9
 250 ; CHECK: br %r14
 251   %shlb = shl i64 %b, 5
 252   %orb = or i64 %shlb, 31
 253   %shlorb = shl i64 %orb, 4
 254   %shrorb = lshr i64 %orb, 60
 255   %rotlorb = or i64 %shlorb, %shrorb
 256   %and = and i64 %a, %rotlorb
 257   ret i64 %and
 258 }
 259
 260 ; Check the handling of zext and AND, which isn't suitable for RNSBG.
 261 define i64 @f23(i64 %a, i32 %b) {
 262 ; CHECK-LABEL: f23:
 263 ; CHECK-NOT: rnsbg
 264 ; CHECK: br %r14
 265   %add = add i32 %b, 1
 266   %ext = zext i32 %add to i64
 267   %and = and i64 %a, %ext
 268   ret i64 %and
 269 }