llvm/test/CodeGen/SystemZ/vec-bswap-03.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
   2 ; Test vector insertion of byte-swapped memory values.
   3 ;
   4 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z15 | FileCheck %s
   5
   6 declare i16 @llvm.bswap.i16(i16)
   7 declare i32 @llvm.bswap.i32(i32)
   8 declare i64 @llvm.bswap.i64(i64)
   9 declare <8 x i16> @llvm.bswap.v8i16(<8 x i16>)
  10 declare <4 x i32> @llvm.bswap.v4i32(<4 x i32>)
  11 declare <2 x i64> @llvm.bswap.v2i64(<2 x i64>)
  12
  13 ; Test v8i16 insertion into the first element.
  14 define <8 x i16> @f1(<8 x i16> %val, ptr %ptr) {
  15 ; CHECK-LABEL: f1:
  16 ; CHECK:       # %bb.0:
  17 ; CHECK-NEXT:    vlebrh %v24, 0(%r2), 0
  18 ; CHECK-NEXT:    br %r14
  19   %element = load i16, ptr %ptr
  20   %swap = call i16 @llvm.bswap.i16(i16 %element)
  21   %ret = insertelement <8 x i16> %val, i16 %swap, i32 0
  22   ret <8 x i16> %ret
  23 }
  24
  25 ; Test v8i16 insertion into the last element.
  26 define <8 x i16> @f2(<8 x i16> %val, ptr %ptr) {
  27 ; CHECK-LABEL: f2:
  28 ; CHECK:       # %bb.0:
  29 ; CHECK-NEXT:    vlebrh %v24, 0(%r2), 7
  30 ; CHECK-NEXT:    br %r14
  31   %element = load i16, ptr %ptr
  32   %swap = call i16 @llvm.bswap.i16(i16 %element)
  33   %ret = insertelement <8 x i16> %val, i16 %swap, i32 7
  34   ret <8 x i16> %ret
  35 }
  36
  37 ; Test v8i16 insertion with the highest in-range offset.
  38 define <8 x i16> @f3(<8 x i16> %val, ptr %base) {
  39 ; CHECK-LABEL: f3:
  40 ; CHECK:       # %bb.0:
  41 ; CHECK-NEXT:    vlebrh %v24, 4094(%r2), 5
  42 ; CHECK-NEXT:    br %r14
  43   %ptr = getelementptr i16, ptr %base, i32 2047
  44   %element = load i16, ptr %ptr
  45   %swap = call i16 @llvm.bswap.i16(i16 %element)
  46   %ret = insertelement <8 x i16> %val, i16 %swap, i32 5
  47   ret <8 x i16> %ret
  48 }
  49
  50 ; Test v8i16 insertion with the first ouf-of-range offset.
  51 define <8 x i16> @f4(<8 x i16> %val, ptr %base) {
  52 ; CHECK-LABEL: f4:
  53 ; CHECK:       # %bb.0:
  54 ; CHECK-NEXT:    aghi %r2, 4096
  55 ; CHECK-NEXT:    vlebrh %v24, 0(%r2), 1
  56 ; CHECK-NEXT:    br %r14
  57   %ptr = getelementptr i16, ptr %base, i32 2048
  58   %element = load i16, ptr %ptr
  59   %swap = call i16 @llvm.bswap.i16(i16 %element)
  60   %ret = insertelement <8 x i16> %val, i16 %swap, i32 1
  61   ret <8 x i16> %ret
  62 }
  63
  64 ; Test v8i16 insertion into a variable element.
  65 define <8 x i16> @f5(<8 x i16> %val, ptr %ptr, i32 %index) {
  66 ; CHECK-LABEL: f5:
  67 ; CHECK:       # %bb.0:
  68 ; CHECK-NEXT:    lrvh %r0, 0(%r2)
  69 ; CHECK-NEXT:    vlvgh %v24, %r0, 0(%r3)
  70 ; CHECK-NEXT:    br %r14
  71   %element = load i16, ptr %ptr
  72   %swap = call i16 @llvm.bswap.i16(i16 %element)
  73   %ret = insertelement <8 x i16> %val, i16 %swap, i32 %index
  74   ret <8 x i16> %ret
  75 }
  76
  77 ; Test v8i16 insertion using a pair of vector bswaps.
  78 define <8 x i16> @f6(<8 x i16> %val, ptr %ptr) {
  79 ; CHECK-LABEL: f6:
  80 ; CHECK:       # %bb.0:
  81 ; CHECK-NEXT:    vlebrh %v24, 0(%r2), 0
  82 ; CHECK-NEXT:    br %r14
  83   %element = load i16, ptr %ptr
  84   %swapval = call <8 x i16> @llvm.bswap.v8i16(<8 x i16> %val)
  85   %insert = insertelement <8 x i16> %swapval, i16 %element, i32 0
  86   %ret = call <8 x i16> @llvm.bswap.v8i16(<8 x i16> %insert)
  87   ret <8 x i16> %ret
  88 }
  89
  90 ; Test v4i32 insertion into the first element.
  91 define <4 x i32> @f7(<4 x i32> %val, ptr %ptr) {
  92 ; CHECK-LABEL: f7:
  93 ; CHECK:       # %bb.0:
  94 ; CHECK-NEXT:    vlebrf %v24, 0(%r2), 0
  95 ; CHECK-NEXT:    br %r14
  96   %element = load i32, ptr %ptr
  97   %swap = call i32 @llvm.bswap.i32(i32 %element)
  98   %ret = insertelement <4 x i32> %val, i32 %swap, i32 0
  99   ret <4 x i32> %ret
 100 }
 101
 102 ; Test v4i32 insertion into the last element.
 103 define <4 x i32> @f8(<4 x i32> %val, ptr %ptr) {
 104 ; CHECK-LABEL: f8:
 105 ; CHECK:       # %bb.0:
 106 ; CHECK-NEXT:    vlebrf %v24, 0(%r2), 3
 107 ; CHECK-NEXT:    br %r14
 108   %element = load i32, ptr %ptr
 109   %swap = call i32 @llvm.bswap.i32(i32 %element)
 110   %ret = insertelement <4 x i32> %val, i32 %swap, i32 3
 111   ret <4 x i32> %ret
 112 }
 113
 114 ; Test v4i32 insertion with the highest in-range offset.
 115 define <4 x i32> @f9(<4 x i32> %val, ptr %base) {
 116 ; CHECK-LABEL: f9:
 117 ; CHECK:       # %bb.0:
 118 ; CHECK-NEXT:    vlebrf %v24, 4092(%r2), 2
 119 ; CHECK-NEXT:    br %r14
 120   %ptr = getelementptr i32, ptr %base, i32 1023
 121   %element = load i32, ptr %ptr
 122   %swap = call i32 @llvm.bswap.i32(i32 %element)
 123   %ret = insertelement <4 x i32> %val, i32 %swap, i32 2
 124   ret <4 x i32> %ret
 125 }
 126
 127 ; Test v4i32 insertion with the first ouf-of-range offset.
 128 define <4 x i32> @f10(<4 x i32> %val, ptr %base) {
 129 ; CHECK-LABEL: f10:
 130 ; CHECK:       # %bb.0:
 131 ; CHECK-NEXT:    aghi %r2, 4096
 132 ; CHECK-NEXT:    vlebrf %v24, 0(%r2), 1
 133 ; CHECK-NEXT:    br %r14
 134   %ptr = getelementptr i32, ptr %base, i32 1024
 135   %element = load i32, ptr %ptr
 136   %swap = call i32 @llvm.bswap.i32(i32 %element)
 137   %ret = insertelement <4 x i32> %val, i32 %swap, i32 1
 138   ret <4 x i32> %ret
 139 }
 140
 141 ; Test v4i32 insertion into a variable element.
 142 define <4 x i32> @f11(<4 x i32> %val, ptr %ptr, i32 %index) {
 143 ; CHECK-LABEL: f11:
 144 ; CHECK:       # %bb.0:
 145 ; CHECK-NEXT:    lrv %r0, 0(%r2)
 146 ; CHECK-NEXT:    vlvgf %v24, %r0, 0(%r3)
 147 ; CHECK-NEXT:    br %r14
 148   %element = load i32, ptr %ptr
 149   %swap = call i32 @llvm.bswap.i32(i32 %element)
 150   %ret = insertelement <4 x i32> %val, i32 %swap, i32 %index
 151   ret <4 x i32> %ret
 152 }
 153
 154 ; Test v4i32 insertion using a pair of vector bswaps.
 155 define <4 x i32> @f12(<4 x i32> %val, ptr %ptr) {
 156 ; CHECK-LABEL: f12:
 157 ; CHECK:       # %bb.0:
 158 ; CHECK-NEXT:    vlebrf %v24, 0(%r2), 0
 159 ; CHECK-NEXT:    br %r14
 160   %element = load i32, ptr %ptr
 161   %swapval = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %val)
 162   %insert = insertelement <4 x i32> %swapval, i32 %element, i32 0
 163   %ret = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %insert)
 164   ret <4 x i32> %ret
 165 }
 166
 167 ; Test v2i64 insertion into the first element.
 168 define <2 x i64> @f13(<2 x i64> %val, ptr %ptr) {
 169 ; CHECK-LABEL: f13:
 170 ; CHECK:       # %bb.0:
 171 ; CHECK-NEXT:    vlebrg %v24, 0(%r2), 0
 172 ; CHECK-NEXT:    br %r14
 173   %element = load i64, ptr %ptr
 174   %swap = call i64 @llvm.bswap.i64(i64 %element)
 175   %ret = insertelement <2 x i64> %val, i64 %swap, i32 0
 176   ret <2 x i64> %ret
 177 }
 178
 179 ; Test v2i64 insertion into the last element.
 180 define <2 x i64> @f14(<2 x i64> %val, ptr %ptr) {
 181 ; CHECK-LABEL: f14:
 182 ; CHECK:       # %bb.0:
 183 ; CHECK-NEXT:    vlebrg %v24, 0(%r2), 1
 184 ; CHECK-NEXT:    br %r14
 185   %element = load i64, ptr %ptr
 186   %swap = call i64 @llvm.bswap.i64(i64 %element)
 187   %ret = insertelement <2 x i64> %val, i64 %swap, i32 1
 188   ret <2 x i64> %ret
 189 }
 190
 191 ; Test v2i64 insertion with the highest in-range offset.
 192 define <2 x i64> @f15(<2 x i64> %val, ptr %base) {
 193 ; CHECK-LABEL: f15:
 194 ; CHECK:       # %bb.0:
 195 ; CHECK-NEXT:    vlebrg %v24, 4088(%r2), 1
 196 ; CHECK-NEXT:    br %r14
 197   %ptr = getelementptr i64, ptr %base, i32 511
 198   %element = load i64, ptr %ptr
 199   %swap = call i64 @llvm.bswap.i64(i64 %element)
 200   %ret = insertelement <2 x i64> %val, i64 %swap, i32 1
 201   ret <2 x i64> %ret
 202 }
 203
 204 ; Test v2i64 insertion with the first ouf-of-range offset.
 205 define <2 x i64> @f16(<2 x i64> %val, ptr %base) {
 206 ; CHECK-LABEL: f16:
 207 ; CHECK:       # %bb.0:
 208 ; CHECK-NEXT:    aghi %r2, 4096
 209 ; CHECK-NEXT:    vlebrg %v24, 0(%r2), 0
 210 ; CHECK-NEXT:    br %r14
 211   %ptr = getelementptr i64, ptr %base, i32 512
 212   %element = load i64, ptr %ptr
 213   %swap = call i64 @llvm.bswap.i64(i64 %element)
 214   %ret = insertelement <2 x i64> %val, i64 %swap, i32 0
 215   ret <2 x i64> %ret
 216 }
 217
 218 ; Test v2i64 insertion into a variable element.
 219 define <2 x i64> @f17(<2 x i64> %val, ptr %ptr, i32 %index) {
 220 ; CHECK-LABEL: f17:
 221 ; CHECK:       # %bb.0:
 222 ; CHECK-NEXT:    lrvg %r0, 0(%r2)
 223 ; CHECK-NEXT:    vlvgg %v24, %r0, 0(%r3)
 224 ; CHECK-NEXT:    br %r14
 225   %element = load i64, ptr %ptr
 226   %swap = call i64 @llvm.bswap.i64(i64 %element)
 227   %ret = insertelement <2 x i64> %val, i64 %swap, i32 %index
 228   ret <2 x i64> %ret
 229 }
 230
 231 ; Test v2i64 insertion using a pair of vector bswaps.
 232 define <2 x i64> @f18(<2 x i64> %val, ptr %ptr) {
 233 ; CHECK-LABEL: f18:
 234 ; CHECK:       # %bb.0:
 235 ; CHECK-NEXT:    vlebrg %v24, 0(%r2), 0
 236 ; CHECK-NEXT:    br %r14
 237   %element = load i64, ptr %ptr
 238   %swapval = call <2 x i64> @llvm.bswap.v2i64(<2 x i64> %val)
 239   %insert = insertelement <2 x i64> %swapval, i64 %element, i32 0
 240   %ret = call <2 x i64> @llvm.bswap.v2i64(<2 x i64> %insert)
 241   ret <2 x i64> %ret
 242 }