; Test load/store pairs that act as memcpys. ; ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s @g1src = dso_local global i8 1 @g1dst = dso_local global i8 1 @g2src = dso_local global i16 2 @g2dst = dso_local global i16 2 @g3 = dso_local global i32 3 @g4 = dso_local global i64 4 @g5src = external dso_local global fp128, align 16 @g5dst = external dso_local global fp128, align 16 ; Test the simple i8 case. define dso_local void @f1(ptr %ptr1) { ; CHECK-LABEL: f1: ; CHECK: mvc 1(1,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i8, ptr %ptr1, i64 1 %val = load i8, ptr %ptr1 store i8 %val, ptr %ptr2 ret void } ; Test i8 cases where the value is zero-extended to 32 bits. define dso_local void @f2(ptr %ptr1) { ; CHECK-LABEL: f2: ; CHECK: mvc 1(1,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i8, ptr %ptr1, i64 1 %val = load i8, ptr %ptr1 %ext = zext i8 %val to i32 %trunc = trunc i32 %ext to i8 store i8 %trunc, ptr %ptr2 ret void } ; Test i8 cases where the value is zero-extended to 64 bits. define dso_local void @f3(ptr %ptr1) { ; CHECK-LABEL: f3: ; CHECK: mvc 1(1,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i8, ptr %ptr1, i64 1 %val = load i8, ptr %ptr1 %ext = zext i8 %val to i64 %trunc = trunc i64 %ext to i8 store i8 %trunc, ptr %ptr2 ret void } ; Test i8 cases where the value is sign-extended to 32 bits. define dso_local void @f4(ptr %ptr1) { ; CHECK-LABEL: f4: ; CHECK: mvc 1(1,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i8, ptr %ptr1, i64 1 %val = load i8, ptr %ptr1 %ext = sext i8 %val to i32 %trunc = trunc i32 %ext to i8 store i8 %trunc, ptr %ptr2 ret void } ; Test i8 cases where the value is sign-extended to 64 bits. define dso_local void @f5(ptr %ptr1) { ; CHECK-LABEL: f5: ; CHECK: mvc 1(1,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i8, ptr %ptr1, i64 1 %val = load i8, ptr %ptr1 %ext = sext i8 %val to i64 %trunc = trunc i64 %ext to i8 store i8 %trunc, ptr %ptr2 ret void } ; Test the simple i16 case. define dso_local void @f6(ptr %ptr1) { ; CHECK-LABEL: f6: ; CHECK: mvc 2(2,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i16, ptr %ptr1, i64 1 %val = load i16, ptr %ptr1 store i16 %val, ptr %ptr2 ret void } ; Test i16 cases where the value is zero-extended to 32 bits. define dso_local void @f7(ptr %ptr1) { ; CHECK-LABEL: f7: ; CHECK: mvc 2(2,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i16, ptr %ptr1, i64 1 %val = load i16, ptr %ptr1 %ext = zext i16 %val to i32 %trunc = trunc i32 %ext to i16 store i16 %trunc, ptr %ptr2 ret void } ; Test i16 cases where the value is zero-extended to 64 bits. define dso_local void @f8(ptr %ptr1) { ; CHECK-LABEL: f8: ; CHECK: mvc 2(2,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i16, ptr %ptr1, i64 1 %val = load i16, ptr %ptr1 %ext = zext i16 %val to i64 %trunc = trunc i64 %ext to i16 store i16 %trunc, ptr %ptr2 ret void } ; Test i16 cases where the value is sign-extended to 32 bits. define dso_local void @f9(ptr %ptr1) { ; CHECK-LABEL: f9: ; CHECK: mvc 2(2,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i16, ptr %ptr1, i64 1 %val = load i16, ptr %ptr1 %ext = sext i16 %val to i32 %trunc = trunc i32 %ext to i16 store i16 %trunc, ptr %ptr2 ret void } ; Test i16 cases where the value is sign-extended to 64 bits. define dso_local void @f10(ptr %ptr1) { ; CHECK-LABEL: f10: ; CHECK: mvc 2(2,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i16, ptr %ptr1, i64 1 %val = load i16, ptr %ptr1 %ext = sext i16 %val to i64 %trunc = trunc i64 %ext to i16 store i16 %trunc, ptr %ptr2 ret void } ; Test the simple i32 case. define dso_local void @f11(ptr %ptr1) { ; CHECK-LABEL: f11: ; CHECK: mvc 4(4,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i32, ptr %ptr1, i64 1 %val = load i32, ptr %ptr1 store i32 %val, ptr %ptr2 ret void } ; Test i32 cases where the value is zero-extended to 64 bits. define dso_local void @f12(ptr %ptr1) { ; CHECK-LABEL: f12: ; CHECK: mvc 4(4,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i32, ptr %ptr1, i64 1 %val = load i32, ptr %ptr1 %ext = zext i32 %val to i64 %trunc = trunc i64 %ext to i32 store i32 %trunc, ptr %ptr2 ret void } ; Test i32 cases where the value is sign-extended to 64 bits. define dso_local void @f13(ptr %ptr1) { ; CHECK-LABEL: f13: ; CHECK: mvc 4(4,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i32, ptr %ptr1, i64 1 %val = load i32, ptr %ptr1 %ext = sext i32 %val to i64 %trunc = trunc i64 %ext to i32 store i32 %trunc, ptr %ptr2 ret void } ; Test the i64 case. define dso_local void @f14(ptr %ptr1) { ; CHECK-LABEL: f14: ; CHECK: mvc 8(8,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i64, ptr %ptr1, i64 1 %val = load i64, ptr %ptr1 store i64 %val, ptr %ptr2 ret void } ; Test the f32 case. define dso_local void @f15(ptr %ptr1) { ; CHECK-LABEL: f15: ; CHECK: mvc 4(4,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr float, ptr %ptr1, i64 1 %val = load float, ptr %ptr1 store float %val, ptr %ptr2 ret void } ; Test the f64 case. define dso_local void @f16(ptr %ptr1) { ; CHECK-LABEL: f16: ; CHECK: mvc 8(8,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr double, ptr %ptr1, i64 1 %val = load double, ptr %ptr1 store double %val, ptr %ptr2 ret void } ; Test the f128 case. define dso_local void @f17(ptr %ptr1) { ; CHECK-LABEL: f17: ; CHECK: mvc 16(16,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr fp128, ptr %ptr1, i64 1 %val = load fp128, ptr %ptr1 store fp128 %val, ptr %ptr2 ret void } ; Make sure that we don't use MVC if the load is volatile. define dso_local void @f18(ptr %ptr1) { ; CHECK-LABEL: f18: ; CHECK-NOT: mvc ; CHECK: br %r14 %ptr2 = getelementptr i64, ptr %ptr1, i64 1 %val = load volatile i64, ptr %ptr1 store i64 %val, ptr %ptr2 ret void } ; ...likewise the store. define dso_local void @f19(ptr %ptr1) { ; CHECK-LABEL: f19: ; CHECK-NOT: mvc ; CHECK: br %r14 %ptr2 = getelementptr i64, ptr %ptr1, i64 1 %val = load i64, ptr %ptr1 store volatile i64 %val, ptr %ptr2 ret void } ; Test that MVC is not used for aligned loads and stores if there is ; no way of telling whether they alias. We don't want to use MVC in ; cases where the addresses could be equal. define dso_local void @f20(ptr %ptr1, ptr %ptr2) { ; CHECK-LABEL: f20: ; CHECK-NOT: mvc ; CHECK: br %r14 %val = load i64, ptr %ptr1 store i64 %val, ptr %ptr2 ret void } ; ...and again for unaligned loads and stores. define dso_local void @f21(ptr %ptr1, ptr %ptr2) { ; CHECK-LABEL: f21: ; CHECK-NOT: mvc ; CHECK: br %r14 %val = load i64, ptr %ptr1, align 2 store i64 %val, ptr %ptr2, align 2 ret void } ; Test a case where there is definite overlap. define dso_local void @f22(i64 %base) { ; CHECK-LABEL: f22: ; CHECK-NOT: mvc ; CHECK: br %r14 %add = add i64 %base, 1 %ptr1 = inttoptr i64 %base to ptr %ptr2 = inttoptr i64 %add to ptr %val = load i64, ptr %ptr1, align 1 store i64 %val, ptr %ptr2, align 1 ret void } ; Test that we can use MVC for global addresses for i8. define dso_local void @f23(ptr %ptr) { ; CHECK-LABEL: f23: ; CHECK-DAG: larl [[SRC:%r[0-5]]], g1src ; CHECK-DAG: larl [[DST:%r[0-5]]], g1dst ; CHECK: mvc 0(1,[[DST]]), 0([[SRC]]) ; CHECK: br %r14 %val = load i8, ptr@g1src store i8 %val, ptr@g1dst ret void } ; Test that we use LHRL and STHRL for i16. define dso_local void @f24(ptr %ptr) { ; CHECK-LABEL: f24: ; CHECK: lhrl [[REG:%r[0-5]]], g2src ; CHECK: sthrl [[REG]], g2dst ; CHECK: br %r14 %val = load i16, ptr@g2src store i16 %val, ptr@g2dst ret void } ; Test that we use LRL for i32. define dso_local void @f25(ptr %ptr) { ; CHECK-LABEL: f25: ; CHECK: lrl [[REG:%r[0-5]]], g3 ; CHECK: st [[REG]], 0(%r2) ; CHECK: br %r14 %val = load i32, ptr@g3 store i32 %val, ptr %ptr ret void } ; ...likewise STRL. define dso_local void @f26(ptr %ptr) { ; CHECK-LABEL: f26: ; CHECK: l [[REG:%r[0-5]]], 0(%r2) ; CHECK: strl [[REG]], g3 ; CHECK: br %r14 %val = load i32, ptr %ptr store i32 %val, ptr@g3 ret void } ; Test that we use LGRL for i64. define dso_local void @f27(ptr %ptr) { ; CHECK-LABEL: f27: ; CHECK: lgrl [[REG:%r[0-5]]], g4 ; CHECK: stg [[REG]], 0(%r2) ; CHECK: br %r14 %val = load i64, ptr@g4 store i64 %val, ptr %ptr ret void } ; ...likewise STGRL. define dso_local void @f28(ptr %ptr) { ; CHECK-LABEL: f28: ; CHECK: lg [[REG:%r[0-5]]], 0(%r2) ; CHECK: stgrl [[REG]], g4 ; CHECK: br %r14 %val = load i64, ptr %ptr store i64 %val, ptr@g4 ret void } ; Test that we can use MVC for global addresses for fp128. define dso_local void @f29(ptr %ptr) { ; CHECK-LABEL: f29: ; CHECK-DAG: larl [[SRC:%r[0-5]]], g5src ; CHECK-DAG: larl [[DST:%r[0-5]]], g5dst ; CHECK: mvc 0(16,[[DST]]), 0([[SRC]]) ; CHECK: br %r14 %val = load fp128, ptr@g5src, align 16 store fp128 %val, ptr@g5dst, align 16 ret void } ; Test a case where offset disambiguation is enough. define dso_local void @f30(ptr %ptr1) { ; CHECK-LABEL: f30: ; CHECK: mvc 8(8,%r2), 0(%r2) ; CHECK: br %r14 %ptr2 = getelementptr i64, ptr %ptr1, i64 1 %val = load i64, ptr %ptr1, align 1 store i64 %val, ptr %ptr2, align 1 ret void } ; Test f21 in cases where TBAA tells us there is no alias. define dso_local void @f31(ptr %ptr1, ptr %ptr2) { ; CHECK-LABEL: f31: ; CHECK: mvc 0(8,%r3), 0(%r2) ; CHECK: br %r14 %val = load i64, ptr %ptr1, align 2, !tbaa !1 store i64 %val, ptr %ptr2, align 2, !tbaa !2 ret void } ; Test f21 in cases where TBAA is present but doesn't help. define dso_local void @f32(ptr %ptr1, ptr %ptr2) { ; CHECK-LABEL: f32: ; CHECK-NOT: mvc ; CHECK: br %r14 %val = load i64, ptr %ptr1, align 2, !tbaa !1 store i64 %val, ptr %ptr2, align 2, !tbaa !1 ret void } !0 = !{ !"root" } !1 = !{ !3, !3, i64 0 } !2 = !{ !4, !4, i64 0 } !3 = !{ !"set1", !0 } !4 = !{ !"set2", !0 }