394 lines · plain
1; Test memory-to-memory ANDs.2;3; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s4 5@g1src = dso_local global i8 16@g1dst = dso_local global i8 17@g2src = dso_local global i16 28@g2dst = dso_local global i16 29 10; Test the simple i8 case.11define dso_local void @f1(ptr %ptr1) {12; CHECK-LABEL: f1:13; CHECK: nc 1(1,%r2), 0(%r2)14; CHECK: br %r1415 %ptr2 = getelementptr i8, ptr %ptr1, i64 116 %val = load i8, ptr %ptr117 %old = load i8, ptr %ptr218 %and = and i8 %val, %old19 store i8 %and, ptr %ptr220 ret void21}22 23; ...and again in reverse.24define dso_local void @f2(ptr %ptr1) {25; CHECK-LABEL: f2:26; CHECK: nc 1(1,%r2), 0(%r2)27; CHECK: br %r1428 %ptr2 = getelementptr i8, ptr %ptr1, i64 129 %val = load i8, ptr %ptr130 %old = load i8, ptr %ptr231 %and = and i8 %old, %val32 store i8 %and, ptr %ptr233 ret void34}35 36; Test i8 cases where one value is zero-extended to 32 bits and the other37; sign-extended.38define dso_local void @f3(ptr %ptr1) {39; CHECK-LABEL: f3:40; CHECK: nc 1(1,%r2), 0(%r2)41; CHECK: br %r1442 %ptr2 = getelementptr i8, ptr %ptr1, i64 143 %val = load i8, ptr %ptr144 %extval = zext i8 %val to i3245 %old = load i8, ptr %ptr246 %extold = sext i8 %old to i3247 %and = and i32 %extval, %extold48 %trunc = trunc i32 %and to i849 store i8 %trunc, ptr %ptr250 ret void51}52 53; ...and again with the extension types reversed.54define dso_local void @f4(ptr %ptr1) {55; CHECK-LABEL: f4:56; CHECK: nc 1(1,%r2), 0(%r2)57; CHECK: br %r1458 %ptr2 = getelementptr i8, ptr %ptr1, i64 159 %val = load i8, ptr %ptr160 %extval = sext i8 %val to i3261 %old = load i8, ptr %ptr262 %extold = zext i8 %old to i3263 %and = and i32 %extval, %extold64 %trunc = trunc i32 %and to i865 store i8 %trunc, ptr %ptr266 ret void67}68 69; ...and again with two sign extensions.70define dso_local void @f5(ptr %ptr1) {71; CHECK-LABEL: f5:72; CHECK: nc 1(1,%r2), 0(%r2)73; CHECK: br %r1474 %ptr2 = getelementptr i8, ptr %ptr1, i64 175 %val = load i8, ptr %ptr176 %extval = sext i8 %val to i3277 %old = load i8, ptr %ptr278 %extold = sext i8 %old to i3279 %and = and i32 %extval, %extold80 %trunc = trunc i32 %and to i881 store i8 %trunc, ptr %ptr282 ret void83}84 85; ...and again with two zero extensions.86define dso_local void @f6(ptr %ptr1) {87; CHECK-LABEL: f6:88; CHECK: nc 1(1,%r2), 0(%r2)89; CHECK: br %r1490 %ptr2 = getelementptr i8, ptr %ptr1, i64 191 %val = load i8, ptr %ptr192 %extval = zext i8 %val to i3293 %old = load i8, ptr %ptr294 %extold = zext i8 %old to i3295 %and = and i32 %extval, %extold96 %trunc = trunc i32 %and to i897 store i8 %trunc, ptr %ptr298 ret void99}100 101; Test i8 cases where the value is extended to 64 bits (just one case102; this time).103define dso_local void @f7(ptr %ptr1) {104; CHECK-LABEL: f7:105; CHECK: nc 1(1,%r2), 0(%r2)106; CHECK: br %r14107 %ptr2 = getelementptr i8, ptr %ptr1, i64 1108 %val = load i8, ptr %ptr1109 %extval = sext i8 %val to i64110 %old = load i8, ptr %ptr2111 %extold = zext i8 %old to i64112 %and = and i64 %extval, %extold113 %trunc = trunc i64 %and to i8114 store i8 %trunc, ptr %ptr2115 ret void116}117 118; Test the simple i16 case.119define dso_local void @f8(ptr %ptr1) {120; CHECK-LABEL: f8:121; CHECK: nc 2(2,%r2), 0(%r2)122; CHECK: br %r14123 %ptr2 = getelementptr i16, ptr %ptr1, i64 1124 %val = load i16, ptr %ptr1125 %old = load i16, ptr %ptr2126 %and = and i16 %val, %old127 store i16 %and, ptr %ptr2128 ret void129}130 131; Test i16 cases where the value is extended to 32 bits.132define dso_local void @f9(ptr %ptr1) {133; CHECK-LABEL: f9:134; CHECK: nc 2(2,%r2), 0(%r2)135; CHECK: br %r14136 %ptr2 = getelementptr i16, ptr %ptr1, i64 1137 %val = load i16, ptr %ptr1138 %extval = zext i16 %val to i32139 %old = load i16, ptr %ptr2140 %extold = sext i16 %old to i32141 %and = and i32 %extval, %extold142 %trunc = trunc i32 %and to i16143 store i16 %trunc, ptr %ptr2144 ret void145}146 147; Test i16 cases where the value is extended to 64 bits.148define dso_local void @f10(ptr %ptr1) {149; CHECK-LABEL: f10:150; CHECK: nc 2(2,%r2), 0(%r2)151; CHECK: br %r14152 %ptr2 = getelementptr i16, ptr %ptr1, i64 1153 %val = load i16, ptr %ptr1154 %extval = sext i16 %val to i64155 %old = load i16, ptr %ptr2156 %extold = zext i16 %old to i64157 %and = and i64 %extval, %extold158 %trunc = trunc i64 %and to i16159 store i16 %trunc, ptr %ptr2160 ret void161}162 163; Test the simple i32 case.164define dso_local void @f11(ptr %ptr1) {165; CHECK-LABEL: f11:166; CHECK: nc 4(4,%r2), 0(%r2)167; CHECK: br %r14168 %ptr2 = getelementptr i32, ptr %ptr1, i64 1169 %val = load i32, ptr %ptr1170 %old = load i32, ptr %ptr2171 %and = and i32 %old, %val172 store i32 %and, ptr %ptr2173 ret void174}175 176; Test i32 cases where the value is extended to 64 bits.177define dso_local void @f12(ptr %ptr1) {178; CHECK-LABEL: f12:179; CHECK: nc 4(4,%r2), 0(%r2)180; CHECK: br %r14181 %ptr2 = getelementptr i32, ptr %ptr1, i64 1182 %val = load i32, ptr %ptr1183 %extval = sext i32 %val to i64184 %old = load i32, ptr %ptr2185 %extold = zext i32 %old to i64186 %and = and i64 %extval, %extold187 %trunc = trunc i64 %and to i32188 store i32 %trunc, ptr %ptr2189 ret void190}191 192; Test the i64 case.193define dso_local void @f13(ptr %ptr1) {194; CHECK-LABEL: f13:195; CHECK: nc 8(8,%r2), 0(%r2)196; CHECK: br %r14197 %ptr2 = getelementptr i64, ptr %ptr1, i64 1198 %val = load i64, ptr %ptr1199 %old = load i64, ptr %ptr2200 %and = and i64 %old, %val201 store i64 %and, ptr %ptr2202 ret void203}204 205; Make sure that we don't use NC if the first load is volatile.206define dso_local void @f14(ptr %ptr1) {207; CHECK-LABEL: f14:208; CHECK-NOT: nc209; CHECK: br %r14210 %ptr2 = getelementptr i64, ptr %ptr1, i64 1211 %val = load volatile i64, ptr %ptr1212 %old = load i64, ptr %ptr2213 %and = and i64 %old, %val214 store i64 %and, ptr %ptr2215 ret void216}217 218; ...likewise the second.219define dso_local void @f15(ptr %ptr1) {220; CHECK-LABEL: f15:221; CHECK-NOT: nc222; CHECK: br %r14223 %ptr2 = getelementptr i64, ptr %ptr1, i64 1224 %val = load i64, ptr %ptr1225 %old = load volatile i64, ptr %ptr2226 %and = and i64 %old, %val227 store i64 %and, ptr %ptr2228 ret void229}230 231; ...likewise the store.232define dso_local void @f16(ptr %ptr1) {233; CHECK-LABEL: f16:234; CHECK-NOT: nc235; CHECK: br %r14236 %ptr2 = getelementptr i64, ptr %ptr1, i64 1237 %val = load i64, ptr %ptr1238 %old = load i64, ptr %ptr2239 %and = and i64 %old, %val240 store volatile i64 %and, ptr %ptr2241 ret void242}243 244; Test that NC is not used for aligned loads and stores if there is245; no way of telling whether they alias. We don't want to use NC in246; cases where the addresses could be equal.247define dso_local void @f17(ptr %ptr1, ptr %ptr2) {248; CHECK-LABEL: f17:249; CHECK-NOT: nc250; CHECK: br %r14251 %val = load i64, ptr %ptr1252 %old = load i64, ptr %ptr2253 %and = and i64 %old, %val254 store i64 %and, ptr %ptr2255 ret void256}257 258; ...but if one of the loads isn't aligned, we can't be sure.259define dso_local void @f18(ptr %ptr1, ptr %ptr2) {260; CHECK-LABEL: f18:261; CHECK-NOT: nc262; CHECK: br %r14263 %val = load i64, ptr %ptr1, align 2264 %old = load i64, ptr %ptr2265 %and = and i64 %old, %val266 store i64 %and, ptr %ptr2267 ret void268}269 270; Repeat the previous test with the operands in the opposite order.271define dso_local void @f19(ptr %ptr1, ptr %ptr2) {272; CHECK-LABEL: f19:273; CHECK-NOT: nc274; CHECK: br %r14275 %val = load i64, ptr %ptr1, align 2276 %old = load i64, ptr %ptr2277 %and = and i64 %val, %old278 store i64 %and, ptr %ptr2279 ret void280}281 282; ...and again with the other operand being unaligned.283define dso_local void @f20(ptr %ptr1, ptr %ptr2) {284; CHECK-LABEL: f20:285; CHECK-NOT: nc286; CHECK: br %r14287 %val = load i64, ptr %ptr1288 %old = load i64, ptr %ptr2, align 2289 %and = and i64 %val, %old290 store i64 %and, ptr %ptr2, align 2291 ret void292}293 294; Test a case where there is definite overlap.295define dso_local void @f21(i64 %base) {296; CHECK-LABEL: f21:297; CHECK-NOT: nc298; CHECK: br %r14299 %add = add i64 %base, 1300 %ptr1 = inttoptr i64 %base to ptr301 %ptr2 = inttoptr i64 %add to ptr302 %val = load i64, ptr %ptr1303 %old = load i64, ptr %ptr2, align 1304 %and = and i64 %old, %val305 store i64 %and, ptr %ptr2, align 1306 ret void307}308 309; Test that we can use NC for global addresses for i8.310define dso_local void @f22(ptr %ptr) {311; CHECK-LABEL: f22:312; CHECK-DAG: larl [[SRC:%r[0-5]]], g1src313; CHECK-DAG: larl [[DST:%r[0-5]]], g1dst314; CHECK: nc 0(1,[[DST]]), 0([[SRC]])315; CHECK: br %r14316 %val = load i8, ptr@g1src317 %old = load i8, ptr@g1dst318 %and = and i8 %val, %old319 store i8 %and, ptr@g1dst320 ret void321}322 323; Test that we use NC even where LHRL and STHRL are available.324define dso_local void @f23(ptr %ptr) {325; CHECK-LABEL: f23:326; CHECK-DAG: larl [[SRC:%r[0-5]]], g2src327; CHECK-DAG: larl [[DST:%r[0-5]]], g2dst328; CHECK: nc 0(2,[[DST]]), 0([[SRC]])329; CHECK: br %r14330 %val = load i16, ptr@g2src331 %old = load i16, ptr@g2dst332 %and = and i16 %val, %old333 store i16 %and, ptr@g2dst334 ret void335}336 337; Test a case where offset disambiguation is enough.338define dso_local void @f24(ptr %ptr1) {339; CHECK-LABEL: f24:340; CHECK: nc 8(8,%r2), 0(%r2)341; CHECK: br %r14342 %ptr2 = getelementptr i64, ptr %ptr1, i64 1343 %val = load i64, ptr %ptr1, align 1344 %old = load i64, ptr %ptr2, align 1345 %and = and i64 %old, %val346 store i64 %and, ptr %ptr2, align 1347 ret void348}349 350; Test a case where TBAA tells us there is no alias.351define dso_local void @f25(ptr %ptr1, ptr %ptr2) {352; CHECK-LABEL: f25:353; CHECK: nc 0(8,%r3), 0(%r2)354; CHECK: br %r14355 %val = load i64, ptr %ptr1, align 2, !tbaa !3356 %old = load i64, ptr %ptr2, align 2, !tbaa !4357 %and = and i64 %old, %val358 store i64 %and, ptr %ptr2, align 2, !tbaa !4359 ret void360}361 362; Test a case where TBAA information is present but doesn't help.363define dso_local void @f26(ptr %ptr1, ptr %ptr2) {364; CHECK-LABEL: f26:365; CHECK-NOT: nc366; CHECK: br %r14367 %val = load i64, ptr %ptr1, align 2, !tbaa !3368 %old = load i64, ptr %ptr2, align 2, !tbaa !3369 %and = and i64 %old, %val370 store i64 %and, ptr %ptr2, align 2, !tbaa !3371 ret void372}373 374; Test a case where one of the loads are optimized by the DAGCombiner to a375; zero-extending load of half the original size.376define dso_local void @f27(ptr noalias %ptr1, ptr noalias %ptr2) {377; CHECK-LABEL: f27:378; CHECK-NOT: nc379; CHECK: br %r14380entry:381 %0 = load i16, ptr %ptr1, align 2382 %1 = lshr i16 %0, 8383 %2 = load i16, ptr %ptr2, align 2384 %and7 = and i16 %1, %2385 store i16 %and7, ptr %ptr1, align 2386 ret void387}388 389!0 = !{ !"root" }390!1 = !{ !"set1", !0 }391!2 = !{ !"set2", !0 }392!3 = !{ !1, !1, i64 0}393!4 = !{ !2, !2, i64 0}394