1 ; Test memcpy using MVC. 2 ; 3 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s 4 5 declare void @llvm.memcpy.p0i8.p0i8.i32(i8 *nocapture, i8 *nocapture, i32, i1) nounwind 6 declare void @llvm.memcpy.p0i8.p0i8.i64(i8 *nocapture, i8 *nocapture, i64, i1) nounwind 7 declare void @foo(i8 *, i8 *) 8 9 ; Test a no-op move, i32 version. 10 define void @f1(i8* %dest, i8* %src) { 11 ; CHECK-LABEL: f1: 12 ; CHECK-NOT: %r2 13 ; CHECK-NOT: %r3 14 ; CHECK: br %r14 15 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 0, i1 false) 16 ret void 17 } 18 19 ; Test a no-op move, i64 version. 20 define void @f2(i8* %dest, i8* %src) { 21 ; CHECK-LABEL: f2: 22 ; CHECK-NOT: %r2 23 ; CHECK-NOT: %r3 24 ; CHECK: br %r14 25 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 0, i1 false) 26 ret void 27 } 28 29 ; Test a 1-byte move, i32 version. 30 define void @f3(i8* %dest, i8* %src) { 31 ; CHECK-LABEL: f3: 32 ; CHECK: mvc 0(1,%r2), 0(%r3) 33 ; CHECK: br %r14 34 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 1, i1 false) 35 ret void 36 } 37 38 ; Test a 1-byte move, i64 version. 39 define void @f4(i8* %dest, i8* %src) { 40 ; CHECK-LABEL: f4: 41 ; CHECK: mvc 0(1,%r2), 0(%r3) 42 ; CHECK: br %r14 43 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1, i1 false) 44 ret void 45 } 46 47 ; Test the upper range of a single MVC, i32 version. 48 define void @f5(i8* %dest, i8* %src) { 49 ; CHECK-LABEL: f5: 50 ; CHECK: mvc 0(256,%r2), 0(%r3) 51 ; CHECK: br %r14 52 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 256, i1 false) 53 ret void 54 } 55 56 ; Test the upper range of a single MVC, i64 version. 57 define void @f6(i8* %dest, i8* %src) { 58 ; CHECK-LABEL: f6: 59 ; CHECK: mvc 0(256,%r2), 0(%r3) 60 ; CHECK: br %r14 61 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 256, i1 false) 62 ret void 63 } 64 65 ; Test the first case that needs two MVCs. 66 define void @f7(i8* %dest, i8* %src) { 67 ; CHECK-LABEL: f7: 68 ; CHECK: mvc 0(256,%r2), 0(%r3) 69 ; CHECK: mvc 256(1,%r2), 256(%r3) 70 ; CHECK: br %r14 71 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 257, i1 false) 72 ret void 73 } 74 75 ; Test the last-but-one case that needs two MVCs. 76 define void @f8(i8* %dest, i8* %src) { 77 ; CHECK-LABEL: f8: 78 ; CHECK: mvc 0(256,%r2), 0(%r3) 79 ; CHECK: mvc 256(255,%r2), 256(%r3) 80 ; CHECK: br %r14 81 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 511, i1 false) 82 ret void 83 } 84 85 ; Test the last case that needs two MVCs. 86 define void @f9(i8* %dest, i8* %src) { 87 ; CHECK-LABEL: f9: 88 ; CHECK: mvc 0(256,%r2), 0(%r3) 89 ; CHECK: mvc 256(256,%r2), 256(%r3) 90 ; CHECK: br %r14 91 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 512, i1 false) 92 ret void 93 } 94 95 ; Test an arbitrary value that uses straight-line code. 96 define void @f10(i8* %dest, i8* %src) { 97 ; CHECK-LABEL: f10: 98 ; CHECK: mvc 0(256,%r2), 0(%r3) 99 ; CHECK: mvc 256(256,%r2), 256(%r3) 100 ; CHECK: mvc 512(256,%r2), 512(%r3) 101 ; CHECK: mvc 768(256,%r2), 768(%r3) 102 ; CHECK: mvc 1024(255,%r2), 1024(%r3) 103 ; CHECK: br %r14 104 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false) 105 ret void 106 } 107 108 ; ...and again in cases where not all parts are in range of MVC. 109 define void @f11(i8* %srcbase, i8* %destbase) { 110 ; CHECK-LABEL: f11: 111 ; CHECK: mvc 4000(256,%r2), 3500(%r3) 112 ; CHECK: lay [[NEWDEST:%r[1-5]]], 4256(%r2) 113 ; CHECK: mvc 0(256,[[NEWDEST]]), 3756(%r3) 114 ; CHECK: mvc 256(256,[[NEWDEST]]), 4012(%r3) 115 ; CHECK: lay [[NEWSRC:%r[1-5]]], 4268(%r3) 116 ; CHECK: mvc 512(256,[[NEWDEST]]), 0([[NEWSRC]]) 117 ; CHECK: mvc 768(255,[[NEWDEST]]), 256([[NEWSRC]]) 118 ; CHECK: br %r14 119 %dest = getelementptr i8, i8* %srcbase, i64 4000 120 %src = getelementptr i8, i8* %destbase, i64 3500 121 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false) 122 ret void 123 } 124 125 ; ...and again with a destination frame base that goes out of range. 126 define void @f12() { 127 ; CHECK-LABEL: f12: 128 ; CHECK: brasl %r14, foo@PLT 129 ; CHECK: mvc 4076(256,%r15), 2100(%r15) 130 ; CHECK: lay [[NEWDEST:%r[1-5]]], 4332(%r15) 131 ; CHECK: mvc 0(256,[[NEWDEST]]), 2356(%r15) 132 ; CHECK: mvc 256(256,[[NEWDEST]]), 2612(%r15) 133 ; CHECK: mvc 512(256,[[NEWDEST]]), 2868(%r15) 134 ; CHECK: mvc 768(255,[[NEWDEST]]), 3124(%r15) 135 ; CHECK: brasl %r14, foo@PLT 136 ; CHECK: br %r14 137 %arr = alloca [6000 x i8] 138 %dest = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 3900 139 %src = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 1924 140 call void @foo(i8* %dest, i8* %src) 141 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false) 142 call void @foo(i8* %dest, i8* %src) 143 ret void 144 } 145 146 ; ...and again with a source frame base that goes out of range. 147 define void @f13() { 148 ; CHECK-LABEL: f13: 149 ; CHECK: brasl %r14, foo@PLT 150 ; CHECK: mvc 200(256,%r15), 3826(%r15) 151 ; CHECK: mvc 456(256,%r15), 4082(%r15) 152 ; CHECK: lay [[NEWSRC:%r[1-5]]], 4338(%r15) 153 ; CHECK: mvc 712(256,%r15), 0([[NEWSRC]]) 154 ; CHECK: mvc 968(256,%r15), 256([[NEWSRC]]) 155 ; CHECK: mvc 1224(255,%r15), 512([[NEWSRC]]) 156 ; CHECK: brasl %r14, foo@PLT 157 ; CHECK: br %r14 158 %arr = alloca [6000 x i8] 159 %dest = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 24 160 %src = getelementptr [6000 x i8], [6000 x i8] *%arr, i64 0, i64 3650 161 call void @foo(i8* %dest, i8* %src) 162 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1279, i1 false) 163 call void @foo(i8* %dest, i8* %src) 164 ret void 165 } 166 167 ; Test the last case that is done using straight-line code. 168 define void @f14(i8* %dest, i8* %src) { 169 ; CHECK-LABEL: f14: 170 ; CHECK: mvc 0(256,%r2), 0(%r3) 171 ; CHECK: mvc 256(256,%r2), 256(%r3) 172 ; CHECK: mvc 512(256,%r2), 512(%r3) 173 ; CHECK: mvc 768(256,%r2), 768(%r3) 174 ; CHECK: mvc 1024(256,%r2), 1024(%r3) 175 ; CHECK: mvc 1280(256,%r2), 1280(%r3) 176 ; CHECK: br %r14 177 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1536, i1 false) 178 ret void 179 } 180 181 ; Test the first case that is done using a loop. 182 define void @f15(i8* %dest, i8* %src) { 183 ; CHECK-LABEL: f15: 184 ; CHECK: lghi [[COUNT:%r[0-5]]], 6 185 ; CHECK: [[LABEL:\.L[^:]*]]: 186 ; CHECK: pfd 2, 768(%r2) 187 ; CHECK: mvc 0(256,%r2), 0(%r3) 188 ; CHECK: la %r2, 256(%r2) 189 ; CHECK: la %r3, 256(%r3) 190 ; CHECK: brctg [[COUNT]], [[LABEL]] 191 ; CHECK: mvc 0(1,%r2), 0(%r3) 192 ; CHECK: br %r14 193 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1537, i1 false) 194 ret void 195 } 196 197 ; ...and again with frame bases, where the base must be loaded into a 198 ; register before the loop. 199 define void @f16() { 200 ; CHECK-LABEL: f16: 201 ; CHECK: brasl %r14, foo@PLT 202 ; CHECK-DAG: lghi [[COUNT:%r[0-5]]], 6 203 ; CHECK-DAG: la [[BASE:%r[0-5]]], 160(%r15) 204 ; CHECK: [[LABEL:\.L[^:]*]]: 205 ; CHECK: pfd 2, 2368([[BASE]]) 206 ; CHECK: mvc 1600(256,[[BASE]]), 0([[BASE]]) 207 ; CHECK: la [[BASE]], 256([[BASE]]) 208 ; CHECK: brctg [[COUNT]], [[LABEL]] 209 ; CHECK: mvc 1600(1,[[BASE]]), 0([[BASE]]) 210 ; CHECK: brasl %r14, foo@PLT 211 ; CHECK: br %r14 212 %arr = alloca [3200 x i8] 213 %dest = getelementptr [3200 x i8], [3200 x i8] *%arr, i64 0, i64 1600 214 %src = getelementptr [3200 x i8], [3200 x i8] *%arr, i64 0, i64 0 215 call void @foo(i8* %dest, i8* %src) 216 call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dest, i8* %src, i64 1537, i1 false) 217 call void @foo(i8* %dest, i8* %src) 218 ret void 219 } 220
