491 lines · plain
1; Test 64-bit additions of constants to memory.2;3; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s4 5declare i64 @foo()6 7; Check addition of 1.8define zeroext i1 @f1(ptr %ptr) {9; CHECK-LABEL: f1:10; CHECK: agsi 0(%r2), 111; CHECK: ipm [[REG:%r[0-5]]]12; CHECK: afi [[REG]], 134217728013; CHECK: risbg %r2, [[REG]], 63, 191, 3314; CHECK: br %r1415 %a = load i64, ptr %ptr16 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)17 %val = extractvalue {i64, i1} %t, 018 %obit = extractvalue {i64, i1} %t, 119 store i64 %val, ptr %ptr20 ret i1 %obit21}22 23; Check the high end of the constant range.24define zeroext i1 @f2(ptr %ptr) {25; CHECK-LABEL: f2:26; CHECK: agsi 0(%r2), 12727; CHECK: ipm [[REG:%r[0-5]]]28; CHECK: afi [[REG]], 134217728029; CHECK: risbg %r2, [[REG]], 63, 191, 3330; CHECK: br %r1431 %a = load i64, ptr %ptr32 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 127)33 %val = extractvalue {i64, i1} %t, 034 %obit = extractvalue {i64, i1} %t, 135 store i64 %val, ptr %ptr36 ret i1 %obit37}38 39; Check the next constant up, which must use an addition and a store.40define zeroext i1 @f3(i64 %dummy, ptr %ptr) {41; CHECK-LABEL: f3:42; CHECK: lg [[VAL:%r[0-5]]], 0(%r3)43; CHECK: aghi [[VAL]], 12844; CHECK-DAG: stg [[VAL]], 0(%r3)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 %a = load i64, ptr %ptr50 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 128)51 %val = extractvalue {i64, i1} %t, 052 %obit = extractvalue {i64, i1} %t, 153 store i64 %val, ptr %ptr54 ret i1 %obit55}56 57; Check the low end of the constant range.58define zeroext i1 @f4(ptr %ptr) {59; CHECK-LABEL: f4:60; CHECK: agsi 0(%r2), -12861; CHECK: ipm [[REG:%r[0-5]]]62; CHECK: afi [[REG]], 134217728063; CHECK: risbg %r2, [[REG]], 63, 191, 3364; CHECK: br %r1465 %a = load i64, ptr %ptr66 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 -128)67 %val = extractvalue {i64, i1} %t, 068 %obit = extractvalue {i64, i1} %t, 169 store i64 %val, ptr %ptr70 ret i1 %obit71}72 73; Check the next value down, with the same comment as f3.74define zeroext i1 @f5(i64 %dummy, ptr %ptr) {75; CHECK-LABEL: f5:76; CHECK: lg [[VAL:%r[0-5]]], 0(%r3)77; CHECK: aghi [[VAL]], -12978; CHECK-DAG: stg [[VAL]], 0(%r3)79; CHECK-DAG: ipm [[REG:%r[0-5]]]80; CHECK-DAG: afi [[REG]], 134217728081; CHECK-DAG: risbg %r2, [[REG]], 63, 191, 3382; CHECK: br %r1483 %a = load i64, ptr %ptr84 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 -129)85 %val = extractvalue {i64, i1} %t, 086 %obit = extractvalue {i64, i1} %t, 187 store i64 %val, ptr %ptr88 ret i1 %obit89}90 91; Check the high end of the aligned AGSI range.92define zeroext i1 @f6(ptr %base) {93; CHECK-LABEL: f6:94; CHECK: agsi 524280(%r2), 195; CHECK: ipm [[REG:%r[0-5]]]96; CHECK: afi [[REG]], 134217728097; CHECK: risbg %r2, [[REG]], 63, 191, 3398; CHECK: br %r1499 %ptr = getelementptr i64, ptr %base, i64 65535100 %a = load i64, ptr %ptr101 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)102 %val = extractvalue {i64, i1} %t, 0103 %obit = extractvalue {i64, i1} %t, 1104 store i64 %val, ptr %ptr105 ret i1 %obit106}107 108; Check the next word up, which must use separate address logic.109; Other sequences besides this one would be OK.110define zeroext i1 @f7(ptr %base) {111; CHECK-LABEL: f7:112; CHECK: agfi %r2, 524288113; CHECK: agsi 0(%r2), 1114; CHECK: ipm [[REG:%r[0-5]]]115; CHECK: afi [[REG]], 1342177280116; CHECK: risbg %r2, [[REG]], 63, 191, 33117; CHECK: br %r14118 %ptr = getelementptr i64, ptr %base, i64 65536119 %a = load i64, ptr %ptr120 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)121 %val = extractvalue {i64, i1} %t, 0122 %obit = extractvalue {i64, i1} %t, 1123 store i64 %val, ptr %ptr124 ret i1 %obit125}126 127; Check the low end of the AGSI range.128define zeroext i1 @f8(ptr %base) {129; CHECK-LABEL: f8:130; CHECK: agsi -524288(%r2), 1131; CHECK: ipm [[REG:%r[0-5]]]132; CHECK: afi [[REG]], 1342177280133; CHECK: risbg %r2, [[REG]], 63, 191, 33134; CHECK: br %r14135 %ptr = getelementptr i64, ptr %base, i64 -65536136 %a = load i64, ptr %ptr137 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)138 %val = extractvalue {i64, i1} %t, 0139 %obit = extractvalue {i64, i1} %t, 1140 store i64 %val, ptr %ptr141 ret i1 %obit142}143 144; Check the next word down, which must use separate address logic.145; Other sequences besides this one would be OK.146define zeroext i1 @f9(ptr %base) {147; CHECK-LABEL: f9:148; CHECK: agfi %r2, -524296149; CHECK: agsi 0(%r2), 1150; CHECK: ipm [[REG:%r[0-5]]]151; CHECK: afi [[REG]], 1342177280152; CHECK: risbg %r2, [[REG]], 63, 191, 33153; CHECK: br %r14154 %ptr = getelementptr i64, ptr %base, i64 -65537155 %a = load i64, ptr %ptr156 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)157 %val = extractvalue {i64, i1} %t, 0158 %obit = extractvalue {i64, i1} %t, 1159 store i64 %val, ptr %ptr160 ret i1 %obit161}162 163; Check that AGSI does not allow indices.164define zeroext i1 @f10(i64 %base, i64 %index) {165; CHECK-LABEL: f10:166; CHECK: agr %r2, %r3167; CHECK: agsi 4(%r2), 1168; CHECK: ipm [[REG:%r[0-5]]]169; CHECK: afi [[REG]], 1342177280170; CHECK: risbg %r2, [[REG]], 63, 191, 33171; CHECK: br %r14172 %add1 = add i64 %base, %index173 %add2 = add i64 %add1, 4174 %ptr = inttoptr i64 %add2 to ptr175 %a = load i64, ptr %ptr176 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)177 %val = extractvalue {i64, i1} %t, 0178 %obit = extractvalue {i64, i1} %t, 1179 store i64 %val, ptr %ptr180 ret i1 %obit181}182 183; Check that adding 127 to a spilled value can use AGSI.184define zeroext i1 @f11(ptr %ptr, i64 %sel) {185; CHECK-LABEL: f11:186; CHECK: agsi {{[0-9]+}}(%r15), 127187; CHECK: br %r14188entry:189 %val0 = load volatile i64, ptr %ptr190 %val1 = load volatile i64, ptr %ptr191 %val2 = load volatile i64, ptr %ptr192 %val3 = load volatile i64, ptr %ptr193 %val4 = load volatile i64, ptr %ptr194 %val5 = load volatile i64, ptr %ptr195 %val6 = load volatile i64, ptr %ptr196 %val7 = load volatile i64, ptr %ptr197 %val8 = load volatile i64, ptr %ptr198 %val9 = load volatile i64, ptr %ptr199 %val10 = load volatile i64, ptr %ptr200 %val11 = load volatile i64, ptr %ptr201 %val12 = load volatile i64, ptr %ptr202 %val13 = load volatile i64, ptr %ptr203 %val14 = load volatile i64, ptr %ptr204 %val15 = load volatile i64, ptr %ptr205 206 %test = icmp ne i64 %sel, 0207 br i1 %test, label %add, label %store208 209add:210 %t0 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val0, i64 127)211 %add0 = extractvalue {i64, i1} %t0, 0212 %obit0 = extractvalue {i64, i1} %t0, 1213 %t1 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val1, i64 127)214 %add1 = extractvalue {i64, i1} %t1, 0215 %obit1 = extractvalue {i64, i1} %t1, 1216 %res1 = or i1 %obit0, %obit1217 %t2 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val2, i64 127)218 %add2 = extractvalue {i64, i1} %t2, 0219 %obit2 = extractvalue {i64, i1} %t2, 1220 %res2 = or i1 %res1, %obit2221 %t3 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val3, i64 127)222 %add3 = extractvalue {i64, i1} %t3, 0223 %obit3 = extractvalue {i64, i1} %t3, 1224 %res3 = or i1 %res2, %obit3225 %t4 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val4, i64 127)226 %add4 = extractvalue {i64, i1} %t4, 0227 %obit4 = extractvalue {i64, i1} %t4, 1228 %res4 = or i1 %res3, %obit4229 %t5 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val5, i64 127)230 %add5 = extractvalue {i64, i1} %t5, 0231 %obit5 = extractvalue {i64, i1} %t5, 1232 %res5 = or i1 %res4, %obit5233 %t6 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val6, i64 127)234 %add6 = extractvalue {i64, i1} %t6, 0235 %obit6 = extractvalue {i64, i1} %t6, 1236 %res6 = or i1 %res5, %obit6237 %t7 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val7, i64 127)238 %add7 = extractvalue {i64, i1} %t7, 0239 %obit7 = extractvalue {i64, i1} %t7, 1240 %res7 = or i1 %res6, %obit7241 %t8 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val8, i64 127)242 %add8 = extractvalue {i64, i1} %t8, 0243 %obit8 = extractvalue {i64, i1} %t8, 1244 %res8 = or i1 %res7, %obit8245 %t9 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val9, i64 127)246 %add9 = extractvalue {i64, i1} %t9, 0247 %obit9 = extractvalue {i64, i1} %t9, 1248 %res9 = or i1 %res8, %obit9249 %t10 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val10, i64 127)250 %add10 = extractvalue {i64, i1} %t10, 0251 %obit10 = extractvalue {i64, i1} %t10, 1252 %res10 = or i1 %res9, %obit10253 %t11 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val11, i64 127)254 %add11 = extractvalue {i64, i1} %t11, 0255 %obit11 = extractvalue {i64, i1} %t11, 1256 %res11 = or i1 %res10, %obit11257 %t12 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val12, i64 127)258 %add12 = extractvalue {i64, i1} %t12, 0259 %obit12 = extractvalue {i64, i1} %t12, 1260 %res12 = or i1 %res11, %obit12261 %t13 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val13, i64 127)262 %add13 = extractvalue {i64, i1} %t13, 0263 %obit13 = extractvalue {i64, i1} %t13, 1264 %res13 = or i1 %res12, %obit13265 %t14 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val14, i64 127)266 %add14 = extractvalue {i64, i1} %t14, 0267 %obit14 = extractvalue {i64, i1} %t14, 1268 %res14 = or i1 %res13, %obit14269 %t15 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val15, i64 127)270 %add15 = extractvalue {i64, i1} %t15, 0271 %obit15 = extractvalue {i64, i1} %t15, 1272 %res15 = or i1 %res14, %obit15273 274 br label %store275 276store:277 %new0 = phi i64 [ %val0, %entry ], [ %add0, %add ]278 %new1 = phi i64 [ %val1, %entry ], [ %add1, %add ]279 %new2 = phi i64 [ %val2, %entry ], [ %add2, %add ]280 %new3 = phi i64 [ %val3, %entry ], [ %add3, %add ]281 %new4 = phi i64 [ %val4, %entry ], [ %add4, %add ]282 %new5 = phi i64 [ %val5, %entry ], [ %add5, %add ]283 %new6 = phi i64 [ %val6, %entry ], [ %add6, %add ]284 %new7 = phi i64 [ %val7, %entry ], [ %add7, %add ]285 %new8 = phi i64 [ %val8, %entry ], [ %add8, %add ]286 %new9 = phi i64 [ %val9, %entry ], [ %add9, %add ]287 %new10 = phi i64 [ %val10, %entry ], [ %add10, %add ]288 %new11 = phi i64 [ %val11, %entry ], [ %add11, %add ]289 %new12 = phi i64 [ %val12, %entry ], [ %add12, %add ]290 %new13 = phi i64 [ %val13, %entry ], [ %add13, %add ]291 %new14 = phi i64 [ %val14, %entry ], [ %add14, %add ]292 %new15 = phi i64 [ %val15, %entry ], [ %add15, %add ]293 %res = phi i1 [ 0, %entry ], [ %res15, %add ]294 295 store volatile i64 %new0, ptr %ptr296 store volatile i64 %new1, ptr %ptr297 store volatile i64 %new2, ptr %ptr298 store volatile i64 %new3, ptr %ptr299 store volatile i64 %new4, ptr %ptr300 store volatile i64 %new5, ptr %ptr301 store volatile i64 %new6, ptr %ptr302 store volatile i64 %new7, ptr %ptr303 store volatile i64 %new8, ptr %ptr304 store volatile i64 %new9, ptr %ptr305 store volatile i64 %new10, ptr %ptr306 store volatile i64 %new11, ptr %ptr307 store volatile i64 %new12, ptr %ptr308 store volatile i64 %new13, ptr %ptr309 store volatile i64 %new14, ptr %ptr310 store volatile i64 %new15, ptr %ptr311 312 ret i1 %res313}314 315; Check that adding -128 to a spilled value can use AGSI.316define zeroext i1 @f12(ptr %ptr, i64 %sel) {317; CHECK-LABEL: f12:318; CHECK: agsi {{[0-9]+}}(%r15), -128319; CHECK: br %r14320entry:321 %val0 = load volatile i64, ptr %ptr322 %val1 = load volatile i64, ptr %ptr323 %val2 = load volatile i64, ptr %ptr324 %val3 = load volatile i64, ptr %ptr325 %val4 = load volatile i64, ptr %ptr326 %val5 = load volatile i64, ptr %ptr327 %val6 = load volatile i64, ptr %ptr328 %val7 = load volatile i64, ptr %ptr329 %val8 = load volatile i64, ptr %ptr330 %val9 = load volatile i64, ptr %ptr331 %val10 = load volatile i64, ptr %ptr332 %val11 = load volatile i64, ptr %ptr333 %val12 = load volatile i64, ptr %ptr334 %val13 = load volatile i64, ptr %ptr335 %val14 = load volatile i64, ptr %ptr336 %val15 = load volatile i64, ptr %ptr337 338 %test = icmp ne i64 %sel, 0339 br i1 %test, label %add, label %store340 341add:342 %t0 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val0, i64 -128)343 %add0 = extractvalue {i64, i1} %t0, 0344 %obit0 = extractvalue {i64, i1} %t0, 1345 %t1 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val1, i64 -128)346 %add1 = extractvalue {i64, i1} %t1, 0347 %obit1 = extractvalue {i64, i1} %t1, 1348 %res1 = or i1 %obit0, %obit1349 %t2 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val2, i64 -128)350 %add2 = extractvalue {i64, i1} %t2, 0351 %obit2 = extractvalue {i64, i1} %t2, 1352 %res2 = or i1 %res1, %obit2353 %t3 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val3, i64 -128)354 %add3 = extractvalue {i64, i1} %t3, 0355 %obit3 = extractvalue {i64, i1} %t3, 1356 %res3 = or i1 %res2, %obit3357 %t4 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val4, i64 -128)358 %add4 = extractvalue {i64, i1} %t4, 0359 %obit4 = extractvalue {i64, i1} %t4, 1360 %res4 = or i1 %res3, %obit4361 %t5 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val5, i64 -128)362 %add5 = extractvalue {i64, i1} %t5, 0363 %obit5 = extractvalue {i64, i1} %t5, 1364 %res5 = or i1 %res4, %obit5365 %t6 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val6, i64 -128)366 %add6 = extractvalue {i64, i1} %t6, 0367 %obit6 = extractvalue {i64, i1} %t6, 1368 %res6 = or i1 %res5, %obit6369 %t7 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val7, i64 -128)370 %add7 = extractvalue {i64, i1} %t7, 0371 %obit7 = extractvalue {i64, i1} %t7, 1372 %res7 = or i1 %res6, %obit7373 %t8 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val8, i64 -128)374 %add8 = extractvalue {i64, i1} %t8, 0375 %obit8 = extractvalue {i64, i1} %t8, 1376 %res8 = or i1 %res7, %obit8377 %t9 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val9, i64 -128)378 %add9 = extractvalue {i64, i1} %t9, 0379 %obit9 = extractvalue {i64, i1} %t9, 1380 %res9 = or i1 %res8, %obit9381 %t10 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val10, i64 -128)382 %add10 = extractvalue {i64, i1} %t10, 0383 %obit10 = extractvalue {i64, i1} %t10, 1384 %res10 = or i1 %res9, %obit10385 %t11 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val11, i64 -128)386 %add11 = extractvalue {i64, i1} %t11, 0387 %obit11 = extractvalue {i64, i1} %t11, 1388 %res11 = or i1 %res10, %obit11389 %t12 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val12, i64 -128)390 %add12 = extractvalue {i64, i1} %t12, 0391 %obit12 = extractvalue {i64, i1} %t12, 1392 %res12 = or i1 %res11, %obit12393 %t13 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val13, i64 -128)394 %add13 = extractvalue {i64, i1} %t13, 0395 %obit13 = extractvalue {i64, i1} %t13, 1396 %res13 = or i1 %res12, %obit13397 %t14 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val14, i64 -128)398 %add14 = extractvalue {i64, i1} %t14, 0399 %obit14 = extractvalue {i64, i1} %t14, 1400 %res14 = or i1 %res13, %obit14401 %t15 = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %val15, i64 -128)402 %add15 = extractvalue {i64, i1} %t15, 0403 %obit15 = extractvalue {i64, i1} %t15, 1404 %res15 = or i1 %res14, %obit15405 406 br label %store407 408store:409 %new0 = phi i64 [ %val0, %entry ], [ %add0, %add ]410 %new1 = phi i64 [ %val1, %entry ], [ %add1, %add ]411 %new2 = phi i64 [ %val2, %entry ], [ %add2, %add ]412 %new3 = phi i64 [ %val3, %entry ], [ %add3, %add ]413 %new4 = phi i64 [ %val4, %entry ], [ %add4, %add ]414 %new5 = phi i64 [ %val5, %entry ], [ %add5, %add ]415 %new6 = phi i64 [ %val6, %entry ], [ %add6, %add ]416 %new7 = phi i64 [ %val7, %entry ], [ %add7, %add ]417 %new8 = phi i64 [ %val8, %entry ], [ %add8, %add ]418 %new9 = phi i64 [ %val9, %entry ], [ %add9, %add ]419 %new10 = phi i64 [ %val10, %entry ], [ %add10, %add ]420 %new11 = phi i64 [ %val11, %entry ], [ %add11, %add ]421 %new12 = phi i64 [ %val12, %entry ], [ %add12, %add ]422 %new13 = phi i64 [ %val13, %entry ], [ %add13, %add ]423 %new14 = phi i64 [ %val14, %entry ], [ %add14, %add ]424 %new15 = phi i64 [ %val15, %entry ], [ %add15, %add ]425 %res = phi i1 [ 0, %entry ], [ %res15, %add ]426 427 store volatile i64 %new0, ptr %ptr428 store volatile i64 %new1, ptr %ptr429 store volatile i64 %new2, ptr %ptr430 store volatile i64 %new3, ptr %ptr431 store volatile i64 %new4, ptr %ptr432 store volatile i64 %new5, ptr %ptr433 store volatile i64 %new6, ptr %ptr434 store volatile i64 %new7, ptr %ptr435 store volatile i64 %new8, ptr %ptr436 store volatile i64 %new9, ptr %ptr437 store volatile i64 %new10, ptr %ptr438 store volatile i64 %new11, ptr %ptr439 store volatile i64 %new12, ptr %ptr440 store volatile i64 %new13, ptr %ptr441 store volatile i64 %new14, ptr %ptr442 store volatile i64 %new15, ptr %ptr443 444 ret i1 %res445}446 447; Check using the overflow result for a branch.448define void @f13(ptr %ptr) {449; CHECK-LABEL: f13:450; CHECK: agsi 0(%r2), 1451; CHECK: jgo foo@PLT452; CHECK: br %r14453 %a = load i64, ptr %ptr454 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)455 %val = extractvalue {i64, i1} %t, 0456 %obit = extractvalue {i64, i1} %t, 1457 store i64 %val, ptr %ptr458 br i1 %obit, label %call, label %exit459 460call:461 tail call i64 @foo()462 br label %exit463 464exit:465 ret void466}467 468; ... and the same with the inverted direction.469define void @f14(ptr %ptr) {470; CHECK-LABEL: f14:471; CHECK: agsi 0(%r2), 1472; CHECK: jgno foo@PLT473; CHECK: br %r14474 %a = load i64, ptr %ptr475 %t = call {i64, i1} @llvm.sadd.with.overflow.i64(i64 %a, i64 1)476 %val = extractvalue {i64, i1} %t, 0477 %obit = extractvalue {i64, i1} %t, 1478 store i64 %val, ptr %ptr479 br i1 %obit, label %exit, label %call480 481call:482 tail call i64 @foo()483 br label %exit484 485exit:486 ret void487}488 489declare {i64, i1} @llvm.sadd.with.overflow.i64(i64, i64) nounwind readnone490 491