test/CodeGen/SystemZ/memcpy-02.ll

   1 ; Test load/store pairs that act as memcpys.
   2 ;
   3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s
   4
   5 @g1src = global i8 1
   6 @g1dst = global i8 1
   7 @g2src = global i16 2
   8 @g2dst = global i16 2
   9 @g3 = global i32 3
  10 @g4 = global i64 4
  11 @g5src = external global fp128, align 16
  12 @g5dst = external global fp128, align 16
  13
  14 ; Test the simple i8 case.
  15 define void @f1(i8 *%ptr1) {
  16 ; CHECK-LABEL: f1:
  17 ; CHECK: mvc 1(1,%r2), 0(%r2)
  18 ; CHECK: br %r14
  19   %ptr2 = getelementptr i8 *%ptr1, i64 1
  20   %val = load i8 *%ptr1
  21   store i8 %val, i8 *%ptr2
  22   ret void
  23 }
  24
  25 ; Test i8 cases where the value is zero-extended to 32 bits.
  26 define void @f2(i8 *%ptr1) {
  27 ; CHECK-LABEL: f2:
  28 ; CHECK: mvc 1(1,%r2), 0(%r2)
  29 ; CHECK: br %r14
  30   %ptr2 = getelementptr i8 *%ptr1, i64 1
  31   %val = load i8 *%ptr1
  32   %ext = zext i8 %val to i32
  33   %trunc = trunc i32 %ext to i8
  34   store i8 %trunc, i8 *%ptr2
  35   ret void
  36 }
  37
  38 ; Test i8 cases where the value is zero-extended to 64 bits.
  39 define void @f3(i8 *%ptr1) {
  40 ; CHECK-LABEL: f3:
  41 ; CHECK: mvc 1(1,%r2), 0(%r2)
  42 ; CHECK: br %r14
  43   %ptr2 = getelementptr i8 *%ptr1, i64 1
  44   %val = load i8 *%ptr1
  45   %ext = zext i8 %val to i64
  46   %trunc = trunc i64 %ext to i8
  47   store i8 %trunc, i8 *%ptr2
  48   ret void
  49 }
  50
  51 ; Test i8 cases where the value is sign-extended to 32 bits.
  52 define void @f4(i8 *%ptr1) {
  53 ; CHECK-LABEL: f4:
  54 ; CHECK: mvc 1(1,%r2), 0(%r2)
  55 ; CHECK: br %r14
  56   %ptr2 = getelementptr i8 *%ptr1, i64 1
  57   %val = load i8 *%ptr1
  58   %ext = sext i8 %val to i32
  59   %trunc = trunc i32 %ext to i8
  60   store i8 %trunc, i8 *%ptr2
  61   ret void
  62 }
  63
  64 ; Test i8 cases where the value is sign-extended to 64 bits.
  65 define void @f5(i8 *%ptr1) {
  66 ; CHECK-LABEL: f5:
  67 ; CHECK: mvc 1(1,%r2), 0(%r2)
  68 ; CHECK: br %r14
  69   %ptr2 = getelementptr i8 *%ptr1, i64 1
  70   %val = load i8 *%ptr1
  71   %ext = sext i8 %val to i64
  72   %trunc = trunc i64 %ext to i8
  73   store i8 %trunc, i8 *%ptr2
  74   ret void
  75 }
  76
  77 ; Test the simple i16 case.
  78 define void @f6(i16 *%ptr1) {
  79 ; CHECK-LABEL: f6:
  80 ; CHECK: mvc 2(2,%r2), 0(%r2)
  81 ; CHECK: br %r14
  82   %ptr2 = getelementptr i16 *%ptr1, i64 1
  83   %val = load i16 *%ptr1
  84   store i16 %val, i16 *%ptr2
  85   ret void
  86 }
  87
  88 ; Test i16 cases where the value is zero-extended to 32 bits.
  89 define void @f7(i16 *%ptr1) {
  90 ; CHECK-LABEL: f7:
  91 ; CHECK: mvc 2(2,%r2), 0(%r2)
  92 ; CHECK: br %r14
  93   %ptr2 = getelementptr i16 *%ptr1, i64 1
  94   %val = load i16 *%ptr1
  95   %ext = zext i16 %val to i32
  96   %trunc = trunc i32 %ext to i16
  97   store i16 %trunc, i16 *%ptr2
  98   ret void
  99 }
 100
 101 ; Test i16 cases where the value is zero-extended to 64 bits.
 102 define void @f8(i16 *%ptr1) {
 103 ; CHECK-LABEL: f8:
 104 ; CHECK: mvc 2(2,%r2), 0(%r2)
 105 ; CHECK: br %r14
 106   %ptr2 = getelementptr i16 *%ptr1, i64 1
 107   %val = load i16 *%ptr1
 108   %ext = zext i16 %val to i64
 109   %trunc = trunc i64 %ext to i16
 110   store i16 %trunc, i16 *%ptr2
 111   ret void
 112 }
 113
 114 ; Test i16 cases where the value is sign-extended to 32 bits.
 115 define void @f9(i16 *%ptr1) {
 116 ; CHECK-LABEL: f9:
 117 ; CHECK: mvc 2(2,%r2), 0(%r2)
 118 ; CHECK: br %r14
 119   %ptr2 = getelementptr i16 *%ptr1, i64 1
 120   %val = load i16 *%ptr1
 121   %ext = sext i16 %val to i32
 122   %trunc = trunc i32 %ext to i16
 123   store i16 %trunc, i16 *%ptr2
 124   ret void
 125 }
 126
 127 ; Test i16 cases where the value is sign-extended to 64 bits.
 128 define void @f10(i16 *%ptr1) {
 129 ; CHECK-LABEL: f10:
 130 ; CHECK: mvc 2(2,%r2), 0(%r2)
 131 ; CHECK: br %r14
 132   %ptr2 = getelementptr i16 *%ptr1, i64 1
 133   %val = load i16 *%ptr1
 134   %ext = sext i16 %val to i64
 135   %trunc = trunc i64 %ext to i16
 136   store i16 %trunc, i16 *%ptr2
 137   ret void
 138 }
 139
 140 ; Test the simple i32 case.
 141 define void @f11(i32 *%ptr1) {
 142 ; CHECK-LABEL: f11:
 143 ; CHECK: mvc 4(4,%r2), 0(%r2)
 144 ; CHECK: br %r14
 145   %ptr2 = getelementptr i32 *%ptr1, i64 1
 146   %val = load i32 *%ptr1
 147   store i32 %val, i32 *%ptr2
 148   ret void
 149 }
 150
 151 ; Test i32 cases where the value is zero-extended to 64 bits.
 152 define void @f12(i32 *%ptr1) {
 153 ; CHECK-LABEL: f12:
 154 ; CHECK: mvc 4(4,%r2), 0(%r2)
 155 ; CHECK: br %r14
 156   %ptr2 = getelementptr i32 *%ptr1, i64 1
 157   %val = load i32 *%ptr1
 158   %ext = zext i32 %val to i64
 159   %trunc = trunc i64 %ext to i32
 160   store i32 %trunc, i32 *%ptr2
 161   ret void
 162 }
 163
 164 ; Test i32 cases where the value is sign-extended to 64 bits.
 165 define void @f13(i32 *%ptr1) {
 166 ; CHECK-LABEL: f13:
 167 ; CHECK: mvc 4(4,%r2), 0(%r2)
 168 ; CHECK: br %r14
 169   %ptr2 = getelementptr i32 *%ptr1, i64 1
 170   %val = load i32 *%ptr1
 171   %ext = sext i32 %val to i64
 172   %trunc = trunc i64 %ext to i32
 173   store i32 %trunc, i32 *%ptr2
 174   ret void
 175 }
 176
 177 ; Test the i64 case.
 178 define void @f14(i64 *%ptr1) {
 179 ; CHECK-LABEL: f14:
 180 ; CHECK: mvc 8(8,%r2), 0(%r2)
 181 ; CHECK: br %r14
 182   %ptr2 = getelementptr i64 *%ptr1, i64 1
 183   %val = load i64 *%ptr1
 184   store i64 %val, i64 *%ptr2
 185   ret void
 186 }
 187
 188 ; Test the f32 case.
 189 define void @f15(float *%ptr1) {
 190 ; CHECK-LABEL: f15:
 191 ; CHECK: mvc 4(4,%r2), 0(%r2)
 192 ; CHECK: br %r14
 193   %ptr2 = getelementptr float *%ptr1, i64 1
 194   %val = load float *%ptr1
 195   store float %val, float *%ptr2
 196   ret void
 197 }
 198
 199 ; Test the f64 case.
 200 define void @f16(double *%ptr1) {
 201 ; CHECK-LABEL: f16:
 202 ; CHECK: mvc 8(8,%r2), 0(%r2)
 203 ; CHECK: br %r14
 204   %ptr2 = getelementptr double *%ptr1, i64 1
 205   %val = load double *%ptr1
 206   store double %val, double *%ptr2
 207   ret void
 208 }
 209
 210 ; Test the f128 case.
 211 define void @f17(fp128 *%ptr1) {
 212 ; CHECK-LABEL: f17:
 213 ; CHECK: mvc 16(16,%r2), 0(%r2)
 214 ; CHECK: br %r14
 215   %ptr2 = getelementptr fp128 *%ptr1, i64 1
 216   %val = load fp128 *%ptr1
 217   store fp128 %val, fp128 *%ptr2
 218   ret void
 219 }
 220
 221 ; Make sure that we don't use MVC if the load is volatile.
 222 define void @f18(i64 *%ptr1) {
 223 ; CHECK-LABEL: f18:
 224 ; CHECK-NOT: mvc
 225 ; CHECK: br %r14
 226   %ptr2 = getelementptr i64 *%ptr1, i64 1
 227   %val = load volatile i64 *%ptr1
 228   store i64 %val, i64 *%ptr2
 229   ret void
 230 }
 231
 232 ; ...likewise the store.
 233 define void @f19(i64 *%ptr1) {
 234 ; CHECK-LABEL: f19:
 235 ; CHECK-NOT: mvc
 236 ; CHECK: br %r14
 237   %ptr2 = getelementptr i64 *%ptr1, i64 1
 238   %val = load i64 *%ptr1
 239   store volatile i64 %val, i64 *%ptr2
 240   ret void
 241 }
 242
 243 ; Test that MVC is not used for aligned loads and stores if there is
 244 ; no way of telling whether they alias.  We don't want to use MVC in
 245 ; cases where the addresses could be equal.
 246 define void @f20(i64 *%ptr1, i64 *%ptr2) {
 247 ; CHECK-LABEL: f20:
 248 ; CHECK-NOT: mvc
 249 ; CHECK: br %r14
 250   %val = load i64 *%ptr1
 251   store i64 %val, i64 *%ptr2
 252   ret void
 253 }
 254
 255 ; ...and again for unaligned loads and stores.
 256 define void @f21(i64 *%ptr1, i64 *%ptr2) {
 257 ; CHECK-LABEL: f21:
 258 ; CHECK-NOT: mvc
 259 ; CHECK: br %r14
 260   %val = load i64 *%ptr1, align 2
 261   store i64 %val, i64 *%ptr2, align 2
 262   ret void
 263 }
 264
 265 ; Test a case where there is definite overlap.
 266 define void @f22(i64 %base) {
 267 ; CHECK-LABEL: f22:
 268 ; CHECK-NOT: mvc
 269 ; CHECK: br %r14
 270   %add = add i64 %base, 1
 271   %ptr1 = inttoptr i64 %base to i64 *
 272   %ptr2 = inttoptr i64 %add to i64 *
 273   %val = load i64 *%ptr1, align 1
 274   store i64 %val, i64 *%ptr2, align 1
 275   ret void
 276 }
 277
 278 ; Test that we can use MVC for global addresses for i8.
 279 define void @f23(i8 *%ptr) {
 280 ; CHECK-LABEL: f23:
 281 ; CHECK-DAG: larl [[SRC:%r[0-5]]], g1src
 282 ; CHECK-DAG: larl [[DST:%r[0-5]]], g1dst
 283 ; CHECK: mvc 0(1,[[DST]]), 0([[SRC]])
 284 ; CHECK: br %r14
 285   %val = load i8 *@g1src
 286   store i8 %val, i8 *@g1dst
 287   ret void
 288 }
 289
 290 ; Test that we use LHRL and STHRL for i16.
 291 define void @f24(i16 *%ptr) {
 292 ; CHECK-LABEL: f24:
 293 ; CHECK: lhrl [[REG:%r[0-5]]], g2src
 294 ; CHECK: sthrl [[REG]], g2dst
 295 ; CHECK: br %r14
 296   %val = load i16 *@g2src
 297   store i16 %val, i16 *@g2dst
 298   ret void
 299 }
 300
 301 ; Test that we use LRL for i32.
 302 define void @f25(i32 *%ptr) {
 303 ; CHECK-LABEL: f25:
 304 ; CHECK: lrl [[REG:%r[0-5]]], g3
 305 ; CHECK: st [[REG]], 0(%r2)
 306 ; CHECK: br %r14
 307   %val = load i32 *@g3
 308   store i32 %val, i32 *%ptr
 309   ret void
 310 }
 311
 312 ; ...likewise STRL.
 313 define void @f26(i32 *%ptr) {
 314 ; CHECK-LABEL: f26:
 315 ; CHECK: l [[REG:%r[0-5]]], 0(%r2)
 316 ; CHECK: strl [[REG]], g3
 317 ; CHECK: br %r14
 318   %val = load i32 *%ptr
 319   store i32 %val, i32 *@g3
 320   ret void
 321 }
 322
 323 ; Test that we use LGRL for i64.
 324 define void @f27(i64 *%ptr) {
 325 ; CHECK-LABEL: f27:
 326 ; CHECK: lgrl [[REG:%r[0-5]]], g4
 327 ; CHECK: stg [[REG]], 0(%r2)
 328 ; CHECK: br %r14
 329   %val = load i64 *@g4
 330   store i64 %val, i64 *%ptr
 331   ret void
 332 }
 333
 334 ; ...likewise STGRL.
 335 define void @f28(i64 *%ptr) {
 336 ; CHECK-LABEL: f28:
 337 ; CHECK: lg [[REG:%r[0-5]]], 0(%r2)
 338 ; CHECK: stgrl [[REG]], g4
 339 ; CHECK: br %r14
 340   %val = load i64 *%ptr
 341   store i64 %val, i64 *@g4
 342   ret void
 343 }
 344
 345 ; Test that we can use MVC for global addresses for fp128.
 346 define void @f29(fp128 *%ptr) {
 347 ; CHECK-LABEL: f29:
 348 ; CHECK-DAG: larl [[SRC:%r[0-5]]], g5src
 349 ; CHECK-DAG: larl [[DST:%r[0-5]]], g5dst
 350 ; CHECK: mvc 0(16,[[DST]]), 0([[SRC]])
 351 ; CHECK: br %r14
 352   %val = load fp128 *@g5src, align 16
 353   store fp128 %val, fp128 *@g5dst, align 16
 354   ret void
 355 }
 356
 357 ; Test a case where offset disambiguation is enough.
 358 define void @f30(i64 *%ptr1) {
 359 ; CHECK-LABEL: f30:
 360 ; CHECK: mvc 8(8,%r2), 0(%r2)
 361 ; CHECK: br %r14
 362   %ptr2 = getelementptr i64 *%ptr1, i64 1
 363   %val = load i64 *%ptr1, align 1
 364   store i64 %val, i64 *%ptr2, align 1
 365   ret void
 366 }
 367
 368 ; Test f21 in cases where TBAA tells us there is no alias.
 369 define void @f31(i64 *%ptr1, i64 *%ptr2) {
 370 ; CHECK-LABEL: f31:
 371 ; CHECK: mvc 0(8,%r3), 0(%r2)
 372 ; CHECK: br %r14
 373   %val = load i64 *%ptr1, align 2, !tbaa !1
 374   store i64 %val, i64 *%ptr2, align 2, !tbaa !2
 375   ret void
 376 }
 377
 378 ; Test f21 in cases where TBAA is present but doesn't help.
 379 define void @f32(i64 *%ptr1, i64 *%ptr2) {
 380 ; CHECK-LABEL: f32:
 381 ; CHECK-NOT: mvc
 382 ; CHECK: br %r14
 383   %val = load i64 *%ptr1, align 2, !tbaa !1
 384   store i64 %val, i64 *%ptr2, align 2, !tbaa !1
 385   ret void
 386 }
 387
 388 !0 = metadata !{ metadata !"root" }
 389 !1 = metadata !{ metadata !3, metadata !3, i64 0 }
 390 !2 = metadata !{ metadata !4, metadata !4, i64 0 }
 391 !3 = metadata !{ metadata !"set1", metadata !0 }
 392 !4 = metadata !{ metadata !"set2", metadata !0 }