213 lines · plain
1; Test 32-bit addition in which the second operand is constant.2;3; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z10 | FileCheck %s4; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z196 | FileCheck %s5 6declare i32 @foo()7 8; Check additions of 1.9define zeroext i1 @f1(i32 %dummy, i32 %a, ptr %res) {10; CHECK-LABEL: f1:11; CHECK: ahi %r3, 112; CHECK-DAG: st %r3, 0(%r4)13; CHECK-DAG: ipm [[REG:%r[0-5]]]14; CHECK-DAG: afi [[REG]], 134217728015; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3316; CHECK: br %r1417 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 1)18 %val = extractvalue {i32, i1} %t, 019 %obit = extractvalue {i32, i1} %t, 120 store i32 %val, ptr %res21 ret i1 %obit22}23 24; Check the high end of the AHI range.25define zeroext i1 @f2(i32 %dummy, i32 %a, ptr %res) {26; CHECK-LABEL: f2:27; CHECK: ahi %r3, 3276728; CHECK-DAG: st %r3, 0(%r4)29; CHECK-DAG: ipm [[REG:%r[0-5]]]30; CHECK-DAG: afi [[REG]], 134217728031; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3332; CHECK: br %r1433 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 32767)34 %val = extractvalue {i32, i1} %t, 035 %obit = extractvalue {i32, i1} %t, 136 store i32 %val, ptr %res37 ret i1 %obit38}39 40; Check the next value up, which must use AFI instead.41define zeroext i1 @f3(i32 %dummy, i32 %a, ptr %res) {42; CHECK-LABEL: f3:43; CHECK: afi %r3, 3276844; CHECK-DAG: st %r3, 0(%r4)45; CHECK-DAG: ipm [[REG:%r[0-5]]]46; CHECK-DAG: afi [[REG]], 134217728047; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3348; CHECK: br %r1449 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 32768)50 %val = extractvalue {i32, i1} %t, 051 %obit = extractvalue {i32, i1} %t, 152 store i32 %val, ptr %res53 ret i1 %obit54}55 56; Check the high end of the signed 32-bit range.57define zeroext i1 @f4(i32 %dummy, i32 %a, ptr %res) {58; CHECK-LABEL: f4:59; CHECK: afi %r3, 214748364760; CHECK-DAG: st %r3, 0(%r4)61; CHECK-DAG: ipm [[REG:%r[0-5]]]62; CHECK-DAG: afi [[REG]], 134217728063; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3364; CHECK: br %r1465 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 2147483647)66 %val = extractvalue {i32, i1} %t, 067 %obit = extractvalue {i32, i1} %t, 168 store i32 %val, ptr %res69 ret i1 %obit70}71 72; Check the next value up, which is treated as a negative value.73define zeroext i1 @f5(i32 %dummy, i32 %a, ptr %res) {74; CHECK-LABEL: f5:75; CHECK: afi %r3, -214748364876; CHECK-DAG: st %r3, 0(%r4)77; CHECK-DAG: ipm [[REG:%r[0-5]]]78; CHECK-DAG: afi [[REG]], 134217728079; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3380; CHECK: br %r1481 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 2147483648)82 %val = extractvalue {i32, i1} %t, 083 %obit = extractvalue {i32, i1} %t, 184 store i32 %val, ptr %res85 ret i1 %obit86}87 88; Check the high end of the negative AHI range.89define zeroext i1 @f6(i32 %dummy, i32 %a, ptr %res) {90; CHECK-LABEL: f6:91; CHECK: ahi %r3, -192; CHECK-DAG: st %r3, 0(%r4)93; CHECK-DAG: ipm [[REG:%r[0-5]]]94; CHECK-DAG: afi [[REG]], 134217728095; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3396; CHECK: br %r1497 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 -1)98 %val = extractvalue {i32, i1} %t, 099 %obit = extractvalue {i32, i1} %t, 1100 store i32 %val, ptr %res101 ret i1 %obit102}103 104; Check the low end of the AHI range.105define zeroext i1 @f7(i32 %dummy, i32 %a, ptr %res) {106; CHECK-LABEL: f7:107; CHECK: ahi %r3, -32768108; CHECK-DAG: st %r3, 0(%r4)109; CHECK-DAG: ipm [[REG:%r[0-5]]]110; CHECK-DAG: afi [[REG]], 1342177280111; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 33112; CHECK: br %r14113 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 -32768)114 %val = extractvalue {i32, i1} %t, 0115 %obit = extractvalue {i32, i1} %t, 1116 store i32 %val, ptr %res117 ret i1 %obit118}119 120; Check the next value down, which must use AFI instead.121define zeroext i1 @f8(i32 %dummy, i32 %a, ptr %res) {122; CHECK-LABEL: f8:123; CHECK: afi %r3, -32769124; CHECK-DAG: st %r3, 0(%r4)125; CHECK-DAG: ipm [[REG:%r[0-5]]]126; CHECK-DAG: afi [[REG]], 1342177280127; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 33128; CHECK: br %r14129 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 -32769)130 %val = extractvalue {i32, i1} %t, 0131 %obit = extractvalue {i32, i1} %t, 1132 store i32 %val, ptr %res133 ret i1 %obit134}135 136; Check the low end of the signed 32-bit range.137define zeroext i1 @f9(i32 %dummy, i32 %a, ptr %res) {138; CHECK-LABEL: f9:139; CHECK: afi %r3, -2147483648140; CHECK-DAG: st %r3, 0(%r4)141; CHECK-DAG: ipm [[REG:%r[0-5]]]142; CHECK-DAG: afi [[REG]], 1342177280143; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 33144; CHECK: br %r14145 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 -2147483648)146 %val = extractvalue {i32, i1} %t, 0147 %obit = extractvalue {i32, i1} %t, 1148 store i32 %val, ptr %res149 ret i1 %obit150}151 152; Check the next value down, which is treated as a positive value.153define zeroext i1 @f10(i32 %dummy, i32 %a, ptr %res) {154; CHECK-LABEL: f10:155; CHECK: afi %r3, 2147483647156; CHECK-DAG: st %r3, 0(%r4)157; CHECK-DAG: ipm [[REG:%r[0-5]]]158; CHECK-DAG: afi [[REG]], 1342177280159; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 33160; CHECK: br %r14161 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 -2147483649)162 %val = extractvalue {i32, i1} %t, 0163 %obit = extractvalue {i32, i1} %t, 1164 store i32 %val, ptr %res165 ret i1 %obit166}167 168; Check using the overflow result for a branch.169define void @f11(i32 %dummy, i32 %a, ptr %res) {170; CHECK-LABEL: f11:171; CHECK: ahi %r3, 1172; CHECK: st %r3, 0(%r4)173; CHECK: {{jgo foo@PLT|bnor %r14}}174; CHECK: {{br %r14|jg foo@PLT}}175 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 1)176 %val = extractvalue {i32, i1} %t, 0177 %obit = extractvalue {i32, i1} %t, 1178 store i32 %val, ptr %res179 br i1 %obit, label %call, label %exit180 181call:182 tail call i32 @foo()183 br label %exit184 185exit:186 ret void187}188 189; ... and the same with the inverted direction.190define void @f12(i32 %dummy, i32 %a, ptr %res) {191; CHECK-LABEL: f12:192; CHECK: ahi %r3, 1193; CHECK: st %r3, 0(%r4)194; CHECK: {{jgno foo@PLT|bor %r14}}195; CHECK: {{br %r14|jg foo@PLT}}196 %t = call {i32, i1} @llvm.sadd.with.overflow.i32(i32 %a, i32 1)197 %val = extractvalue {i32, i1} %t, 0198 %obit = extractvalue {i32, i1} %t, 1199 store i32 %val, ptr %res200 br i1 %obit, label %exit, label %call201 202call:203 tail call i32 @foo()204 br label %exit205 206exit:207 ret void208}209 210 211declare {i32, i1} @llvm.sadd.with.overflow.i32(i32, i32) nounwind readnone212 213