llvm/test/CodeGen/SystemZ/int-conv-02.ll

   1 ; Test zero extensions from a byte to an i32.    The tests here
   2 ; assume z10 register pressure, without the high words being available.
   3 ;
   4 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z10 | FileCheck %s
   5
   6 ; Test register extension, starting with an i32.
   7 define i32 @f1(i32 %a) {
   8 ; CHECK-LABEL: f1:
   9 ; CHECK: llcr %r2, %r2
  10 ; CHECK: br %r14
  11   %byte = trunc i32 %a to i8
  12   %ext = zext i8 %byte to i32
  13   ret i32 %ext
  14 }
  15
  16 ; ...and again with an i64.
  17 define i32 @f2(i64 %a) {
  18 ; CHECK-LABEL: f2:
  19 ; CHECK: llcr %r2, %r2
  20 ; CHECK: br %r14
  21   %byte = trunc i64 %a to i8
  22   %ext = zext i8 %byte to i32
  23   ret i32 %ext
  24 }
  25
  26 ; Check ANDs that are equivalent to zero extension.
  27 define i32 @f3(i32 %a) {
  28 ; CHECK-LABEL: f3:
  29 ; CHECK: llcr %r2, %r2
  30 ; CHECK: br %r14
  31   %ext = and i32 %a, 255
  32   ret i32 %ext
  33 }
  34
  35 ; Check LLC with no displacement.
  36 define i32 @f4(ptr %src) {
  37 ; CHECK-LABEL: f4:
  38 ; CHECK: llc %r2, 0(%r2)
  39 ; CHECK: br %r14
  40   %byte = load i8, ptr %src
  41   %ext = zext i8 %byte to i32
  42   ret i32 %ext
  43 }
  44
  45 ; Check the high end of the LLC range.
  46 define i32 @f5(ptr %src) {
  47 ; CHECK-LABEL: f5:
  48 ; CHECK: llc %r2, 524287(%r2)
  49 ; CHECK: br %r14
  50   %ptr = getelementptr i8, ptr %src, i64 524287
  51   %byte = load i8, ptr %ptr
  52   %ext = zext i8 %byte to i32
  53   ret i32 %ext
  54 }
  55
  56 ; Check the next byte up, which needs separate address logic.
  57 ; Other sequences besides this one would be OK.
  58 define i32 @f6(ptr %src) {
  59 ; CHECK-LABEL: f6:
  60 ; CHECK: agfi %r2, 524288
  61 ; CHECK: llc %r2, 0(%r2)
  62 ; CHECK: br %r14
  63   %ptr = getelementptr i8, ptr %src, i64 524288
  64   %byte = load i8, ptr %ptr
  65   %ext = zext i8 %byte to i32
  66   ret i32 %ext
  67 }
  68
  69 ; Check the high end of the negative LLC range.
  70 define i32 @f7(ptr %src) {
  71 ; CHECK-LABEL: f7:
  72 ; CHECK: llc %r2, -1(%r2)
  73 ; CHECK: br %r14
  74   %ptr = getelementptr i8, ptr %src, i64 -1
  75   %byte = load i8, ptr %ptr
  76   %ext = zext i8 %byte to i32
  77   ret i32 %ext
  78 }
  79
  80 ; Check the low end of the LLC range.
  81 define i32 @f8(ptr %src) {
  82 ; CHECK-LABEL: f8:
  83 ; CHECK: llc %r2, -524288(%r2)
  84 ; CHECK: br %r14
  85   %ptr = getelementptr i8, ptr %src, i64 -524288
  86   %byte = load i8, ptr %ptr
  87   %ext = zext i8 %byte to i32
  88   ret i32 %ext
  89 }
  90
  91 ; Check the next byte down, which needs separate address logic.
  92 ; Other sequences besides this one would be OK.
  93 define i32 @f9(ptr %src) {
  94 ; CHECK-LABEL: f9:
  95 ; CHECK: agfi %r2, -524289
  96 ; CHECK: llc %r2, 0(%r2)
  97 ; CHECK: br %r14
  98   %ptr = getelementptr i8, ptr %src, i64 -524289
  99   %byte = load i8, ptr %ptr
 100   %ext = zext i8 %byte to i32
 101   ret i32 %ext
 102 }
 103
 104 ; Check that LLC allows an index
 105 define i32 @f10(i64 %src, i64 %index) {
 106 ; CHECK-LABEL: f10:
 107 ; CHECK: llc %r2, 524287(%r3,%r2)
 108 ; CHECK: br %r14
 109   %add1 = add i64 %src, %index
 110   %add2 = add i64 %add1, 524287
 111   %ptr = inttoptr i64 %add2 to ptr
 112   %byte = load i8, ptr %ptr
 113   %ext = zext i8 %byte to i32
 114   ret i32 %ext
 115 }
 116
 117 ; Test a case where we spill the source of at least one LLCR.  We want
 118 ; to use LLC if possible.
 119 define void @f11(ptr %ptr) {
 120 ; CHECK-LABEL: f11:
 121 ; CHECK: llc {{%r[0-9]+}}, 179(%r15)
 122 ; CHECK: br %r14
 123   %val0 = load volatile i32, ptr %ptr
 124   %val1 = load volatile i32, ptr %ptr
 125   %val2 = load volatile i32, ptr %ptr
 126   %val3 = load volatile i32, ptr %ptr
 127   %val4 = load volatile i32, ptr %ptr
 128   %val5 = load volatile i32, ptr %ptr
 129   %val6 = load volatile i32, ptr %ptr
 130   %val7 = load volatile i32, ptr %ptr
 131   %val8 = load volatile i32, ptr %ptr
 132   %val9 = load volatile i32, ptr %ptr
 133   %val10 = load volatile i32, ptr %ptr
 134   %val11 = load volatile i32, ptr %ptr
 135   %val12 = load volatile i32, ptr %ptr
 136   %val13 = load volatile i32, ptr %ptr
 137   %val14 = load volatile i32, ptr %ptr
 138   %val15 = load volatile i32, ptr %ptr
 139
 140   %trunc0 = trunc i32 %val0 to i8
 141   %trunc1 = trunc i32 %val1 to i8
 142   %trunc2 = trunc i32 %val2 to i8
 143   %trunc3 = trunc i32 %val3 to i8
 144   %trunc4 = trunc i32 %val4 to i8
 145   %trunc5 = trunc i32 %val5 to i8
 146   %trunc6 = trunc i32 %val6 to i8
 147   %trunc7 = trunc i32 %val7 to i8
 148   %trunc8 = trunc i32 %val8 to i8
 149   %trunc9 = trunc i32 %val9 to i8
 150   %trunc10 = trunc i32 %val10 to i8
 151   %trunc11 = trunc i32 %val11 to i8
 152   %trunc12 = trunc i32 %val12 to i8
 153   %trunc13 = trunc i32 %val13 to i8
 154   %trunc14 = trunc i32 %val14 to i8
 155   %trunc15 = trunc i32 %val15 to i8
 156
 157   %ext0 = zext i8 %trunc0 to i32
 158   %ext1 = zext i8 %trunc1 to i32
 159   %ext2 = zext i8 %trunc2 to i32
 160   %ext3 = zext i8 %trunc3 to i32
 161   %ext4 = zext i8 %trunc4 to i32
 162   %ext5 = zext i8 %trunc5 to i32
 163   %ext6 = zext i8 %trunc6 to i32
 164   %ext7 = zext i8 %trunc7 to i32
 165   %ext8 = zext i8 %trunc8 to i32
 166   %ext9 = zext i8 %trunc9 to i32
 167   %ext10 = zext i8 %trunc10 to i32
 168   %ext11 = zext i8 %trunc11 to i32
 169   %ext12 = zext i8 %trunc12 to i32
 170   %ext13 = zext i8 %trunc13 to i32
 171   %ext14 = zext i8 %trunc14 to i32
 172   %ext15 = zext i8 %trunc15 to i32
 173
 174   store volatile i32 %val0, ptr %ptr
 175   store volatile i32 %val1, ptr %ptr
 176   store volatile i32 %val2, ptr %ptr
 177   store volatile i32 %val3, ptr %ptr
 178   store volatile i32 %val4, ptr %ptr
 179   store volatile i32 %val5, ptr %ptr
 180   store volatile i32 %val6, ptr %ptr
 181   store volatile i32 %val7, ptr %ptr
 182   store volatile i32 %val8, ptr %ptr
 183   store volatile i32 %val9, ptr %ptr
 184   store volatile i32 %val10, ptr %ptr
 185   store volatile i32 %val11, ptr %ptr
 186   store volatile i32 %val12, ptr %ptr
 187   store volatile i32 %val13, ptr %ptr
 188   store volatile i32 %val14, ptr %ptr
 189   store volatile i32 %val15, ptr %ptr
 190
 191   store volatile i32 %ext0, ptr %ptr
 192   store volatile i32 %ext1, ptr %ptr
 193   store volatile i32 %ext2, ptr %ptr
 194   store volatile i32 %ext3, ptr %ptr
 195   store volatile i32 %ext4, ptr %ptr
 196   store volatile i32 %ext5, ptr %ptr
 197   store volatile i32 %ext6, ptr %ptr
 198   store volatile i32 %ext7, ptr %ptr
 199   store volatile i32 %ext8, ptr %ptr
 200   store volatile i32 %ext9, ptr %ptr
 201   store volatile i32 %ext10, ptr %ptr
 202   store volatile i32 %ext11, ptr %ptr
 203   store volatile i32 %ext12, ptr %ptr
 204   store volatile i32 %ext13, ptr %ptr
 205   store volatile i32 %ext14, ptr %ptr
 206   store volatile i32 %ext15, ptr %ptr
 207
 208   ret void
 209 }