1 /* $NetBSD: msg_193.c,v 1.22 2024/11/13 04:32:49 rillig Exp $ */ 2 # 3 "msg_193.c" 3 4 // Test for message: '%s' statement not reached [193] 5 6 /* lint1-extra-flags: -X 351 */ 7 8 /* 9 * Test the reachability of statements in a function. 10 * 11 * if 12 * if-else 13 * if-else-if-else 14 * for 15 * while 16 * do-while 17 * switch 18 * break 19 * continue 20 * goto 21 * return 22 * 23 * constant expression 24 * system-dependent constant expression 25 */ 26 27 extern void reachable(void); 28 extern void unreachable(void); 29 extern _Bool maybe(void); 30 31 32 void 33 test_statement(void) 34 { 35 reachable(); 36 reachable(); 37 } 38 39 void 40 test_compound_statement(void) 41 { 42 reachable(); 43 { 44 reachable(); 45 reachable(); 46 } 47 reachable(); 48 } 49 50 void 51 test_if_statement(void) 52 { 53 if (1) 54 reachable(); 55 reachable(); 56 if (0) 57 unreachable(); /* expect+0: ... [193] */ 58 reachable(); 59 } 60 61 void 62 test_if_compound_statement(void) 63 { 64 if (1) { 65 reachable(); 66 } 67 if (1) { 68 { 69 { 70 reachable(); 71 } 72 } 73 } 74 75 if (0) { 76 unreachable(); /* expect+0: ... [193] */ 77 } 78 if (0) { 79 { 80 { 81 unreachable(); /* expect+0: ... [193] */ 82 } 83 } 84 } 85 } 86 87 void 88 test_if_without_else(void) 89 { 90 if (1) 91 reachable(); 92 reachable(); 93 94 if (0) 95 unreachable(); /* expect+0: ... [193] */ 96 reachable(); 97 } 98 99 void 100 test_if_with_else(void) 101 { 102 if (1) 103 reachable(); 104 else 105 unreachable(); /* expect+0: ... [193] */ 106 reachable(); 107 108 if (0) 109 unreachable(); /* expect+0: ... [193] */ 110 else 111 reachable(); 112 reachable(); 113 } 114 115 void 116 test_if_else_if_else(void) 117 { 118 if (1) 119 reachable(); 120 else if (1) /* expect+0: ... [193] */ 121 unreachable(); 122 else 123 unreachable(); /* expect+0: ... [193] */ 124 125 if (0) 126 unreachable(); /* expect+0: ... [193] */ 127 else if (1) 128 reachable(); 129 else 130 unreachable(); /* expect+0: ... [193] */ 131 132 if (0) 133 unreachable(); /* expect+0: ... [193] */ 134 else if (0) 135 unreachable(); /* expect+0: ... [193] */ 136 else 137 reachable(); 138 } 139 140 void 141 test_if_return(void) 142 { 143 if (1) 144 return; 145 unreachable(); /* expect+0: ... [193] */ 146 } 147 148 void 149 test_if_else_return(void) 150 { 151 if (1) 152 reachable(); 153 else 154 return; /* expect+0: ... [193] */ 155 reachable(); 156 } 157 158 void 159 test_for_forever(void) 160 { 161 for (;;) 162 reachable(); 163 unreachable(); /* expect+0: ... [193] */ 164 } 165 166 void 167 test_for_true(void) 168 { 169 for (; 1;) 170 reachable(); 171 unreachable(); /* expect+0: ... [193] */ 172 } 173 174 void 175 test_for_false(void) 176 { 177 for (; 0;) 178 unreachable(); /* expect+0: ... [193] */ 179 reachable(); 180 } 181 182 void 183 test_for_break(void) 184 { 185 for (;;) { 186 reachable(); 187 break; 188 unreachable(); /* expect+0: ... [193] */ 189 } 190 reachable(); 191 } 192 193 void 194 test_for_if_break(void) 195 { 196 for (;;) { 197 reachable(); 198 if (0) { 199 unreachable(); /* expect+0: ... [193] */ 200 break; 201 unreachable(); /* expect+0: ... [193] */ 202 } 203 if (1) { 204 reachable(); 205 break; 206 unreachable(); /* expect+0: ... [193] */ 207 } 208 unreachable(); /* expect+0: ... [193] */ 209 } 210 reachable(); 211 } 212 213 void 214 test_for_continue(void) 215 { 216 for (;;) { 217 reachable(); 218 continue; 219 unreachable(); /* expect+0: ... [193] */ 220 } 221 unreachable(); /* expect+0: ... [193] */ 222 } 223 224 void 225 test_for_if_continue(void) 226 { 227 for (;;) { 228 reachable(); 229 if (0) { 230 unreachable(); /* expect+0: ... [193] */ 231 continue; 232 unreachable(); /* expect+0: ... [193] */ 233 } 234 if (1) { 235 reachable(); 236 continue; 237 unreachable(); /* expect+0: ... [193] */ 238 } 239 unreachable(); /* expect+0: ... [193] */ 240 } 241 unreachable(); /* expect+0: ... [193] */ 242 } 243 244 void 245 test_for_return(void) 246 { 247 for (;;) { 248 reachable(); 249 return; 250 unreachable(); /* expect+0: ... [193] */ 251 } 252 unreachable(); /* expect+0: ... [193] */ 253 } 254 255 void 256 test_for_if_return(void) 257 { 258 for (;;) { 259 reachable(); 260 if (0) { 261 unreachable(); /* expect+0: ... [193] */ 262 return; 263 unreachable(); /* expect+0: ... [193] */ 264 } 265 if (1) { 266 reachable(); 267 return; 268 unreachable(); /* expect+0: ... [193] */ 269 } 270 unreachable(); /* expect+0: ... [193] */ 271 } 272 unreachable(); /* expect+0: ... [193] */ 273 } 274 275 void 276 test_while_true(void) 277 { 278 while (1) 279 reachable(); 280 unreachable(); /* expect+0: ... [193] */ 281 } 282 283 void 284 test_while_false(void) 285 { 286 while (0) 287 unreachable(); /* expect+0: ... [193] */ 288 reachable(); 289 } 290 291 void 292 test_while_break(void) 293 { 294 while (1) { 295 reachable(); 296 break; 297 unreachable(); /* expect+0: ... [193] */ 298 } 299 reachable(); 300 } 301 302 void 303 test_while_if_break(void) 304 { 305 while (1) { 306 reachable(); 307 if (0) { 308 unreachable(); /* expect+0: ... [193] */ 309 break; 310 unreachable(); /* expect+0: ... [193] */ 311 } 312 if (1) { 313 reachable(); 314 break; 315 unreachable(); /* expect+0: ... [193] */ 316 } 317 unreachable(); /* expect+0: ... [193] */ 318 } 319 reachable(); 320 } 321 322 void 323 test_while_continue(void) 324 { 325 while (1) { 326 reachable(); 327 continue; 328 unreachable(); /* expect+0: ... [193] */ 329 } 330 unreachable(); /* expect+0: ... [193] */ 331 } 332 333 void 334 test_while_if_continue(void) 335 { 336 while (1) { 337 reachable(); 338 if (0) { 339 unreachable(); /* expect+0: ... [193] */ 340 continue; 341 unreachable(); /* expect+0: ... [193] */ 342 } 343 if (1) { 344 reachable(); 345 continue; 346 unreachable(); /* expect+0: ... [193] */ 347 } 348 unreachable(); /* expect+0: ... [193] */ 349 } 350 unreachable(); /* expect+0: ... [193] */ 351 } 352 353 void 354 test_while_return(void) 355 { 356 while (1) { 357 reachable(); 358 return; 359 unreachable(); /* expect+0: ... [193] */ 360 } 361 unreachable(); /* expect+0: ... [193] */ 362 } 363 364 void 365 test_while_if_return(void) 366 { 367 while (1) { 368 reachable(); 369 if (0) { 370 unreachable(); /* expect+0: ... [193] */ 371 return; 372 unreachable(); /* expect+0: ... [193] */ 373 } 374 if (1) { 375 reachable(); 376 return; 377 unreachable(); /* expect+0: ... [193] */ 378 } 379 unreachable(); /* expect+0: ... [193] */ 380 } 381 unreachable(); /* expect+0: ... [193] */ 382 } 383 384 void 385 test_do_while_true(void) 386 { 387 do { 388 reachable(); 389 } while (1); 390 unreachable(); /* expect+0: ... [193] */ 391 } 392 393 void 394 test_do_while_false(void) 395 { 396 do { 397 reachable(); 398 } while (0); 399 reachable(); 400 } 401 402 void 403 test_do_while_break(void) 404 { 405 do { 406 reachable(); 407 break; 408 unreachable(); /* expect+0: ... [193] */ 409 } while (1); 410 reachable(); 411 } 412 413 void 414 test_do_while_if_break(void) 415 { 416 do { 417 reachable(); 418 if (0) { 419 unreachable(); /* expect+0: ... [193] */ 420 break; 421 unreachable(); /* expect+0: ... [193] */ 422 } 423 if (1) { 424 reachable(); 425 break; 426 unreachable(); /* expect+0: ... [193] */ 427 } 428 unreachable(); /* expect+0: ... [193] */ 429 } while (1); 430 reachable(); 431 } 432 433 void 434 test_do_while_continue(void) 435 { 436 do { 437 reachable(); 438 continue; 439 unreachable(); /* expect+0: ... [193] */ 440 } while (1); 441 unreachable(); /* expect+0: ... [193] */ 442 } 443 444 void 445 test_do_while_if_continue(void) 446 { 447 do { 448 reachable(); 449 if (0) { 450 unreachable(); /* expect+0: ... [193] */ 451 continue; 452 unreachable(); /* expect+0: ... [193] */ 453 } 454 if (1) { 455 reachable(); 456 continue; 457 unreachable(); /* expect+0: ... [193] */ 458 } 459 unreachable(); /* expect+0: ... [193] */ 460 } while (1); 461 unreachable(); /* expect+0: ... [193] */ 462 } 463 464 void 465 test_do_while_return(void) 466 { 467 do { 468 reachable(); 469 return; 470 unreachable(); /* expect+0: ... [193] */ 471 } while (1); 472 unreachable(); /* expect+0: ... [193] */ 473 } 474 475 void 476 test_do_while_if_return(void) 477 { 478 do { 479 reachable(); 480 if (0) { 481 unreachable(); /* expect+0: ... [193] */ 482 return; 483 unreachable(); /* expect+0: ... [193] */ 484 } 485 if (1) { 486 reachable(); 487 return; 488 unreachable(); /* expect+0: ... [193] */ 489 } 490 unreachable(); /* expect+0: ... [193] */ 491 } while (1); 492 unreachable(); /* expect+0: ... [193] */ 493 } 494 495 void 496 test_if_nested(void) 497 { 498 if (0) { 499 if (1) /* expect+0: ... [193] */ 500 unreachable(); 501 else 502 unreachable(); /* expect+0: ... [193] *//* XXX: redundant */ 503 504 if (0) 505 unreachable(); /* expect+0: ... [193] *//* XXX: redundant */ 506 else 507 unreachable(); 508 509 unreachable(); 510 } 511 reachable(); 512 513 if (1) { 514 if (1) 515 reachable(); 516 else 517 unreachable(); /* expect+0: ... [193] */ 518 519 if (0) 520 unreachable(); /* expect+0: ... [193] */ 521 else 522 reachable(); 523 524 reachable(); 525 } 526 reachable(); 527 } 528 529 void 530 test_if_maybe(void) 531 { 532 if (maybe()) { 533 if (0) 534 unreachable(); /* expect+0: ... [193] */ 535 else 536 reachable(); 537 reachable(); 538 } 539 reachable(); 540 541 if (0) { 542 if (maybe()) /* expect+0: ... [193] */ 543 unreachable(); 544 else 545 unreachable(); 546 unreachable(); 547 } 548 reachable(); 549 550 if (1) { 551 if (maybe()) 552 reachable(); 553 else 554 reachable(); 555 reachable(); 556 } 557 reachable(); 558 } 559 560 /* 561 * To compute the reachability graph of this little monster, lint would have 562 * to keep all statements and their relations from the whole function in 563 * memory. It doesn't do that. Therefore it does not warn about any 564 * unreachable statements in this function. 565 */ 566 void 567 test_goto_numbers_alphabetically(void) 568 { 569 goto one; 570 eight: 571 goto nine; 572 five: 573 return; 574 four: 575 goto five; 576 nine: 577 goto ten; 578 one: 579 goto two; 580 seven: 581 goto eight; 582 six: 583 /* expect-1: warning: label 'six' unused in function 'test_goto_numbers_alphabetically' [232] */ 584 goto seven; 585 ten: 586 return; 587 three: 588 goto four; 589 two: 590 goto three; 591 } 592 593 void 594 test_while_goto(void) 595 { 596 while (1) { 597 goto out; 598 break; /* lint only warns with the -b option */ 599 } 600 unreachable(); /* expect+0: ... [193] */ 601 out: 602 reachable(); 603 } 604 605 void 606 test_unreachable_label(void) 607 { 608 if (0) 609 goto unreachable; /* expect+0: ... [193] */ 610 goto reachable; 611 612 /* named_label assumes that any label is reachable. */ 613 unreachable: 614 unreachable(); 615 reachable: 616 reachable(); 617 } 618 619 /* TODO: switch */ 620 621 /* TODO: system-dependent constant expression (see tn_system_dependent) */ 622 623 void suppressed(void); 624 625 void 626 lint_annotation_NOTREACHED(void) 627 { 628 if (0) { 629 /* expect+1: warning: 'call' statement not reached [193] */ 630 unreachable(); 631 } 632 633 if (0) { 634 /* NOTREACHED */ 635 suppressed(); 636 } 637 638 if (0) 639 /* NOTREACHED */ 640 suppressed(); 641 642 if (1) { 643 reachable(); 644 } 645 646 if (1) { 647 /* NOTREACHED */ 648 suppressed(); 649 } 650 651 /* 652 * Since the condition in the 'if' statement is constant, lint knows 653 * that the branch is unconditionally taken. The annotation comment 654 * marks that branch as not reached, which means that any following 655 * statement cannot be reached as well. 656 */ 657 /* expect+1: warning: 'if' statement not reached [193] */ 658 if (1) 659 /* NOTREACHED */ 660 suppressed(); 661 } 662 663 /* 664 * Since at least 2002 and before cgram.y 1.379 from 2022-01-16, lint did not 665 * detect a double semicolon. See cgram.y, expression_statement, T_SEMI. 666 */ 667 int 668 test_null_statement(void) 669 { 670 /* 671 * The following 2 semicolons are superfluous but lint doesn't warn 672 * about them. Probably it should. A null statement as part of a 673 * block-list has no use. 674 */ 675 ;; 676 677 /* 678 * If assertions are disabled with -DNDEBUG and __lint__ is defined, 679 * NetBSD's <assert.h> defines assert(x) to nothing, leaving only 680 * the trailing semicolon. If there are several assertions next to 681 * each other, without any whitespace in between (very unusual), the 682 * GCC preprocessor generates ";;" for them, which makes them 683 * indistinguishable from the literal ";;" from the typo above. 684 * 685 * (echo '#include <assert.h>'; echo 'assert(0);assert(1);') \ 686 * | gcc -DNDEBUG -E - -D__lint__ 687 * 688 * To actually see the difference, lint would need to look at the 689 * code before preprocessing and compare it with the preprocessed 690 * code, which would be a lot of work. 691 * 692 * Apart from the above edge case, detecting extra semicolons would 693 * be possible, but lint would have to look at the whitespace between 694 * the tokens, and this is something that it doesn't do at all, as of 695 * 2022-01-16. 696 */ 697 698 /* 699 * A stand-alone null statement, on the other hand, has its purpose. 700 * Without it, the 'for' loop would not be complete. The NetBSD 701 * style is to use 'continue;' instead of a simple ';'. 702 */ 703 for (int i = 0; i < 10; i++) 704 ; 705 706 /* expect+1: warning: 'empty' statement not reached [193] */ 707 return 0;; 708 } 709 710 /* 711 * Before func.c 1.149 from 2023-02-21, lint crashed due to a null pointer 712 * dereference. 713 */ 714 void 715 invalid_case_expression(void) 716 { 717 switch (4) { 718 /* expect+1: error: operand of '~' has invalid type 'double' [108] */ 719 case ~0.0: 720 ; 721 } 722 } 723
Indexes created Sun Sep 21 19:09:51 GMT 2025