contrib/gcc/gcov.c

24 /* ??? Print a list of the ten blocks with the highest execution counts,
25    and list the line numbers corresponding to those blocks.  Also, perhaps
29 /* ??? Should have an option to print the number of basic blocks, and the
74 /* Describes an arc between two basic blocks.  */
78   /* source and destination blocks.  */
113    predecessor blocks.  */
149     } line; /* Valid until blocks are linked onto lines */
152       /* Single line graph cycle workspace.  Used for all-blocks
156     } cycle; /* Used in all-blocks mode, after blocks are linked onto
160   /* Temporary chain for solving graph, and for chaining blocks on one
166 /* Describes a single function. Contains an array of basic blocks.  */
175   /* Array of basic blocks.  */
176   block_t *blocks;
212 /* Describes a single line of source. Contains a chain of basic blocks
220     arc_t *branches;	   /* branches from blocks that end on this
222 			      all-blocks mode.  */
223     block_t *blocks;       /* blocks which start on this line.  Used
224 			      in all-blocks mode.  */
397   fnotice (file, "  -a, --all-blocks                Show information for every basic block\n");
432   { "all-blocks",           no_argument,       NULL, 'a' },
593       for (ix = fn->num_blocks, block = fn->blocks; ix--; block++)
603       free (fn->blocks);
779 	  if (fn->blocks)
780 	    fnotice (stderr, "%s:already seen blocks for '%s'\n",
787 	      fn->blocks = XCNEWVEC (block_t, fn->num_blocks);
789 		fn->blocks[ix].flags = gcov_read_unsigned ();
797 	  if (src >= fn->num_blocks || fn->blocks[src].succ)
810 	      arc->dst = &fn->blocks[dest];
811 	      arc->src = &fn->blocks[src];
819 	      arc->succ_next = fn->blocks[src].succ;
820 	      fn->blocks[src].succ = arc;
821 	      fn->blocks[src].num_succ++;
823 	      arc->pred_next = fn->blocks[dest].pred;
824 	      fn->blocks[dest].pred = arc;
825 	      fn->blocks[dest].num_pred++;
833 		      fn->blocks[src].is_call_site = 1;
842 		      fn->blocks[dest].is_nonlocal_return = 1;
855 	  if (blockno >= fn->num_blocks || fn->blocks[blockno].u.line.encoding)
886 	  fn->blocks[blockno].u.line.encoding = line_nos;
887 	  fn->blocks[blockno].u.line.num = ix;
936 	    for (arc_p = NULL, arc = fn->blocks[ix].succ; arc;
942 	    fn->blocks[ix].succ = arc_p;
944 	    for (arc_p = NULL, arc = fn->blocks[ix].pred; arc;
950 	    fn->blocks[ix].pred = arc_p;
1067    to the blocks and the uninstrumented arcs.  */
1076   block_t *valid_blocks = NULL;    /* valid, but unpropagated blocks.  */
1077   block_t *invalid_blocks = NULL;  /* invalid, but inferable blocks.  */
1080     fnotice (stderr, "%s:'%s' lacks entry and/or exit blocks\n",
1084       if (fn->blocks[0].num_pred)
1090 	fn->blocks[0].num_pred = ~(unsigned)0;
1092       if (fn->blocks[fn->num_blocks - 1].num_succ)
1098 	fn->blocks[fn->num_blocks - 1].num_succ = ~(unsigned)0;
1103   for (ix = 0, blk = fn->blocks; ix != fn->num_blocks; ix++, blk++)
1299     if (!fn->blocks[ix].count_valid)
1494       block_t *block = &fn->blocks[ix];
1535 	  block->chain = block_line->u.blocks;
1536 	  block_line->u.blocks = block;
1590       else if (line->u.blocks)
1595 	     is to sum the entry counts to the graph of blocks on this
1602 	  for (block = line->u.blocks, block_p = NULL; block;
1609 	  line->u.blocks = block_p;
1612 	  for (block = line->u.blocks; block; block = block->chain)
1638 	     graphs, at worst we'll have O(N^2), as most blocks have
1645 	  for (block = line->u.blocks; block; block = block->chain)
1827 	  arc_t *arc = fn->blocks[fn->num_blocks - 1].pred;
1828 	  gcov_type return_count = fn->blocks[fn->num_blocks - 1].count;
1836 		   format_gcov (fn->blocks[0].count, 0, -1));
1838 		   format_gcov (return_count, fn->blocks[0].count, 0));
1839 	  fprintf (gcov_file, " blocks executed %s",
1875 	  for (ix = jx = 0, block = line->u.blocks; block;