Debian Codegraph @

gcc/testsuite/gcc.misc-tests/gcov-29.c

raw
1 /* { dg-options "--coverage -fpath-coverage" } */
2 /* { dg-do run { target native } } */
3
4 void
5 pathcov001a ()
6 {
7 /* Empty functions should not be problematic. */
8 }
9
10 /* Straight line, which should have only one path. */
11 /* BEGIN paths
12 summary: 1/1
13 */
14 void
15 pathcov001b ()
16 /* END */
17 {
18 int a = 0;
19 ++a;
20 }
21
22 /* Same as b, but not executed. */
23 /* BEGIN paths
24 summary: 0/1
25 expect: 33
26 */
27 void
28 pathcov001c ()
29 /* END */
30 {
31 int a = 0;
32 ++a;
33 }
34
35 /* 002 is a simple baseline test, with no complicated control flow and no
36 loops, run with different combinations of inputs that tests the paths in
37 isolation. */
38 /* BEGIN paths
39 summary: 0/2
40 expect: 48(true) 49 52
41 expect: 48(false) 51 52
42 */
43 void
44 pathcov002a (int a)
45 /* END */
46 {
47 int v = 0;
48 if (a)
49 v++;
50 else
51 v--;
52 }
53
54 /* BEGIN paths
55 summary: 1/2
56 expect: 63(false) 66 67
57 */
58 void
59 pathcov002c (int a)
60 /* END */
61 {
62 int v = 0;
63 if (a)
64 v++;
65 else
66 v--;
67 }
68
69 /* BEGIN paths
70 summary: 1/2
71 expect: 78(true) 79 82
72 */
73 void
74 pathcov002b (int a)
75 /* END */
76 {
77 int v = 0;
78 if (a)
79 v++;
80 else
81 v--;
82 }
83
84 /* Identical to 002*, but run for both inputs. This should achieve full
85 coverage.
86
87 BEGIN paths
88 summary: 2/2
89 */
90 void
91 pathcov002d (int a)
92 /* END */
93 {
94 int v = 0;
95 if (a)
96 v++;
97 else
98 v--;
99 }
100
101 /* Test individual control flow structures in isolation. */
102
103 /* BEGIN paths
104 summary: 0/2
105 expect: 112(true) 113 114
106 expect: 112(false) 114
107 */
108 void
109 pathcov003a (int a)
110 /* END */
111 {
112 if (a)
113 a++;
114 }
115
116 /* BEGIN paths
117 summary: 0/2
118 expect: 125(true) 126 129
119 expect: 125(false) 128 129
120 */
121 void
122 pathcov003b (int a)
123 /* END */
124 {
125 if (a)
126 a++;
127 else
128 a--;
129 }
130
131 /* BEGIN paths
132 summary: 0/3
133 expect: 141(true) 142 147
134 expect: 141(false) 143(true) 144 147
135 expect: 141(false) 143(false) 146 147
136 */
137 void
138 pathcov003c (int a)
139 /* END */
140 {
141 if (a > 10)
142 a++;
143 else if (a > 20)
144 a--;
145 else
146 a += 2;
147 }
148
149 /* BEGIN paths
150 summary: 0/5
151 expect: 162 162(true) 163
152 expect: 162 162(false) 164
153 expect: 163 162(true) 163
154 expect: 163 162(false) 164
155 expect: 162(true) 163 162
156 */
157 void
158 pathcov003d (int a)
159 /* END */
160 {
161 int x = 0;
162 for (int i = 0; i < a; ++i)
163 ++x;
164 }
165
166 /* BEGIN paths
167 summary: 0/5
168 expect: 180 180(true) 181
169 expect: 180 180(false) 182
170 expect: 181 180(true) 181
171 expect: 181 180(false) 182
172 expect: 180(true) 181 180
173 */
174 void
175 pathcov003e (int a)
176 /* END */
177 {
178 int x = 0;
179 int i = 0;
180 while (i++ < a)
181 x++;
182 }
183
184 /* BEGIN paths
185 summary: 0/2
186 expect: 194 197(false) 198
187 expect: 197(true) 197
188 */
189 void
190 pathcov003f (int a)
191 /* END */
192 {
193 int x = 0;
194 int i = 0;
195 do {
196 x++;
197 } while (i++ < a);
198 }
199
200 /* BEGIN paths
201 summary: 0/5
202 expect: 213 216(true) 220
203 expect: 213 216(false) 222
204 expect: 216(true) 220 216
205 expect: 220 216(true) 220
206 expect: 220 216(false) 222
207 */
208 void
209 pathcov003g (int a)
210 /* END */
211 {
212 int i = 0;
213 int x = 0;
214
215 top:
216 if (i < a)
217 {
218 x++;
219 i++;
220 goto top;
221 }
222 }
223
224 /* This example has a good mix of control flow structures which makes it nice
225 at identifying problems with the bookeeping/instrumentation. */
226
227 /* BEGIN paths
228 summary: 0/9
229 expect: 243(false) 247 247(true) 247(true) 249(true) 250 253
230 expect: 243(false) 247 247(true) 247(false) 253
231 expect: 243(false) 247 247(false) 253
232 expect: 243(true) 253
233 expect: 249(false) 247(true) 247(true) 249
234 expect: 249(false) 247(true) 247(false) 253
235 expect: 247(true) 247(true) 249(false) 247
236 expect: 247(true) 249(false) 247(true) 247
237 expect: 247(true) 249(false) 247(false) 253
238 */
239 void
240 pathcov004a (int a, int b, int c, int d)
241 /* END */
242 {
243 if (a)
244 {}
245 else
246 {
247 while (b-- > 0 && c-- > 0)
248 {
249 if (d)
250 break;
251 }
252 }
253 }
254
255 /* BEGIN paths
256 args: (1, 0, 0, 0)
257 summary: 1/9 */
258 void
259 pathcov004b (int a, int b, int c, int d)
260 /* END */
261 {
262 if (a)
263 {}
264 else
265 {
266 while (b-- > 0 && c-- > 0)
267 {
268 if (d)
269 break;
270 }
271 }
272 }
273
274 /* BEGIN paths
275 args: (0, 0, 0, 0)
276 summary: 1/9 */
277 void
278 pathcov004c (int a, int b, int c, int d)
279 /* END */
280 {
281 if (a)
282 {}
283 else
284 {
285 while (b-- > 0 && c-- > 0)
286 {
287 if (d)
288 break;
289 }
290 }
291 }
292
293 /* BEGIN paths
294 args: (0, 1, 0, 0)
295 summary: 1/9 */
296 void
297 pathcov004d (int a, int b, int c, int d)
298 /* END */
299 {
300 if (a)
301 {}
302 else
303 {
304 while (b-- > 0 && c-- > 0)
305 {
306 if (d)
307 break;
308 }
309 }
310 }
311
312 /* BEGIN paths
313 args: (0, 1, 1, 0)
314 summary: 2/9 */
315 void
316 pathcov004e (int a, int b, int c, int d)
317 /* END */
318 {
319 if (a)
320 {}
321 else
322 {
323 while (b-- > 0 && c-- > 0)
324 {
325 if (d)
326 break;
327 }
328 }
329 }
330
331 /* BEGIN paths
332 args: (0, 2, 1, 0)
333 summary: 3/9 */
334 void
335 pathcov004f (int a, int b, int c, int d)
336 /* END */
337 {
338 if (a)
339 {}
340 else
341 {
342 while (b-- > 0 && c-- > 0)
343 {
344 if (d)
345 break;
346 }
347 }
348 }
349
350 /* Funny loop exits. */
351
352 /* BEGIN paths
353 summary: 0/14
354 */
355 void
356 pathcov005a (int a, int b, int c)
357 /* END */
358 {
359 while (a)
360 {
361 if (b)
362 return;
363 while (c--)
364 a++;
365 }
366 }
367
368 void
369 pathcov005b (int a, int b, int c)
370 /* END */
371 {
372 if (a)
373 goto loop;
374
375 while (b > 0)
376 {
377 b--;
378 loop:
379 while (c--)
380 a++;
381 }
382 }
383
384 void
385 pathcov005c (int a, int b, int c)
386 /* END */
387 {
388 while (a-- > 0) c++;
389 while (b-- > 0) c++;
390 }
391
392 /* BEGIN paths
393 summary: 0/67
394
395 This is a sanity check and baseline and should not be executed.
396
397 With >64 cases we should have >64 paths which guarantees we cannot fit the
398 full bitset within a in a single gcov type. We want to only update the
399 relevant counters because extra instructions are expensive in compile time
400 and binary bloat, and verify that only taken paths are recorded. */
401 void
402 pathcov006a (int a)
403 /* END */
404 {
405 int x = 0;
406 switch (a)
407 {
408 case 0: x++; break;
409 case 1: x++; break;
410 case 2: x++; break;
411 case 3: x++; break;
412 case 4: x++; break;
413 case 5: x++; break;
414 case 6: x++; break;
415 case 7: x++; break;
416 case 8: x++; break;
417 case 9: x++; break;
418 case 10: x++; break;
419 case 11: x++; break;
420 case 12: x++; break;
421 case 13: x++; break;
422 case 14: x++; break;
423 case 15: x++; break;
424 case 16: x++; break;
425 case 17: x++; break;
426 case 18: x++; break;
427 case 19: x++; break;
428 case 20: x++; break;
429 case 21: x++; break;
430 case 22: x++; break;
431 case 23: x++; break;
432 case 24: x++; break;
433 case 25: x++; break;
434 case 26: x++; break;
435 case 27: x++; break;
436 case 28: x++; break;
437 case 29: x++; break;
438 case 30: x++; break;
439 case 31: x++; break;
440 case 32: x++; break;
441 case 33: x++; break;
442 case 34: x++; break;
443 case 35: x++; break;
444 case 36: x++; break;
445 case 37: x++; break;
446 case 38: x++; break;
447 case 39: x++; break;
448 case 40: x++; break;
449 case 41: x++; break;
450 case 42: x++; break;
451 case 43: x++; break;
452 case 44: x++; break;
453 case 45: x++; break;
454 case 46: x++; break;
455 case 47: x++; break;
456 case 48: x++; break;
457 case 49: x++; break;
458 case 50: x++; break;
459 case 51: x++; break;
460 case 52: x++; break;
461 case 53: x++; break;
462 case 54: x++; break;
463 case 55: x++; break;
464 case 56: x++; break;
465 case 57: x++; break;
466 case 58: x++; break;
467 case 59: x++; break;
468 case 60: x++; break;
469 case 61: x++; break;
470 case 62: x++; break;
471 case 63: x++; break;
472 case 64: x++; break;
473 case 65: x++; break;
474 }
475 }
476
477 /* BEGIN paths
478 args: (0)
479 summary: 1/67
480 */
481 void
482 pathcov006b (int a)
483 /* END */
484 {
485 int x = 0;
486 switch (a)
487 {
488 case 0: x++; break;
489 case 1: x++; break;
490 case 2: x++; break;
491 case 3: x++; break;
492 case 4: x++; break;
493 case 5: x++; break;
494 case 6: x++; break;
495 case 7: x++; break;
496 case 8: x++; break;
497 case 9: x++; break;
498 case 10: x++; break;
499 case 11: x++; break;
500 case 12: x++; break;
501 case 13: x++; break;
502 case 14: x++; break;
503 case 15: x++; break;
504 case 16: x++; break;
505 case 17: x++; break;
506 case 18: x++; break;
507 case 19: x++; break;
508 case 20: x++; break;
509 case 21: x++; break;
510 case 22: x++; break;
511 case 23: x++; break;
512 case 24: x++; break;
513 case 25: x++; break;
514 case 26: x++; break;
515 case 27: x++; break;
516 case 28: x++; break;
517 case 29: x++; break;
518 case 30: x++; break;
519 case 31: x++; break;
520 case 32: x++; break;
521 case 33: x++; break;
522 case 34: x++; break;
523 case 35: x++; break;
524 case 36: x++; break;
525 case 37: x++; break;
526 case 38: x++; break;
527 case 39: x++; break;
528 case 40: x++; break;
529 case 41: x++; break;
530 case 42: x++; break;
531 case 43: x++; break;
532 case 44: x++; break;
533 case 45: x++; break;
534 case 46: x++; break;
535 case 47: x++; break;
536 case 48: x++; break;
537 case 49: x++; break;
538 case 50: x++; break;
539 case 51: x++; break;
540 case 52: x++; break;
541 case 53: x++; break;
542 case 54: x++; break;
543 case 55: x++; break;
544 case 56: x++; break;
545 case 57: x++; break;
546 case 58: x++; break;
547 case 59: x++; break;
548 case 60: x++; break;
549 case 61: x++; break;
550 case 62: x++; break;
551 case 63: x++; break;
552 case 64: x++; break;
553 case 65: x++; break;
554 }
555 }
556
557 /* BEGIN paths
558 args: (64)
559 summary: 1/67 */
560 void
561 pathcov006c (int a)
562 /* END */
563 {
564 int x = 0;
565 switch (a)
566 {
567 case 0: x++; break;
568 case 1: x++; break;
569 case 2: x++; break;
570 case 3: x++; break;
571 case 4: x++; break;
572 case 5: x++; break;
573 case 6: x++; break;
574 case 7: x++; break;
575 case 8: x++; break;
576 case 9: x++; break;
577 case 10: x++; break;
578 case 11: x++; break;
579 case 12: x++; break;
580 case 13: x++; break;
581 case 14: x++; break;
582 case 15: x++; break;
583 case 16: x++; break;
584 case 17: x++; break;
585 case 18: x++; break;
586 case 19: x++; break;
587 case 20: x++; break;
588 case 21: x++; break;
589 case 22: x++; break;
590 case 23: x++; break;
591 case 24: x++; break;
592 case 25: x++; break;
593 case 26: x++; break;
594 case 27: x++; break;
595 case 28: x++; break;
596 case 29: x++; break;
597 case 30: x++; break;
598 case 31: x++; break;
599 case 32: x++; break;
600 case 33: x++; break;
601 case 34: x++; break;
602 case 35: x++; break;
603 case 36: x++; break;
604 case 37: x++; break;
605 case 38: x++; break;
606 case 39: x++; break;
607 case 40: x++; break;
608 case 41: x++; break;
609 case 42: x++; break;
610 case 43: x++; break;
611 case 44: x++; break;
612 case 45: x++; break;
613 case 46: x++; break;
614 case 47: x++; break;
615 case 48: x++; break;
616 case 49: x++; break;
617 case 50: x++; break;
618 case 51: x++; break;
619 case 52: x++; break;
620 case 53: x++; break;
621 case 54: x++; break;
622 case 55: x++; break;
623 case 56: x++; break;
624 case 57: x++; break;
625 case 58: x++; break;
626 case 59: x++; break;
627 case 60: x++; break;
628 case 61: x++; break;
629 case 62: x++; break;
630 case 63: x++; break;
631 case 64: x++; break;
632 case 65: x++; break;
633 }
634 }
635
636 /* BEGIN paths
637 args: (2, 65)
638 summary: 2/67
639
640 In this case we should record a path in both halves of the accumulator
641 bitsets. Note that the paths don't overlap with the single-half examples in
642 006b and 006c to reduce the chance of accidental passes. */
643 void
644 pathcov006d (int a)
645 /* END */
646 {
647 int x = 0;
648 switch (a)
649 {
650 case 0: x++; break;
651 case 1: x++; break;
652 case 2: x++; break;
653 case 3: x++; break;
654 case 4: x++; break;
655 case 5: x++; break;
656 case 6: x++; break;
657 case 7: x++; break;
658 case 8: x++; break;
659 case 9: x++; break;
660 case 10: x++; break;
661 case 11: x++; break;
662 case 12: x++; break;
663 case 13: x++; break;
664 case 14: x++; break;
665 case 15: x++; break;
666 case 16: x++; break;
667 case 17: x++; break;
668 case 18: x++; break;
669 case 19: x++; break;
670 case 20: x++; break;
671 case 21: x++; break;
672 case 22: x++; break;
673 case 23: x++; break;
674 case 24: x++; break;
675 case 25: x++; break;
676 case 26: x++; break;
677 case 27: x++; break;
678 case 28: x++; break;
679 case 29: x++; break;
680 case 30: x++; break;
681 case 31: x++; break;
682 case 32: x++; break;
683 case 33: x++; break;
684 case 34: x++; break;
685 case 35: x++; break;
686 case 36: x++; break;
687 case 37: x++; break;
688 case 38: x++; break;
689 case 39: x++; break;
690 case 40: x++; break;
691 case 41: x++; break;
692 case 42: x++; break;
693 case 43: x++; break;
694 case 44: x++; break;
695 case 45: x++; break;
696 case 46: x++; break;
697 case 47: x++; break;
698 case 48: x++; break;
699 case 49: x++; break;
700 case 50: x++; break;
701 case 51: x++; break;
702 case 52: x++; break;
703 case 53: x++; break;
704 case 54: x++; break;
705 case 55: x++; break;
706 case 56: x++; break;
707 case 57: x++; break;
708 case 58: x++; break;
709 case 59: x++; break;
710 case 60: x++; break;
711 case 61: x++; break;
712 case 62: x++; break;
713 case 63: x++; break;
714 case 64: x++; break;
715 case 65: x++; break;
716 }
717 }
718
719 /* BEGIN paths
720 args: (66)
721 summary: 1/67
722
723 This case should hit the empty default. */
724 void
725 pathcov006e (int a)
726 /* END */
727 {
728 int x = 0;
729 switch (a)
730 {
731 case 0: x++; break;
732 case 1: x++; break;
733 case 2: x++; break;
734 case 3: x++; break;
735 case 4: x++; break;
736 case 5: x++; break;
737 case 6: x++; break;
738 case 7: x++; break;
739 case 8: x++; break;
740 case 9: x++; break;
741 case 10: x++; break;
742 case 11: x++; break;
743 case 12: x++; break;
744 case 13: x++; break;
745 case 14: x++; break;
746 case 15: x++; break;
747 case 16: x++; break;
748 case 17: x++; break;
749 case 18: x++; break;
750 case 19: x++; break;
751 case 20: x++; break;
752 case 21: x++; break;
753 case 22: x++; break;
754 case 23: x++; break;
755 case 24: x++; break;
756 case 25: x++; break;
757 case 26: x++; break;
758 case 27: x++; break;
759 case 28: x++; break;
760 case 29: x++; break;
761 case 30: x++; break;
762 case 31: x++; break;
763 case 32: x++; break;
764 case 33: x++; break;
765 case 34: x++; break;
766 case 35: x++; break;
767 case 36: x++; break;
768 case 37: x++; break;
769 case 38: x++; break;
770 case 39: x++; break;
771 case 40: x++; break;
772 case 41: x++; break;
773 case 42: x++; break;
774 case 43: x++; break;
775 case 44: x++; break;
776 case 45: x++; break;
777 case 46: x++; break;
778 case 47: x++; break;
779 case 48: x++; break;
780 case 49: x++; break;
781 case 50: x++; break;
782 case 51: x++; break;
783 case 52: x++; break;
784 case 53: x++; break;
785 case 54: x++; break;
786 case 55: x++; break;
787 case 56: x++; break;
788 case 57: x++; break;
789 case 58: x++; break;
790 case 59: x++; break;
791 case 60: x++; break;
792 case 61: x++; break;
793 case 62: x++; break;
794 case 63: x++; break;
795 case 64: x++; break;
796 case 65: x++; break;
797 default:
798 }
799 }
800
801 void *alloc (int) { return 0; }
802 void *getcwd (void *, int) { return 0; }
803 void release (void *) {}
804
805 /* Based on gnu_getcwd from tree.c. This function crashed in early
806 development, and is mostly useful as a regression test.
807
808 BEGIN paths
809 summary: 0/8 */
810 void *gnu_getcwd()
811 /* END */
812 {
813 int size = 100;
814 void *buffer = alloc (size);
815
816 while (1) {
817 void *value = getcwd (buffer, size);
818 if (value != 0) return buffer;
819 size *= 2;
820 release (buffer);
821 buffer = (void *) alloc (size);
822 }
823 }
824
825 /* BEGIN paths
826 summary: 0/5 */
827 void pathcov007a (int a)
828 /* END */
829 {
830 goto mid;
831 while (1)
832 {
833 a--;
834 mid:
835 a--;
836 if (a < -5)
837 break;
838 a--;
839 }
840 }
841
842 int
843 main ()
844 {
845 pathcov001a ();
846 pathcov001b ();
847 /* not called: pathcov001c (); */
848
849 /* not called: pathcov002a (); */
850 pathcov002b (0);
851 pathcov002c (1);
852 pathcov002d (0);
853 pathcov002d (1);
854
855 pathcov004b (1, 0, 0, 0);
856 pathcov004c (0, 0, 0, 0);
857 pathcov004d (0, 1, 0, 0);
858 pathcov004e (0, 1, 1, 0);
859 pathcov004f (0, 2, 1, 0);
860
861 /* not called: pathcov006a (); */
862 pathcov006b (0);
863 pathcov006c (64);
864 pathcov006d (2);
865 pathcov006d (65);
866 pathcov006e (66);
867 }
868
869 /* { dg-final { run-gcov prime-paths { --prime-paths-lines gcov-29.c } } } */