1/* Calculate branch probabilities, and basic block execution counts.
2 Copyright (C) 1990, 91-94, 96-98, 1999 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
6
7This file is part of GNU CC.
8
9GNU CC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GNU CC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GNU CC; see the file COPYING. If not, write to
21the Free Software Foundation, 59 Temple Place - Suite 330,
22Boston, MA 02111-1307, USA. */
23
24/* ??? Really should not put insns inside of LIBCALL sequences, when putting
25 insns after a call, should look for the insn setting the retval, and
26 insert the insns after that one. */
27
28/* ??? Register allocation should use basic block execution counts to
29 give preference to the most commonly executed blocks. */
30
31/* ??? The .da files are not safe. Changing the program after creating .da
32 files or using different options when compiling with -fbranch-probabilities
33 can result the arc data not matching the program. Maybe add instrumented
34 arc count to .bbg file? Maybe check whether PFG matches the .bbg file? */
35
36/* ??? Should calculate branch probabilities before instrumenting code, since
37 then we can use arc counts to help decide which arcs to instrument. */
38
39/* ??? Rearrange code so that the most frequently executed arcs become from
40 one block to the next block (i.e. a fall through), move seldom executed
41 code outside of loops even at the expense of adding a few branches to
42 achieve this, see Dain Sample's UC Berkeley thesis. */
43
44#include "config.h"
45#include "system.h"
46#include "rtl.h"
47#include "flags.h"
48#include "insn-flags.h"
49#include "insn-config.h"
50#include "output.h"
51#include "regs.h"
52#include "tree.h"
53#include "output.h"
54#include "gcov-io.h"
55#include "toplev.h"
56
57/* One of these is dynamically created whenever we identify an arc in the
58 function. */
59
60struct adj_list
61{
62 int source;
63 int target;
64 int arc_count;
65 unsigned int count_valid : 1;
66 unsigned int on_tree : 1;
67 unsigned int fake : 1;
68 unsigned int fall_through : 1;
69 rtx branch_insn;
70 struct adj_list *pred_next;
71 struct adj_list *succ_next;
72};
73
74#define ARC_TARGET(ARCPTR) (ARCPTR->target)
75#define ARC_SOURCE(ARCPTR) (ARCPTR->source)
76#define ARC_COUNT(ARCPTR) (ARCPTR->arc_count)
77
78/* Count the number of basic blocks, and create an array of these structures,
79 one for each bb in the function. */
80
81struct bb_info
82{
83 struct adj_list *succ;
84 struct adj_list *pred;
85 int succ_count;
86 int pred_count;
87 int exec_count;
88 unsigned int count_valid : 1;
89 unsigned int on_tree : 1;
90 rtx first_insn;
91};
92
93/* Indexed by label number, gives the basic block number containing that
94 label. */
95
96static int *label_to_bb;
97
98/* Number of valid entries in the label_to_bb array. */
99
100static int label_to_bb_size;
101
102/* Indexed by block index, holds the basic block graph. */
103
104static struct bb_info *bb_graph;
105
106/* Name and file pointer of the output file for the basic block graph. */
107
108static char *bbg_file_name;
109static FILE *bbg_file;
110
111/* Name and file pointer of the input file for the arc count data. */
112
113static char *da_file_name;
114static FILE *da_file;
115
116/* Pointer of the output file for the basic block/line number map. */
117static FILE *bb_file;
118
119/* Last source file name written to bb_file. */
120
121static char *last_bb_file_name;
122
123/* Indicates whether the next line number note should be output to
124 bb_file or not. Used to eliminate a redundant note after an
125 expanded inline function call. */
126
127static int ignore_next_note;
128
129/* Used by final, for allocating the proper amount of storage for the
130 instrumented arc execution counts. */
131
132int count_instrumented_arcs;
133
134/* Number of executions for the return label. */
135
136int return_label_execution_count;
137
138/* Collect statistics on the performance of this pass for the entire source
139 file. */
140
141static int total_num_blocks;
142static int total_num_arcs;
143static int total_num_arcs_instrumented;
144static int total_num_blocks_created;
145static int total_num_passes;
146static int total_num_times_called;
147static int total_hist_br_prob[20];
148static int total_num_never_executed;
149static int total_num_branches;
150
151/* Forward declarations. */
152static void init_arc PROTO((struct adj_list *, int, int, rtx));
153static void find_spanning_tree PROTO((int));
154static void expand_spanning_tree PROTO((int));
155static void fill_spanning_tree PROTO((int));
156static void init_arc_profiler PROTO((void));
157static void output_arc_profiler PROTO((int, rtx));
158
159#ifndef LONG_TYPE_SIZE
160#define LONG_TYPE_SIZE BITS_PER_WORD
161#endif
162
163/* If non-zero, we need to output a constructor to set up the
164 per-object-file data. */
165static int need_func_profiler = 0;
166
167
168/* Add arc instrumentation code to the entire insn chain.
169
170 F is the first insn of the chain.
171 NUM_BLOCKS is the number of basic blocks found in F.
172 DUMP_FILE, if nonzero, is an rtl dump file we can write to. */
173
174static void
175instrument_arcs (f, num_blocks, dump_file)
176 rtx f;
177 int num_blocks;
178 FILE *dump_file;
179{
180 register int i;
181 register struct adj_list *arcptr, *backptr;
182 int num_arcs = 0;
183 int num_instr_arcs = 0;
184 rtx insn;
185
186 /* Instrument the program start. */
187 /* Handle block 0 specially, since it will always be instrumented,
188 but it doesn't have a valid first_insn or branch_insn. We must
189 put the instructions before the NOTE_INSN_FUNCTION_BEG note, so
190 that they don't clobber any of the parameters of the current
191 function. */
192 for (insn = f; insn; insn = NEXT_INSN (insn))
193 if (GET_CODE (insn) == NOTE
194 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
195 break;
196 insn = PREV_INSN (insn);
197 need_func_profiler = 1;
198 output_arc_profiler (total_num_arcs_instrumented + num_instr_arcs++, insn);
199
200 for (i = 1; i < num_blocks; i++)
201 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
202 if (! arcptr->on_tree)
203 {
204 if (dump_file)
205 fprintf (dump_file, "Arc %d to %d instrumented\n", i,
206 ARC_TARGET (arcptr));
207
208 /* Check to see if this arc is the only exit from its source block,
209 or the only entrance to its target block. In either case,
210 we don't need to create a new block to instrument the arc. */
211
212 if (bb_graph[i].succ == arcptr && arcptr->succ_next == 0)
213 {
214 /* Instrument the source block. */
215 output_arc_profiler (total_num_arcs_instrumented
216 + num_instr_arcs++,
217 PREV_INSN (bb_graph[i].first_insn));
218 }
219 else if (arcptr == bb_graph[ARC_TARGET (arcptr)].pred
220 && arcptr->pred_next == 0)
221 {
222 /* Instrument the target block. */
223 output_arc_profiler (total_num_arcs_instrumented
224 + num_instr_arcs++,
225 PREV_INSN (bb_graph[ARC_TARGET (arcptr)].first_insn));
226 }
227 else if (arcptr->fall_through)
228 {
229 /* This is a fall-through; put the instrumentation code after
230 the branch that ends this block. */
231
232 for (backptr = bb_graph[i].succ; backptr;
233 backptr = backptr->succ_next)
234 if (backptr != arcptr)
235 break;
236
237 output_arc_profiler (total_num_arcs_instrumented
238 + num_instr_arcs++,
239 backptr->branch_insn);
240 }
241 else
242 {
243 /* Must emit a new basic block to hold the arc counting code. */
244 enum rtx_code code = GET_CODE (PATTERN (arcptr->branch_insn));
245
246 if (code == SET)
247 {
248 /* Create the new basic block right after the branch.
249 Invert the branch so that it jumps past the end of the new
250 block. The new block will consist of the instrumentation
251 code, and a jump to the target of this arc. */
252 int this_is_simplejump = simplejump_p (arcptr->branch_insn);
253 rtx new_label = gen_label_rtx ();
254 rtx old_label, set_src;
255 rtx after = arcptr->branch_insn;
256
257 /* Simplejumps can't reach here. */
258 if (this_is_simplejump)
259 abort ();
260
261 /* We can't use JUMP_LABEL, because it won't be set if we
262 are compiling without optimization. */
263
264 set_src = SET_SRC (single_set (arcptr->branch_insn));
265 if (GET_CODE (set_src) == LABEL_REF)
266 old_label = set_src;
267 else if (GET_CODE (set_src) != IF_THEN_ELSE)
268 abort ();
269 else if (XEXP (set_src, 1) == pc_rtx)
270 old_label = XEXP (XEXP (set_src, 2), 0);
271 else
272 old_label = XEXP (XEXP (set_src, 1), 0);
273
274 /* Set the JUMP_LABEL so that redirect_jump will work. */
275 JUMP_LABEL (arcptr->branch_insn) = old_label;
276
277 /* Add a use for OLD_LABEL that will be needed when we emit
278 the JUMP_INSN below. If we don't do this here,
279 `invert_jump' might delete it for us. We must add two
280 when not optimizing, because the NUSES is zero now,
281 but must be at least two to prevent the label from being
282 deleted. */
283 LABEL_NUSES (old_label) += 2;
284
285 /* Emit the insns for the new block in reverse order,
286 since that is most convenient. */
287
288 if (this_is_simplejump)
289 {
290 after = NEXT_INSN (arcptr->branch_insn);
291 if (! redirect_jump (arcptr->branch_insn, new_label))
292 /* Don't know what to do if this branch won't
293 redirect. */
294 abort ();
295 }
296 else
297 {
298 if (! invert_jump (arcptr->branch_insn, new_label))
299 /* Don't know what to do if this branch won't invert. */
300 abort ();
301
302 emit_label_after (new_label, after);
303 LABEL_NUSES (new_label)++;
304 }
305 emit_barrier_after (after);
306 emit_jump_insn_after (gen_jump (old_label), after);
307 JUMP_LABEL (NEXT_INSN (after)) = old_label;
308
309 /* Instrument the source arc. */
310 output_arc_profiler (total_num_arcs_instrumented
311 + num_instr_arcs++,
312 after);
313 if (this_is_simplejump)
314 {
315 emit_label_after (new_label, after);
316 LABEL_NUSES (new_label)++;
317 }
318 }
319 else if (code == ADDR_VEC || code == ADDR_DIFF_VEC)
320 {
321 /* A table jump. Create a new basic block immediately
322 after the table, by emitting a barrier, a label, a
323 counting note, and a jump to the old label. Put the
324 new label in the table. */
325
326 rtx new_label = gen_label_rtx ();
327 rtx old_lref, new_lref;
328 int index;
329
330 /* Must determine the old_label reference, do this
331 by counting the arcs after this one, which will
332 give the index of our label in the table. */
333
334 index = 0;
335 for (backptr = arcptr->succ_next; backptr;
336 backptr = backptr->succ_next)
337 index++;
338
339 old_lref = XVECEXP (PATTERN (arcptr->branch_insn),
340 (code == ADDR_DIFF_VEC), index);
341
342 /* Emit the insns for the new block in reverse order,
343 since that is most convenient. */
344 emit_jump_insn_after (gen_jump (XEXP (old_lref, 0)),
345 arcptr->branch_insn);
346 JUMP_LABEL (NEXT_INSN (arcptr->branch_insn))
347 = XEXP (old_lref, 0);
348
349 /* Instrument the source arc. */
350 output_arc_profiler (total_num_arcs_instrumented
351 + num_instr_arcs++,
352 arcptr->branch_insn);
353
354 emit_label_after (new_label, arcptr->branch_insn);
355 LABEL_NUSES (NEXT_INSN (arcptr->branch_insn))++;
356 emit_barrier_after (arcptr->branch_insn);
357
358 /* Fix up the table jump. */
359 new_lref = gen_rtx_LABEL_REF (Pmode, new_label);
360 XVECEXP (PATTERN (arcptr->branch_insn),
361 (code == ADDR_DIFF_VEC), index) = new_lref;
362 }
363 else
364 abort ();
365
366 num_arcs += 1;
367 if (dump_file)
368 fprintf (dump_file,
369 "Arc %d to %d needed new basic block\n", i,
370 ARC_TARGET (arcptr));
371 }
372 }
373
374 total_num_arcs_instrumented += num_instr_arcs;
375 count_instrumented_arcs = total_num_arcs_instrumented;
376
377 total_num_blocks_created += num_arcs;
378 if (dump_file)
379 {
380 fprintf (dump_file, "%d arcs instrumented\n", num_instr_arcs);
381 fprintf (dump_file, "%d extra basic blocks created\n", num_arcs);
382 }
383}
384
385/* Output STRING to bb_file, surrounded by DELIMITER. */
386
387static void
388output_gcov_string (string, delimiter)
389 char *string;
390 long delimiter;
391{
392 long temp;
393
394 /* Write a delimiter to indicate that a file name follows. */
395 __write_long (delimiter, bb_file, 4);
396
397 /* Write the string. */
398 temp = strlen (string) + 1;
399 fwrite (string, temp, 1, bb_file);
400
401 /* Append a few zeros, to align the output to a 4 byte boundary. */
402 temp = temp & 0x3;
403 if (temp)
404 {
405 char c[4];
406
407 c[0] = c[1] = c[2] = c[3] = 0;
408 fwrite (c, sizeof (char), 4 - temp, bb_file);
409 }
410
411 /* Store another delimiter in the .bb file, just to make it easy to find the
412 end of the file name. */
413 __write_long (delimiter, bb_file, 4);
414}
415
416/* Return TRUE if this insn must be a tablejump entry insn. This works for
417 the MIPS port, but may give false negatives for some targets. */
418
419int
420tablejump_entry_p (insn, label)
421 rtx insn, label;
422{
423 rtx next = next_active_insn (insn);
424 enum rtx_code code = GET_CODE (PATTERN (next));
425
426 if (code != ADDR_DIFF_VEC && code != ADDR_VEC)
427 return 0;
428
429 if (PREV_INSN (next) == XEXP (label, 0))
430 return 1;
431
432 return 0;
433}
434
435/* Instrument and/or analyze program behavior based on program flow graph.
436 In either case, this function builds a flow graph for the function being
437 compiled. The flow graph is stored in BB_GRAPH.
438
439 When FLAG_PROFILE_ARCS is nonzero, this function instruments the arcs in
440 the flow graph that are needed to reconstruct the dynamic behavior of the
441 flow graph.
442
443 When FLAG_BRANCH_PROBABILITIES is nonzero, this function reads auxiliary
444 information from a data file containing arc count information from previous
445 executions of the function being compiled. In this case, the flow graph is
446 annotated with actual execution counts, which are later propagated into the
447 rtl for optimization purposes.
448
449 Main entry point of this file. */
450
451void
452branch_prob (f, dump_file)
453 rtx f;
454 FILE *dump_file;
455{
456 int i, num_blocks;
457 struct adj_list *arcptr;
458 int num_arcs, changes, passes;
459 int total, prob;
460 int hist_br_prob[20], num_never_executed, num_branches;
461 /* Set to non-zero if we got bad count information. */
462 int bad_counts = 0;
463
464 /* start of a function. */
465 if (flag_test_coverage)
466 output_gcov_string (current_function_name, (long) -2);
467
468 /* Execute this only if doing arc profiling or branch probabilities. */
469 if (! profile_arc_flag && ! flag_branch_probabilities
470 && ! flag_test_coverage)
471 abort ();
472
473 total_num_times_called++;
474
475 /* Create an array label_to_bb of ints of size max_label_num. */
476 label_to_bb_size = max_label_num ();
477 label_to_bb = (int *) oballoc (label_to_bb_size * sizeof (int));
478 bzero ((char *) label_to_bb, label_to_bb_size * sizeof (int));
479
480 /* Scan the insns in the function, count the number of basic blocks
481 present. When a code label is passed, set label_to_bb[label] = bb
482 number. */
483
484 /* The first block found will be block 1, so that function entry can be
485 block 0. */
486
487 {
488 register RTX_CODE prev_code = JUMP_INSN;
489 register RTX_CODE code;
490 register rtx insn;
491 register int i;
492 int block_separator_emitted = 0;
493
494 ignore_next_note = 0;
495
496 for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
497 {
498 code = GET_CODE (insn);
499
500 if (code == BARRIER)
501 ;
502 else if (code == CODE_LABEL)
503 /* This label is part of the next block, but we can't increment
504 block number yet since there might be multiple labels. */
505 label_to_bb[CODE_LABEL_NUMBER (insn)] = i + 1;
506 /* We make NOTE_INSN_SETJMP notes into a block of their own, so that
507 they can be the target of the fake arc for the setjmp call.
508 This avoids creating cycles of fake arcs, which would happen if
509 the block after the setjmp call contained a call insn. */
510 else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
511 || prev_code == CODE_LABEL || prev_code == BARRIER)
512 && (GET_RTX_CLASS (code) == 'i'
513 || (code == NOTE
514 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
515 {
516 i += 1;
517
518 /* Emit the block separator if it hasn't already been emitted. */
519 if (flag_test_coverage && ! block_separator_emitted)
520 {
521 /* Output a zero to the .bb file to indicate that a new
522 block list is starting. */
523 __write_long (0, bb_file, 4);
524 }
525 block_separator_emitted = 0;
526 }
527 /* If flag_test_coverage is true, then we must add an entry to the
528 .bb file for every note. */
529 else if (code == NOTE && flag_test_coverage)
530 {
531 /* Must ignore the line number notes that immediately follow the
532 end of an inline function to avoid counting it twice. There
533 is a note before the call, and one after the call. */
534 if (NOTE_LINE_NUMBER (insn) == NOTE_REPEATED_LINE_NUMBER)
535 ignore_next_note = 1;
536 else if (NOTE_LINE_NUMBER (insn) > 0)
537 {
538 if (ignore_next_note)
539 ignore_next_note = 0;
540 else
541 {
542 /* Emit a block separator here to ensure that a NOTE
543 immediately following a JUMP_INSN or CALL_INSN will end
544 up in the right basic block list. */
545 if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
546 || prev_code == CODE_LABEL || prev_code == BARRIER)
547 && ! block_separator_emitted)
548 {
549 /* Output a zero to the .bb file to indicate that
550 a new block list is starting. */
551 __write_long (0, bb_file, 4);
552
553 block_separator_emitted = 1;
554 }
555
556 /* If this is a new source file, then output the file's
557 name to the .bb file. */
558 if (! last_bb_file_name
559 || strcmp (NOTE_SOURCE_FILE (insn),
560 last_bb_file_name))
561 {
562 if (last_bb_file_name)
563 free (last_bb_file_name);
564 last_bb_file_name
565 = xmalloc (strlen (NOTE_SOURCE_FILE (insn)) + 1);
566 strcpy (last_bb_file_name, NOTE_SOURCE_FILE (insn));
567 output_gcov_string (NOTE_SOURCE_FILE (insn), (long)-1);
568 }
569
570 /* Output the line number to the .bb file. Must be done
571 after the output_bb_profile_data() call, and after the
572 file name is written, to ensure that it is correctly
573 handled by gcov. */
574 __write_long (NOTE_LINE_NUMBER (insn), bb_file, 4);
575 }
576 }
577 }
578
579 if (code != NOTE)
580 prev_code = code;
581 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
582 prev_code = CALL_INSN;
583 }
584
585 /* Allocate last `normal' entry for bb_graph. */
586
587 /* The last insn was a jump, call, or label. In that case we have
588 a block at the end of the function with no insns. */
589 if (prev_code == JUMP_INSN || prev_code == CALL_INSN
590 || prev_code == CODE_LABEL || prev_code == BARRIER)
591 {
592 i++;
593
594 /* Emit the block separator if it hasn't already been emitted. */
595 if (flag_test_coverage && ! block_separator_emitted)
596 {
597 /* Output a zero to the .bb file to indicate that a new
598 block list is starting. */
599 __write_long (0, bb_file, 4);
600 }
601 }
602
603 /* Create another block to stand for EXIT, and make all return insns, and
604 the last basic block point here. Add one more to account for block
605 zero. */
606 num_blocks = i + 2;
607 }
608
609 total_num_blocks += num_blocks;
610 if (dump_file)
611 fprintf (dump_file, "%d basic blocks\n", num_blocks);
612
613 /* If we are only doing test coverage here, then return now. */
614 if (! profile_arc_flag && ! flag_branch_probabilities)
615 return;
616
617 /* Create and initialize the arrays that will hold bb_graph
618 and execution count info. */
619
620 bb_graph = (struct bb_info *) alloca (num_blocks * sizeof (struct bb_info));
621 bzero ((char *) bb_graph, (sizeof (struct bb_info) * num_blocks));
622
623 {
624 /* Scan the insns again:
625 - at the entry to each basic block, increment the predecessor count
626 (and successor of previous block) if it is a fall through entry,
627 create adj_list entries for this and the previous block
628 - at each jump insn, increment predecessor/successor counts for
629 target/source basic blocks, add this insn to pred/succ lists.
630
631 This also cannot be broken out as a separate subroutine
632 because it uses `alloca'. */
633
634 register RTX_CODE prev_code = JUMP_INSN;
635 register RTX_CODE code;
636 register rtx insn;
637 register int i;
638 int fall_through = 0;
639 struct adj_list *arcptr;
640 int dest = 0;
641
642 /* Block 0 always falls through to block 1. */
643 num_arcs = 0;
644 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
645 init_arc (arcptr, 0, 1, 0);
646 arcptr->fall_through = 1;
647 num_arcs++;
648
649 /* Add a fake fall through arc from the last block to block 0, to make the
650 graph complete. */
651 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
652 init_arc (arcptr, num_blocks - 1, 0, 0);
653 arcptr->fake = 1;
654 num_arcs++;
655
656 /* Exit must be one node of the graph, and all exits from the function
657 must point there. When see a return branch, must point the arc to the
658 exit node. */
659
660 /* Must start scan with second insn in function as above. */
661 for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
662 {
663 code = GET_CODE (insn);
664
665 if (code == BARRIER)
666 fall_through = 0;
667 else if (code == CODE_LABEL)
668 ;
669 /* We make NOTE_INSN_SETJMP notes into a block of their own, so that
670 they can be the target of the fake arc for the setjmp call.
671 This avoids creating cycles of fake arcs, which would happen if
672 the block after the setjmp call ended with a call. */
673 else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
674 || prev_code == CODE_LABEL || prev_code == BARRIER)
675 && (GET_RTX_CLASS (code) == 'i'
676 || (code == NOTE
677 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
678 {
679 /* This is the first insn of the block. */
680 i += 1;
681 if (fall_through)
682 {
683 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
684 init_arc (arcptr, i - 1, i, 0);
685 arcptr->fall_through = 1;
686
687 num_arcs++;
688 }
689 fall_through = 1;
690 bb_graph[i].first_insn = insn;
691 }
692 else if (code == NOTE)
693 {;}
694
695 if (code == CALL_INSN)
696 {
697 /* In the normal case, the call returns, and this is just like
698 a branch fall through. */
699 fall_through = 1;
700
701 /* Setjmp may return more times than called, so to make the graph
702 solvable, add a fake arc from the function entrance to the
703 next block.
704
705 All other functions may return fewer times than called (if
706 a descendent call longjmp or exit), so to make the graph
707 solvable, add a fake arc to the function exit from the
708 current block.
709
710 Distinguish the cases by checking for a SETJUMP note.
711 A call_insn can be the last ins of a function, so must check
712 to see if next insn actually exists. */
713 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
714 if (NEXT_INSN (insn)
715 && GET_CODE (NEXT_INSN (insn)) == NOTE
716 && NOTE_LINE_NUMBER (NEXT_INSN (insn)) == NOTE_INSN_SETJMP)
717 init_arc (arcptr, 0, i+1, insn);
718 else
719 init_arc (arcptr, i, num_blocks-1, insn);
720 arcptr->fake = 1;
721 num_arcs++;
722 }
723 else if (code == JUMP_INSN)
724 {
725 rtx tem, pattern = PATTERN (insn);
726 rtx tablejump = 0;
727
728 /* If running without optimization, then jump label won't be valid,
729 so we must search for the destination label in that case.
730 We have to handle tablejumps and returns specially anyways, so
731 we don't check the JUMP_LABEL at all here. */
732
733 /* ??? This code should be rewritten. We need a more elegant way
734 to find the LABEL_REF. We need a more elegant way to
735 differentiate tablejump entries from computed gotos.
736 We should perhaps reuse code from flow to compute the CFG
737 instead of trying to compute it here.
738
739 We can't use current_function_has_computed_jump, because that
740 is calculated later by flow. We can't use computed_jump_p,
741 because that returns true for tablejump entry insns for some
742 targets, e.g. HPPA and MIPS. */
743
744 if (GET_CODE (pattern) == PARALLEL)
745 {
746 /* This assumes that PARALLEL jumps with a USE are
747 tablejump entry jumps. The same assumption can be found
748 in computed_jump_p. */
749 /* Make an arc from this jump to the label of the
750 jump table. This will instrument the number of
751 times the switch statement is executed. */
752 if (GET_CODE (XVECEXP (pattern, 0, 1)) == USE)
753 {
754 tem = XEXP (XVECEXP (pattern, 0, 1), 0);
755 if (GET_CODE (tem) != LABEL_REF)
756 abort ();
757 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
758 }
759 else if (GET_CODE (XVECEXP (pattern, 0, 0)) == SET
760 && SET_DEST (XVECEXP (pattern, 0, 0)) == pc_rtx)
761 {
762 tem = SET_SRC (XVECEXP (pattern, 0, 0));
763 if (GET_CODE (tem) == PLUS
764 && GET_CODE (XEXP (tem, 1)) == LABEL_REF)
765 {
766 tem = XEXP (tem, 1);
767 dest = label_to_bb [CODE_LABEL_NUMBER (XEXP (tem, 0))];
768 }
769 }
770 else
771 abort ();
772 }
773 else if (GET_CODE (pattern) == ADDR_VEC
774 || GET_CODE (pattern) == ADDR_DIFF_VEC)
775 tablejump = pattern;
776 else if (GET_CODE (pattern) == RETURN)
777 dest = num_blocks - 1;
778 else if (GET_CODE (pattern) != SET)
779 abort ();
780 else if ((tem = SET_SRC (pattern))
781 && GET_CODE (tem) == LABEL_REF)
782 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
783 /* Recognize HPPA table jump entry. This code is similar to
784 the code above in the PARALLEL case. */
785 else if (GET_CODE (tem) == PLUS
786 && GET_CODE (XEXP (tem, 0)) == MEM
787 && GET_CODE (XEXP (XEXP (tem, 0), 0)) == PLUS
788 && GET_CODE (XEXP (XEXP (XEXP (tem, 0), 0), 0)) == PC
789 && GET_CODE (XEXP (tem, 1)) == LABEL_REF
790 && tablejump_entry_p (insn, XEXP (tem, 1)))
791 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
792 /* Recognize the MIPS table jump entry. */
793 else if (GET_CODE (tem) == PLUS
794 && GET_CODE (XEXP (tem, 0)) == REG
795 && GET_CODE (XEXP (tem, 1)) == LABEL_REF
796 && tablejump_entry_p (insn, XEXP (tem, 1)))
797 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
798 else
799 {
800 rtx label_ref;
801
802 /* Must be an IF_THEN_ELSE branch. If it isn't, assume it
803 is a computed goto, which aren't supported yet. */
804 if (GET_CODE (tem) != IF_THEN_ELSE)
805 fatal ("-fprofile-arcs does not support computed gotos");
806 if (XEXP (tem, 1) != pc_rtx)
807 label_ref = XEXP (tem, 1);
808 else
809 label_ref = XEXP (tem, 2);
810 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (label_ref, 0))];
811 }
812
813 if (tablejump)
814 {
815 int diff_vec_p = GET_CODE (tablejump) == ADDR_DIFF_VEC;
816 int len = XVECLEN (tablejump, diff_vec_p);
817 int k;
818
819 for (k = 0; k < len; k++)
820 {
821 rtx tem = XEXP (XVECEXP (tablejump, diff_vec_p, k), 0);
822 dest = label_to_bb[CODE_LABEL_NUMBER (tem)];
823
824 arcptr = (struct adj_list *) alloca (sizeof(struct adj_list));
825 init_arc (arcptr, i, dest, insn);
826
827 num_arcs++;
828 }
829 }
830 else
831 {
832 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
833 init_arc (arcptr, i, dest, insn);
834
835 num_arcs++;
836 }
837
838 /* Determine whether or not this jump will fall through.
839 Unconditional jumps and returns are not always followed by
840 barriers. */
841 pattern = PATTERN (insn);
842 if (GET_CODE (pattern) == PARALLEL
843 || GET_CODE (pattern) == RETURN)
844 fall_through = 0;
845 else if (GET_CODE (pattern) == ADDR_VEC
846 || GET_CODE (pattern) == ADDR_DIFF_VEC)
847 /* These aren't actually jump insns, but they never fall
848 through, so... */
849 fall_through = 0;
850 else
851 {
852 if (GET_CODE (pattern) != SET || SET_DEST (pattern) != pc_rtx)
853 abort ();
854 if (GET_CODE (SET_SRC (pattern)) != IF_THEN_ELSE)
855 fall_through = 0;
856 }
857 }
858
859 if (code != NOTE)
860 prev_code = code;
861 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
862 {
863 /* Make a fake insn to tag our notes on. */
864 bb_graph[i].first_insn = insn
865 = emit_insn_after (gen_rtx_USE (VOIDmode, stack_pointer_rtx),
866 insn);
867 prev_code = CALL_INSN;
868 }
869 }
870
871 /* If the code at the end of the function would give a new block, then
872 do the following. */
873
874 if (prev_code == JUMP_INSN || prev_code == CALL_INSN
875 || prev_code == CODE_LABEL || prev_code == BARRIER)
876 {
877 if (fall_through)
878 {
879 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
880 init_arc (arcptr, i, i + 1, 0);
881 arcptr->fall_through = 1;
882
883 num_arcs++;
884 }
885
886 /* This may not be a real insn, but that should not cause a problem. */
887 bb_graph[i+1].first_insn = get_last_insn ();
888 }
889
890 /* There is always a fake arc from the last block of the function
891 to the function exit block. */
892 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
893 init_arc (arcptr, num_blocks-2, num_blocks-1, 0);
894 arcptr->fake = 1;
895 num_arcs++;
896 }
897
898 total_num_arcs += num_arcs;
899 if (dump_file)
900 fprintf (dump_file, "%d arcs\n", num_arcs);
901
902 /* Create spanning tree from basic block graph, mark each arc that is
903 on the spanning tree. */
904
905 /* To reduce the instrumentation cost, make two passes over the tree.
906 First, put as many must-split (crowded and fake) arcs on the tree as
907 possible, then on the second pass fill in the rest of the tree.
908 Note that the spanning tree is considered undirected, so that as many
909 must-split arcs as possible can be put on it.
910
911 Fallthrough arcs which are crowded should not be chosen on the first
912 pass, since they do not require creating a new basic block. These
913 arcs will have fall_through set. */
914
915 find_spanning_tree (num_blocks);
916
917 /* Create a .bbg file from which gcov can reconstruct the basic block
918 graph. First output the number of basic blocks, and then for every
919 arc output the source and target basic block numbers.
920 NOTE: The format of this file must be compatible with gcov. */
921
922 if (flag_test_coverage)
923 {
924 int flag_bits;
925
926 __write_long (num_blocks, bbg_file, 4);
927 __write_long (num_arcs, bbg_file, 4);
928
929 for (i = 0; i < num_blocks; i++)
930 {
931 long count = 0;
932 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
933 count++;
934 __write_long (count, bbg_file, 4);
935
936 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
937 {
938 flag_bits = 0;
939 if (arcptr->on_tree)
940 flag_bits |= 0x1;
941 if (arcptr->fake)
942 flag_bits |= 0x2;
943 if (arcptr->fall_through)
944 flag_bits |= 0x4;
945
946 __write_long (ARC_TARGET (arcptr), bbg_file, 4);
947 __write_long (flag_bits, bbg_file, 4);
948 }
949 }
950
951 /* Emit a -1 to separate the list of all arcs from the list of
952 loop back edges that follows. */
953 __write_long (-1, bbg_file, 4);
954 }
955
956 /* For each arc not on the spanning tree, add counting code as rtl. */
957
958 if (profile_arc_flag)
959 {
960 instrument_arcs (f, num_blocks, dump_file);
961 allocate_reg_info (max_reg_num (), FALSE, FALSE);
962 }
963
964 /* Execute the rest only if doing branch probabilities. */
965 if (! flag_branch_probabilities)
966 return;
967
968 /* For each arc not on the spanning tree, set its execution count from
969 the .da file. */
970
971 /* The first count in the .da file is the number of times that the function
972 was entered. This is the exec_count for block zero. */
973
974 num_arcs = 0;
975 for (i = 0; i < num_blocks; i++)
976 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
977 if (! arcptr->on_tree)
978 {
979 num_arcs++;
980 if (da_file)
981 {
982 long value;
983 __read_long (&value, da_file, 8);
984 ARC_COUNT (arcptr) = value;
985 }
986 else
987 ARC_COUNT (arcptr) = 0;
988 arcptr->count_valid = 1;
989 bb_graph[i].succ_count--;
990 bb_graph[ARC_TARGET (arcptr)].pred_count--;
991 }
992
993 if (dump_file)
994 fprintf (dump_file, "%d arc counts read\n", num_arcs);
995
996 /* For every block in the file,
997 - if every exit/entrance arc has a known count, then set the block count
998 - if the block count is known, and every exit/entrance arc but one has
999 a known execution count, then set the count of the remaining arc
1000
1001 As arc counts are set, decrement the succ/pred count, but don't delete
1002 the arc, that way we can easily tell when all arcs are known, or only
1003 one arc is unknown. */
1004
1005 /* The order that the basic blocks are iterated through is important.
1006 Since the code that finds spanning trees starts with block 0, low numbered
1007 arcs are put on the spanning tree in preference to high numbered arcs.
1008 Hence, most instrumented arcs are at the end. Graph solving works much
1009 faster if we propagate numbers from the end to the start.
1010
1011 This takes an average of slightly more than 3 passes. */
1012
1013 changes = 1;
1014 passes = 0;
1015 while (changes)
1016 {
1017 passes++;
1018 changes = 0;
1019
1020 for (i = num_blocks - 1; i >= 0; i--)
1021 {
1022 struct bb_info *binfo = &bb_graph[i];
1023 if (! binfo->count_valid)
1024 {
1025 if (binfo->succ_count == 0)
1026 {
1027 total = 0;
1028 for (arcptr = binfo->succ; arcptr;
1029 arcptr = arcptr->succ_next)
1030 total += ARC_COUNT (arcptr);
1031 binfo->exec_count = total;
1032 binfo->count_valid = 1;
1033 changes = 1;
1034 }
1035 else if (binfo->pred_count == 0)
1036 {
1037 total = 0;
1038 for (arcptr = binfo->pred; arcptr;
1039 arcptr = arcptr->pred_next)
1040 total += ARC_COUNT (arcptr);
1041 binfo->exec_count = total;
1042 binfo->count_valid = 1;
1043 changes = 1;
1044 }
1045 }
1046 if (binfo->count_valid)
1047 {
1048 if (binfo->succ_count == 1)
1049 {
1050 total = 0;
1051 /* One of the counts will be invalid, but it is zero,
1052 so adding it in also doesn't hurt. */
1053 for (arcptr = binfo->succ; arcptr;
1054 arcptr = arcptr->succ_next)
1055 total += ARC_COUNT (arcptr);
1056 /* Calculate count for remaining arc by conservation. */
1057 total = binfo->exec_count - total;
1058 /* Search for the invalid arc, and set its count. */
1059 for (arcptr = binfo->succ; arcptr;
1060 arcptr = arcptr->succ_next)
1061 if (! arcptr->count_valid)
1062 break;
1063 if (! arcptr)
1064 abort ();
1065 arcptr->count_valid = 1;
1066 ARC_COUNT (arcptr) = total;
1067 binfo->succ_count--;
1068
1069 bb_graph[ARC_TARGET (arcptr)].pred_count--;
1070 changes = 1;
1071 }
1072 if (binfo->pred_count == 1)
1073 {
1074 total = 0;
1075 /* One of the counts will be invalid, but it is zero,
1076 so adding it in also doesn't hurt. */
1077 for (arcptr = binfo->pred; arcptr;
1078 arcptr = arcptr->pred_next)
1079 total += ARC_COUNT (arcptr);
1080 /* Calculate count for remaining arc by conservation. */
1081 total = binfo->exec_count - total;
1082 /* Search for the invalid arc, and set its count. */
1083 for (arcptr = binfo->pred; arcptr;
1084 arcptr = arcptr->pred_next)
1085 if (! arcptr->count_valid)
1086 break;
1087 if (! arcptr)
1088 abort ();
1089 arcptr->count_valid = 1;
1090 ARC_COUNT (arcptr) = total;
1091 binfo->pred_count--;
1092
1093 bb_graph[ARC_SOURCE (arcptr)].succ_count--;
1094 changes = 1;
1095 }
1096 }
1097 }
1098 }
1099
1100 total_num_passes += passes;
1101 if (dump_file)
1102 fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
1103
1104 /* If the graph has been correctly solved, every block will have a
1105 succ and pred count of zero. */
1106 for (i = 0; i < num_blocks; i++)
1107 {
1108 struct bb_info *binfo = &bb_graph[i];
1109 if (binfo->succ_count || binfo->pred_count)
1110 abort ();
1111 }
1112
1113 /* For every arc, calculate its branch probability and add a reg_note
1114 to the branch insn to indicate this. */
1115
1116 for (i = 0; i < 20; i++)
1117 hist_br_prob[i] = 0;
1118 num_never_executed = 0;
1119 num_branches = 0;
1120
1121 for (i = 0; i < num_blocks; i++)
1122 {
1123 struct bb_info *binfo = &bb_graph[i];
1124
1125 total = binfo->exec_count;
1126 for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
1127 {
1128 if (arcptr->branch_insn)
1129 {
1130 /* This calculates the branch probability as an integer between
1131 0 and REG_BR_PROB_BASE, properly rounded to the nearest
1132 integer. Perform the arithmetic in double to avoid
1133 overflowing the range of ints. */
1134
1135 if (total == 0)
1136 prob = -1;
1137 else
1138 {
1139 rtx pat = PATTERN (arcptr->branch_insn);
1140
1141 prob = (((double)ARC_COUNT (arcptr) * REG_BR_PROB_BASE)
1142 + (total >> 1)) / total;
1143 if (prob < 0 || prob > REG_BR_PROB_BASE)
1144 {
1145 if (dump_file)
1146 fprintf (dump_file, "bad count: prob for %d-%d thought to be %d (forcibly normalized)\n",
1147 ARC_SOURCE (arcptr), ARC_TARGET (arcptr),
1148 prob);
1149
1150 bad_counts = 1;
1151 prob = REG_BR_PROB_BASE / 2;
1152 }
1153
1154 /* Match up probability with JUMP pattern. */
1155
1156 if (GET_CODE (pat) == SET
1157 && GET_CODE (SET_SRC (pat)) == IF_THEN_ELSE)
1158 {
1159 if (ARC_TARGET (arcptr) == ARC_SOURCE (arcptr) + 1)
1160 {
1161 /* A fall through arc should never have a
1162 branch insn. */
1163 abort ();
1164 }
1165 else
1166 {
1167 /* This is the arc for the taken branch. */
1168 if (GET_CODE (XEXP (SET_SRC (pat), 2)) != PC)
1169 prob = REG_BR_PROB_BASE - prob;
1170 }
1171 }
1172 }
1173
1174 if (prob == -1)
1175 num_never_executed++;
1176 else
1177 {
1178 int index = prob * 20 / REG_BR_PROB_BASE;
1179 if (index == 20)
1180 index = 19;
1181 hist_br_prob[index]++;
1182 }
1183 num_branches++;
1184
1185 REG_NOTES (arcptr->branch_insn)
1186 = gen_rtx_EXPR_LIST (REG_BR_PROB, GEN_INT (prob),
1187 REG_NOTES (arcptr->branch_insn));
1188 }
1189 }
1190
1191 /* Add a REG_EXEC_COUNT note to the first instruction of this block. */
1192 if (! binfo->first_insn
1193 || GET_RTX_CLASS (GET_CODE (binfo->first_insn)) != 'i')
1194 {
1195 /* Block 0 is a fake block representing function entry, and does
1196 not have a real first insn. The second last block might not
1197 begin with a real insn. */
1198 if (i == num_blocks - 1)
1199 return_label_execution_count = total;
1200 else if (i != 0 && i != num_blocks - 2)
1201 abort ();
1202 }
1203 else
1204 {
1205 REG_NOTES (binfo->first_insn)
1206 = gen_rtx_EXPR_LIST (REG_EXEC_COUNT, GEN_INT (total),
1207 REG_NOTES (binfo->first_insn));
1208 if (i == num_blocks - 1)
1209 return_label_execution_count = total;
1210 }
1211 }
1212
1213 /* This should never happen. */
1214 if (bad_counts)
1215 warning ("Arc profiling: some arc counts were bad.");
1216
1217 if (dump_file)
1218 {
1219 fprintf (dump_file, "%d branches\n", num_branches);
1220 fprintf (dump_file, "%d branches never executed\n",
1221 num_never_executed);
1222 if (num_branches)
1223 for (i = 0; i < 10; i++)
1224 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1225 (hist_br_prob[i]+hist_br_prob[19-i])*100/num_branches,
1226 5*i, 5*i+5);
1227
1228 total_num_branches += num_branches;
1229 total_num_never_executed += num_never_executed;
1230 for (i = 0; i < 20; i++)
1231 total_hist_br_prob[i] += hist_br_prob[i];
1232 }
1233
1234}
1235
1236/* Initialize a new arc.
1237 ARCPTR is the empty adj_list this function fills in.
1238 SOURCE is the block number of the source block.
1239 TARGET is the block number of the target block.
1240 INSN is the insn which transfers control from SOURCE to TARGET,
1241 or zero if the transfer is implicit. */
1242
1243static void
1244init_arc (arcptr, source, target, insn)
1245 struct adj_list *arcptr;
1246 int source, target;
1247 rtx insn;
1248{
1249 ARC_TARGET (arcptr) = target;
1250 ARC_SOURCE (arcptr) = source;
1251
1252 ARC_COUNT (arcptr) = 0;
1253 arcptr->count_valid = 0;
1254 arcptr->on_tree = 0;
1255 arcptr->fake = 0;
1256 arcptr->fall_through = 0;
1257 arcptr->branch_insn = insn;
1258
1259 arcptr->succ_next = bb_graph[source].succ;
1260 bb_graph[source].succ = arcptr;
1261 bb_graph[source].succ_count++;
1262
1263 arcptr->pred_next = bb_graph[target].pred;
1264 bb_graph[target].pred = arcptr;
1265 bb_graph[target].pred_count++;
1266}
1267
1268/* This function searches all of the arcs in the program flow graph, and puts
1269 as many bad arcs as possible onto the spanning tree. Bad arcs include
1270 fake arcs (needed for setjmp(), longjmp(), exit()) which MUST be on the
1271 spanning tree as they can't be instrumented. Also, arcs which must be
1272 split when instrumented should be part of the spanning tree if possible. */
1273
1274static void
1275find_spanning_tree (num_blocks)
1276 int num_blocks;
1277{
1278 int i;
1279 struct adj_list *arcptr;
1280 struct bb_info *binfo = &bb_graph[0];
1281
1282 /* Fake arcs must be part of the spanning tree, and are always safe to put
1283 on the spanning tree. Fake arcs will either be a successor of node 0,
1284 a predecessor of the last node, or from the last node to node 0. */
1285
1286 for (arcptr = bb_graph[0].succ; arcptr; arcptr = arcptr->succ_next)
1287 if (arcptr->fake)
1288 {
1289 /* Adding this arc should never cause a cycle. This is a fatal
1290 error if it would. */
1291 if (bb_graph[ARC_TARGET (arcptr)].on_tree && binfo->on_tree)
1292 abort();
1293 else
1294 {
1295 arcptr->on_tree = 1;
1296 bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
1297 binfo->on_tree = 1;
1298 }
1299 }
1300
1301 binfo = &bb_graph[num_blocks-1];
1302 for (arcptr = binfo->pred; arcptr; arcptr = arcptr->pred_next)
1303 if (arcptr->fake)
1304 {
1305 /* Adding this arc should never cause a cycle. This is a fatal
1306 error if it would. */
1307 if (bb_graph[ARC_SOURCE (arcptr)].on_tree && binfo->on_tree)
1308 abort();
1309 else
1310 {
1311 arcptr->on_tree = 1;
1312 bb_graph[ARC_SOURCE (arcptr)].on_tree = 1;
1313 binfo->on_tree = 1;
1314 }
1315 }
1316 /* The only entrace to node zero is a fake arc. */
1317 bb_graph[0].pred->on_tree = 1;
1318
1319 /* Arcs which are crowded at both the source and target should be put on
1320 the spanning tree if possible, except for fall_throuch arcs which never
1321 require adding a new block even if crowded, add arcs with the same source
1322 and dest which must always be instrumented. */
1323 for (i = 0; i < num_blocks; i++)
1324 {
1325 binfo = &bb_graph[i];
1326
1327 for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
1328 if (! ((binfo->succ == arcptr && arcptr->succ_next == 0)
1329 || (bb_graph[ARC_TARGET (arcptr)].pred
1330 && arcptr->pred_next == 0))
1331 && ! arcptr->fall_through
1332 && ARC_TARGET (arcptr) != i)
1333 {
1334 /* This is a crowded arc at both source and target. Try to put
1335 in on the spanning tree. Can do this if either the source or
1336 target block is not yet on the tree. */
1337 if (! bb_graph[ARC_TARGET (arcptr)].on_tree || ! binfo->on_tree)
1338 {
1339 arcptr->on_tree = 1;
1340 bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
1341 binfo->on_tree = 1;
1342 }
1343 }
1344 }
1345
1346 /* Clear all of the basic block on_tree bits, so that we can use them to
1347 create the spanning tree. */
1348 for (i = 0; i < num_blocks; i++)
1349 bb_graph[i].on_tree = 0;
1350
1351 /* Now fill in the spanning tree until every basic block is on it.
1352 Don't put the 0 to 1 fall through arc on the tree, since it is
1353 always cheap to instrument, so start filling the tree from node 1. */
1354
1355 for (i = 1; i < num_blocks; i++)
1356 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
1357 if (! arcptr->on_tree
1358 && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1359 {
1360 fill_spanning_tree (i);
1361 break;
1362 }
1363}
1364
1365/* Add arcs reached from BLOCK to the spanning tree if they are needed and
1366 not already there. */
1367
1368static void
1369fill_spanning_tree (block)
1370 int block;
1371{
1372 struct adj_list *arcptr;
1373
1374 expand_spanning_tree (block);
1375
1376 for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
1377 if (! arcptr->on_tree
1378 && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1379 {
1380 arcptr->on_tree = 1;
1381 fill_spanning_tree (ARC_TARGET (arcptr));
1382 }
1383}
1384
1385/* When first visit a block, must add all blocks that are already connected
1386 to this block via tree arcs to the spanning tree. */
1387
1388static void
1389expand_spanning_tree (block)
1390 int block;
1391{
1392 struct adj_list *arcptr;
1393
1394 bb_graph[block].on_tree = 1;
1395
1396 for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
1397 if (arcptr->on_tree && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1398 expand_spanning_tree (ARC_TARGET (arcptr));
1399
1400 for (arcptr = bb_graph[block].pred;
1401 arcptr; arcptr = arcptr->pred_next)
1402 if (arcptr->on_tree && ! bb_graph[ARC_SOURCE (arcptr)].on_tree)
1403 expand_spanning_tree (ARC_SOURCE (arcptr));
1404}
1405
1406/* Perform file-level initialization for branch-prob processing. */
1407
1408void
1409init_branch_prob (filename)
1410 const char *filename;
1411{
1412 long len;
1413 int i;
1414
1415 if (flag_test_coverage)
1416 {
1417 /* Open an output file for the basic block/line number map. */
1418 int len = strlen (filename);
1419 char *data_file = (char *) alloca (len + 4);
1420 strcpy (data_file, filename);
1421 strip_off_ending (data_file, len);
1422 strcat (data_file, ".bb");
1423 if ((bb_file = fopen (data_file, "w")) == 0)
1424 pfatal_with_name (data_file);
1425
1426 /* Open an output file for the program flow graph. */
1427 len = strlen (filename);
1428 bbg_file_name = (char *) alloca (len + 5);
1429 strcpy (bbg_file_name, filename);
1430 strip_off_ending (bbg_file_name, len);
1431 strcat (bbg_file_name, ".bbg");
1432 if ((bbg_file = fopen (bbg_file_name, "w")) == 0)
1433 pfatal_with_name (bbg_file_name);
1434
1435 /* Initialize to zero, to ensure that the first file name will be
1436 written to the .bb file. */
1437 last_bb_file_name = 0;
1438 }
1439
1440 if (flag_branch_probabilities)
1441 {
1442 len = strlen (filename);
1443 da_file_name = (char *) alloca (len + 4);
1444 strcpy (da_file_name, filename);
1445 strip_off_ending (da_file_name, len);
1446 strcat (da_file_name, ".da");
1447 if ((da_file = fopen (da_file_name, "r")) == 0)
1448 warning ("file %s not found, execution counts assumed to be zero.",
1449 da_file_name);
1450
1451 /* The first word in the .da file gives the number of instrumented arcs,
1452 which is not needed for our purposes. */
1453
1454 if (da_file)
1455 __read_long (&len, da_file, 8);
1456 }
1457
1458 if (profile_arc_flag)
1459 init_arc_profiler ();
1460
1461 total_num_blocks = 0;
1462 total_num_arcs = 0;
1463 total_num_arcs_instrumented = 0;
1464 total_num_blocks_created = 0;
1465 total_num_passes = 0;
1466 total_num_times_called = 0;
1467 total_num_branches = 0;
1468 total_num_never_executed = 0;
1469 for (i = 0; i < 20; i++)
1470 total_hist_br_prob[i] = 0;
1471}
1472
1473/* Performs file-level cleanup after branch-prob processing
1474 is completed. */
1475
1476void
1477end_branch_prob (dump_file)
1478 FILE *dump_file;
1479{
1480 if (flag_test_coverage)
1481 {
1482 fclose (bb_file);
1483 fclose (bbg_file);
1484 }
1485
1486 if (flag_branch_probabilities)
1487 {
1488 if (da_file)
1489 {
1490 long temp;
1491 /* This seems slightly dangerous, as it presumes the EOF
1492 flag will not be set until an attempt is made to read
1493 past the end of the file. */
1494 if (feof (da_file))
1495 warning (".da file contents exhausted too early\n");
1496 /* Should be at end of file now. */
1497 if (__read_long (&temp, da_file, 8) == 0)
1498 warning (".da file contents not exhausted\n");
1499 fclose (da_file);
1500 }
1501 }
1502
1503 if (dump_file)
1504 {
1505 fprintf (dump_file, "\n");
1506 fprintf (dump_file, "Total number of blocks: %d\n", total_num_blocks);
1507 fprintf (dump_file, "Total number of arcs: %d\n", total_num_arcs);
1508 fprintf (dump_file, "Total number of instrumented arcs: %d\n",
1509 total_num_arcs_instrumented);
1510 fprintf (dump_file, "Total number of blocks created: %d\n",
1511 total_num_blocks_created);
1512 fprintf (dump_file, "Total number of graph solution passes: %d\n",
1513 total_num_passes);
1514 if (total_num_times_called != 0)
1515 fprintf (dump_file, "Average number of graph solution passes: %d\n",
1516 (total_num_passes + (total_num_times_called >> 1))
1517 / total_num_times_called);
1518 fprintf (dump_file, "Total number of branches: %d\n", total_num_branches);
1519 fprintf (dump_file, "Total number of branches never executed: %d\n",
1520 total_num_never_executed);
1521 if (total_num_branches)
1522 {
1523 int i;
1524
1525 for (i = 0; i < 10; i++)
1526 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1527 (total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
1528 / total_num_branches, 5*i, 5*i+5);
1529 }
1530 }
1531}
1532
1533/* The label used by the arc profiling code. */
1534
1535static rtx profiler_label;
1536
1537/* Initialize the profiler_label. */
1538
1539static void
1540init_arc_profiler ()
1541{
1542 /* Generate and save a copy of this so it can be shared. */
1543 char *name = xmalloc (20);
1544 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
1545 profiler_label = gen_rtx_SYMBOL_REF (Pmode, name);
1546}
1547
1548/* Output instructions as RTL to increment the arc execution count. */
1549
1550static void
1551output_arc_profiler (arcno, insert_after)
1552 int arcno;
1553 rtx insert_after;
1554{
1555 rtx profiler_target_addr
1556 = (arcno
1557 ? gen_rtx_CONST (Pmode,
1558 gen_rtx_PLUS (Pmode, profiler_label,
1559 GEN_INT (LONG_TYPE_SIZE / BITS_PER_UNIT * arcno)))
1560 : profiler_label);
1561 enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
1562 rtx profiler_reg = gen_reg_rtx (mode);
1563 rtx address_reg = gen_reg_rtx (Pmode);
1564 rtx mem_ref, add_ref;
1565 rtx sequence;
1566
1567 /* In this case, reload can use explicitly mentioned hard registers for
1568 reloads. It is not safe to output profiling code between a call
1569 and the instruction that copies the result to a pseudo-reg. This
1570 is because reload may allocate one of the profiling code pseudo-regs
1571 to the return value reg, thus clobbering the return value. So we
1572 must check for calls here, and emit the profiling code after the
1573 instruction that uses the return value, if any.
1574
1575 ??? The code here performs the same tests that reload does so hopefully
1576 all the bases are covered. */
1577
1578 if (SMALL_REGISTER_CLASSES
1579 && GET_CODE (insert_after) == CALL_INSN
1580 && (GET_CODE (PATTERN (insert_after)) == SET
1581 || (GET_CODE (PATTERN (insert_after)) == PARALLEL
1582 && GET_CODE (XVECEXP (PATTERN (insert_after), 0, 0)) == SET)))
1583 {
1584 rtx return_reg;
1585 rtx next_insert_after = next_nonnote_insn (insert_after);
1586
1587 /* The first insn after the call may be a stack pop, skip it. */
1588 if (next_insert_after
1589 && GET_CODE (next_insert_after) == INSN
1590 && GET_CODE (PATTERN (next_insert_after)) == SET
1591 && SET_DEST (PATTERN (next_insert_after)) == stack_pointer_rtx)
1592 next_insert_after = next_nonnote_insn (next_insert_after);
1593
1594 if (next_insert_after
1595 && GET_CODE (next_insert_after) == INSN)
1596 {
1597 if (GET_CODE (PATTERN (insert_after)) == SET)
1598 return_reg = SET_DEST (PATTERN (insert_after));
1599 else
1600 return_reg = SET_DEST (XVECEXP (PATTERN (insert_after), 0, 0));
1601
1602 /* Now, NEXT_INSERT_AFTER may be an instruction that uses the
1603 return value. However, it could also be something else,
1604 like a CODE_LABEL, so check that the code is INSN. */
1605 if (next_insert_after != 0
1606 && GET_RTX_CLASS (GET_CODE (next_insert_after)) == 'i'
1607 && reg_referenced_p (return_reg, PATTERN (next_insert_after)))
1608 insert_after = next_insert_after;
1609 }
1610 }
1611
1612 start_sequence ();
1613
1614 emit_move_insn (address_reg, profiler_target_addr);
1615 mem_ref = gen_rtx_MEM (mode, address_reg);
1616 emit_move_insn (profiler_reg, mem_ref);
1617
1618 add_ref = gen_rtx_PLUS (mode, profiler_reg, GEN_INT (1));
1619 emit_move_insn (profiler_reg, add_ref);
1620
1621 /* This is the same rtx as above, but it is not legal to share this rtx. */
1622 mem_ref = gen_rtx_MEM (mode, address_reg);
1623 emit_move_insn (mem_ref, profiler_reg);
1624
1625 sequence = gen_sequence ();
1626 end_sequence ();
1627 emit_insn_after (sequence, insert_after);
1628}
1629
1630/* Output code for a constructor that will invoke __bb_init_func, if
1631 this has not already been done. */
1632
1633void
1634output_func_start_profiler ()
1635{
1636 tree fnname, fndecl;
1637 char *name, *cfnname;
1638 rtx table_address;
1639 enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
1640 int save_flag_inline_functions = flag_inline_functions;
1641
1642 /* It's either already been output, or we don't need it because we're
1643 not doing profile-arcs. */
1644 if (! need_func_profiler)
1645 return;
1646
1647 need_func_profiler = 0;
1648
1649 /* Synthesize a constructor function to invoke __bb_init_func with a
1650 pointer to this object file's profile block. */
1651 start_sequence ();
1652
1653 /* Try and make a unique name given the "file function name".
1654
1655 And no, I don't like this either. */
1656
1657 fnname = get_file_function_name ('I');
1658 cfnname = IDENTIFIER_POINTER (fnname);
1659 name = xmalloc (strlen (cfnname) + 5);
1660 sprintf (name, "%sGCOV",cfnname);
1661 fnname = get_identifier (name);
1662 free (name);
1663
1664 fndecl = build_decl (FUNCTION_DECL, fnname,
1665 build_function_type (void_type_node, NULL_TREE));
1666 DECL_EXTERNAL (fndecl) = 0;
1667 TREE_PUBLIC (fndecl) = 1;
1668 DECL_ASSEMBLER_NAME (fndecl) = fnname;
1669 DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
1670
1671 fndecl = pushdecl (fndecl);
1672 rest_of_decl_compilation (fndecl, 0, 1, 0);
1673 announce_function (fndecl);
1674 current_function_decl = fndecl;
1675 DECL_INITIAL (fndecl) = error_mark_node;
1676 temporary_allocation ();
1677 pushlevel (0);
1678 make_function_rtl (fndecl);
1679 init_function_start (fndecl, input_filename, lineno);
1680 expand_function_start (fndecl, 0);
1681
1682 /* Actually generate the code to call __bb_init_func. */
1683 name = xmalloc (20);
1684 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0);
1685 table_address = force_reg (Pmode, gen_rtx_SYMBOL_REF (Pmode, name));
1686 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_init_func"), 0,
1687 mode, 1, table_address, Pmode);
1688
1689 expand_function_end (input_filename, lineno, 0);
1690 poplevel (1, 0, 1);
1691
1692 /* Since fndecl isn't in the list of globals, it would never be emitted
1693 when it's considered to be 'safe' for inlining, so turn off
1694 flag_inline_functions. */
1695 flag_inline_functions = 0;
1696
1697 rest_of_compilation (fndecl);
1698
1699 /* Reset flag_inline_functions to its original value. */
1700 flag_inline_functions = save_flag_inline_functions;
1701
1702 if (! quiet_flag)
1703 fflush (asm_out_file);
1704 current_function_decl = NULL_TREE;
1705
1706 assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
1707}
2 Copyright (C) 1990, 91-94, 96-98, 1999 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
6
7This file is part of GNU CC.
8
9GNU CC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GNU CC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GNU CC; see the file COPYING. If not, write to
21the Free Software Foundation, 59 Temple Place - Suite 330,
22Boston, MA 02111-1307, USA. */
23
24/* ??? Really should not put insns inside of LIBCALL sequences, when putting
25 insns after a call, should look for the insn setting the retval, and
26 insert the insns after that one. */
27
28/* ??? Register allocation should use basic block execution counts to
29 give preference to the most commonly executed blocks. */
30
31/* ??? The .da files are not safe. Changing the program after creating .da
32 files or using different options when compiling with -fbranch-probabilities
33 can result the arc data not matching the program. Maybe add instrumented
34 arc count to .bbg file? Maybe check whether PFG matches the .bbg file? */
35
36/* ??? Should calculate branch probabilities before instrumenting code, since
37 then we can use arc counts to help decide which arcs to instrument. */
38
39/* ??? Rearrange code so that the most frequently executed arcs become from
40 one block to the next block (i.e. a fall through), move seldom executed
41 code outside of loops even at the expense of adding a few branches to
42 achieve this, see Dain Sample's UC Berkeley thesis. */
43
44#include "config.h"
45#include "system.h"
46#include "rtl.h"
47#include "flags.h"
48#include "insn-flags.h"
49#include "insn-config.h"
50#include "output.h"
51#include "regs.h"
52#include "tree.h"
53#include "output.h"
54#include "gcov-io.h"
55#include "toplev.h"
56
57/* One of these is dynamically created whenever we identify an arc in the
58 function. */
59
60struct adj_list
61{
62 int source;
63 int target;
64 int arc_count;
65 unsigned int count_valid : 1;
66 unsigned int on_tree : 1;
67 unsigned int fake : 1;
68 unsigned int fall_through : 1;
69 rtx branch_insn;
70 struct adj_list *pred_next;
71 struct adj_list *succ_next;
72};
73
74#define ARC_TARGET(ARCPTR) (ARCPTR->target)
75#define ARC_SOURCE(ARCPTR) (ARCPTR->source)
76#define ARC_COUNT(ARCPTR) (ARCPTR->arc_count)
77
78/* Count the number of basic blocks, and create an array of these structures,
79 one for each bb in the function. */
80
81struct bb_info
82{
83 struct adj_list *succ;
84 struct adj_list *pred;
85 int succ_count;
86 int pred_count;
87 int exec_count;
88 unsigned int count_valid : 1;
89 unsigned int on_tree : 1;
90 rtx first_insn;
91};
92
93/* Indexed by label number, gives the basic block number containing that
94 label. */
95
96static int *label_to_bb;
97
98/* Number of valid entries in the label_to_bb array. */
99
100static int label_to_bb_size;
101
102/* Indexed by block index, holds the basic block graph. */
103
104static struct bb_info *bb_graph;
105
106/* Name and file pointer of the output file for the basic block graph. */
107
108static char *bbg_file_name;
109static FILE *bbg_file;
110
111/* Name and file pointer of the input file for the arc count data. */
112
113static char *da_file_name;
114static FILE *da_file;
115
116/* Pointer of the output file for the basic block/line number map. */
117static FILE *bb_file;
118
119/* Last source file name written to bb_file. */
120
121static char *last_bb_file_name;
122
123/* Indicates whether the next line number note should be output to
124 bb_file or not. Used to eliminate a redundant note after an
125 expanded inline function call. */
126
127static int ignore_next_note;
128
129/* Used by final, for allocating the proper amount of storage for the
130 instrumented arc execution counts. */
131
132int count_instrumented_arcs;
133
134/* Number of executions for the return label. */
135
136int return_label_execution_count;
137
138/* Collect statistics on the performance of this pass for the entire source
139 file. */
140
141static int total_num_blocks;
142static int total_num_arcs;
143static int total_num_arcs_instrumented;
144static int total_num_blocks_created;
145static int total_num_passes;
146static int total_num_times_called;
147static int total_hist_br_prob[20];
148static int total_num_never_executed;
149static int total_num_branches;
150
151/* Forward declarations. */
152static void init_arc PROTO((struct adj_list *, int, int, rtx));
153static void find_spanning_tree PROTO((int));
154static void expand_spanning_tree PROTO((int));
155static void fill_spanning_tree PROTO((int));
156static void init_arc_profiler PROTO((void));
157static void output_arc_profiler PROTO((int, rtx));
158
159#ifndef LONG_TYPE_SIZE
160#define LONG_TYPE_SIZE BITS_PER_WORD
161#endif
162
163/* If non-zero, we need to output a constructor to set up the
164 per-object-file data. */
165static int need_func_profiler = 0;
166
167
168/* Add arc instrumentation code to the entire insn chain.
169
170 F is the first insn of the chain.
171 NUM_BLOCKS is the number of basic blocks found in F.
172 DUMP_FILE, if nonzero, is an rtl dump file we can write to. */
173
174static void
175instrument_arcs (f, num_blocks, dump_file)
176 rtx f;
177 int num_blocks;
178 FILE *dump_file;
179{
180 register int i;
181 register struct adj_list *arcptr, *backptr;
182 int num_arcs = 0;
183 int num_instr_arcs = 0;
184 rtx insn;
185
186 /* Instrument the program start. */
187 /* Handle block 0 specially, since it will always be instrumented,
188 but it doesn't have a valid first_insn or branch_insn. We must
189 put the instructions before the NOTE_INSN_FUNCTION_BEG note, so
190 that they don't clobber any of the parameters of the current
191 function. */
192 for (insn = f; insn; insn = NEXT_INSN (insn))
193 if (GET_CODE (insn) == NOTE
194 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
195 break;
196 insn = PREV_INSN (insn);
197 need_func_profiler = 1;
198 output_arc_profiler (total_num_arcs_instrumented + num_instr_arcs++, insn);
199
200 for (i = 1; i < num_blocks; i++)
201 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
202 if (! arcptr->on_tree)
203 {
204 if (dump_file)
205 fprintf (dump_file, "Arc %d to %d instrumented\n", i,
206 ARC_TARGET (arcptr));
207
208 /* Check to see if this arc is the only exit from its source block,
209 or the only entrance to its target block. In either case,
210 we don't need to create a new block to instrument the arc. */
211
212 if (bb_graph[i].succ == arcptr && arcptr->succ_next == 0)
213 {
214 /* Instrument the source block. */
215 output_arc_profiler (total_num_arcs_instrumented
216 + num_instr_arcs++,
217 PREV_INSN (bb_graph[i].first_insn));
218 }
219 else if (arcptr == bb_graph[ARC_TARGET (arcptr)].pred
220 && arcptr->pred_next == 0)
221 {
222 /* Instrument the target block. */
223 output_arc_profiler (total_num_arcs_instrumented
224 + num_instr_arcs++,
225 PREV_INSN (bb_graph[ARC_TARGET (arcptr)].first_insn));
226 }
227 else if (arcptr->fall_through)
228 {
229 /* This is a fall-through; put the instrumentation code after
230 the branch that ends this block. */
231
232 for (backptr = bb_graph[i].succ; backptr;
233 backptr = backptr->succ_next)
234 if (backptr != arcptr)
235 break;
236
237 output_arc_profiler (total_num_arcs_instrumented
238 + num_instr_arcs++,
239 backptr->branch_insn);
240 }
241 else
242 {
243 /* Must emit a new basic block to hold the arc counting code. */
244 enum rtx_code code = GET_CODE (PATTERN (arcptr->branch_insn));
245
246 if (code == SET)
247 {
248 /* Create the new basic block right after the branch.
249 Invert the branch so that it jumps past the end of the new
250 block. The new block will consist of the instrumentation
251 code, and a jump to the target of this arc. */
252 int this_is_simplejump = simplejump_p (arcptr->branch_insn);
253 rtx new_label = gen_label_rtx ();
254 rtx old_label, set_src;
255 rtx after = arcptr->branch_insn;
256
257 /* Simplejumps can't reach here. */
258 if (this_is_simplejump)
259 abort ();
260
261 /* We can't use JUMP_LABEL, because it won't be set if we
262 are compiling without optimization. */
263
264 set_src = SET_SRC (single_set (arcptr->branch_insn));
265 if (GET_CODE (set_src) == LABEL_REF)
266 old_label = set_src;
267 else if (GET_CODE (set_src) != IF_THEN_ELSE)
268 abort ();
269 else if (XEXP (set_src, 1) == pc_rtx)
270 old_label = XEXP (XEXP (set_src, 2), 0);
271 else
272 old_label = XEXP (XEXP (set_src, 1), 0);
273
274 /* Set the JUMP_LABEL so that redirect_jump will work. */
275 JUMP_LABEL (arcptr->branch_insn) = old_label;
276
277 /* Add a use for OLD_LABEL that will be needed when we emit
278 the JUMP_INSN below. If we don't do this here,
279 `invert_jump' might delete it for us. We must add two
280 when not optimizing, because the NUSES is zero now,
281 but must be at least two to prevent the label from being
282 deleted. */
283 LABEL_NUSES (old_label) += 2;
284
285 /* Emit the insns for the new block in reverse order,
286 since that is most convenient. */
287
288 if (this_is_simplejump)
289 {
290 after = NEXT_INSN (arcptr->branch_insn);
291 if (! redirect_jump (arcptr->branch_insn, new_label))
292 /* Don't know what to do if this branch won't
293 redirect. */
294 abort ();
295 }
296 else
297 {
298 if (! invert_jump (arcptr->branch_insn, new_label))
299 /* Don't know what to do if this branch won't invert. */
300 abort ();
301
302 emit_label_after (new_label, after);
303 LABEL_NUSES (new_label)++;
304 }
305 emit_barrier_after (after);
306 emit_jump_insn_after (gen_jump (old_label), after);
307 JUMP_LABEL (NEXT_INSN (after)) = old_label;
308
309 /* Instrument the source arc. */
310 output_arc_profiler (total_num_arcs_instrumented
311 + num_instr_arcs++,
312 after);
313 if (this_is_simplejump)
314 {
315 emit_label_after (new_label, after);
316 LABEL_NUSES (new_label)++;
317 }
318 }
319 else if (code == ADDR_VEC || code == ADDR_DIFF_VEC)
320 {
321 /* A table jump. Create a new basic block immediately
322 after the table, by emitting a barrier, a label, a
323 counting note, and a jump to the old label. Put the
324 new label in the table. */
325
326 rtx new_label = gen_label_rtx ();
327 rtx old_lref, new_lref;
328 int index;
329
330 /* Must determine the old_label reference, do this
331 by counting the arcs after this one, which will
332 give the index of our label in the table. */
333
334 index = 0;
335 for (backptr = arcptr->succ_next; backptr;
336 backptr = backptr->succ_next)
337 index++;
338
339 old_lref = XVECEXP (PATTERN (arcptr->branch_insn),
340 (code == ADDR_DIFF_VEC), index);
341
342 /* Emit the insns for the new block in reverse order,
343 since that is most convenient. */
344 emit_jump_insn_after (gen_jump (XEXP (old_lref, 0)),
345 arcptr->branch_insn);
346 JUMP_LABEL (NEXT_INSN (arcptr->branch_insn))
347 = XEXP (old_lref, 0);
348
349 /* Instrument the source arc. */
350 output_arc_profiler (total_num_arcs_instrumented
351 + num_instr_arcs++,
352 arcptr->branch_insn);
353
354 emit_label_after (new_label, arcptr->branch_insn);
355 LABEL_NUSES (NEXT_INSN (arcptr->branch_insn))++;
356 emit_barrier_after (arcptr->branch_insn);
357
358 /* Fix up the table jump. */
359 new_lref = gen_rtx_LABEL_REF (Pmode, new_label);
360 XVECEXP (PATTERN (arcptr->branch_insn),
361 (code == ADDR_DIFF_VEC), index) = new_lref;
362 }
363 else
364 abort ();
365
366 num_arcs += 1;
367 if (dump_file)
368 fprintf (dump_file,
369 "Arc %d to %d needed new basic block\n", i,
370 ARC_TARGET (arcptr));
371 }
372 }
373
374 total_num_arcs_instrumented += num_instr_arcs;
375 count_instrumented_arcs = total_num_arcs_instrumented;
376
377 total_num_blocks_created += num_arcs;
378 if (dump_file)
379 {
380 fprintf (dump_file, "%d arcs instrumented\n", num_instr_arcs);
381 fprintf (dump_file, "%d extra basic blocks created\n", num_arcs);
382 }
383}
384
385/* Output STRING to bb_file, surrounded by DELIMITER. */
386
387static void
388output_gcov_string (string, delimiter)
389 char *string;
390 long delimiter;
391{
392 long temp;
393
394 /* Write a delimiter to indicate that a file name follows. */
395 __write_long (delimiter, bb_file, 4);
396
397 /* Write the string. */
398 temp = strlen (string) + 1;
399 fwrite (string, temp, 1, bb_file);
400
401 /* Append a few zeros, to align the output to a 4 byte boundary. */
402 temp = temp & 0x3;
403 if (temp)
404 {
405 char c[4];
406
407 c[0] = c[1] = c[2] = c[3] = 0;
408 fwrite (c, sizeof (char), 4 - temp, bb_file);
409 }
410
411 /* Store another delimiter in the .bb file, just to make it easy to find the
412 end of the file name. */
413 __write_long (delimiter, bb_file, 4);
414}
415
416/* Return TRUE if this insn must be a tablejump entry insn. This works for
417 the MIPS port, but may give false negatives for some targets. */
418
419int
420tablejump_entry_p (insn, label)
421 rtx insn, label;
422{
423 rtx next = next_active_insn (insn);
424 enum rtx_code code = GET_CODE (PATTERN (next));
425
426 if (code != ADDR_DIFF_VEC && code != ADDR_VEC)
427 return 0;
428
429 if (PREV_INSN (next) == XEXP (label, 0))
430 return 1;
431
432 return 0;
433}
434
435/* Instrument and/or analyze program behavior based on program flow graph.
436 In either case, this function builds a flow graph for the function being
437 compiled. The flow graph is stored in BB_GRAPH.
438
439 When FLAG_PROFILE_ARCS is nonzero, this function instruments the arcs in
440 the flow graph that are needed to reconstruct the dynamic behavior of the
441 flow graph.
442
443 When FLAG_BRANCH_PROBABILITIES is nonzero, this function reads auxiliary
444 information from a data file containing arc count information from previous
445 executions of the function being compiled. In this case, the flow graph is
446 annotated with actual execution counts, which are later propagated into the
447 rtl for optimization purposes.
448
449 Main entry point of this file. */
450
451void
452branch_prob (f, dump_file)
453 rtx f;
454 FILE *dump_file;
455{
456 int i, num_blocks;
457 struct adj_list *arcptr;
458 int num_arcs, changes, passes;
459 int total, prob;
460 int hist_br_prob[20], num_never_executed, num_branches;
461 /* Set to non-zero if we got bad count information. */
462 int bad_counts = 0;
463
464 /* start of a function. */
465 if (flag_test_coverage)
466 output_gcov_string (current_function_name, (long) -2);
467
468 /* Execute this only if doing arc profiling or branch probabilities. */
469 if (! profile_arc_flag && ! flag_branch_probabilities
470 && ! flag_test_coverage)
471 abort ();
472
473 total_num_times_called++;
474
475 /* Create an array label_to_bb of ints of size max_label_num. */
476 label_to_bb_size = max_label_num ();
477 label_to_bb = (int *) oballoc (label_to_bb_size * sizeof (int));
478 bzero ((char *) label_to_bb, label_to_bb_size * sizeof (int));
479
480 /* Scan the insns in the function, count the number of basic blocks
481 present. When a code label is passed, set label_to_bb[label] = bb
482 number. */
483
484 /* The first block found will be block 1, so that function entry can be
485 block 0. */
486
487 {
488 register RTX_CODE prev_code = JUMP_INSN;
489 register RTX_CODE code;
490 register rtx insn;
491 register int i;
492 int block_separator_emitted = 0;
493
494 ignore_next_note = 0;
495
496 for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
497 {
498 code = GET_CODE (insn);
499
500 if (code == BARRIER)
501 ;
502 else if (code == CODE_LABEL)
503 /* This label is part of the next block, but we can't increment
504 block number yet since there might be multiple labels. */
505 label_to_bb[CODE_LABEL_NUMBER (insn)] = i + 1;
506 /* We make NOTE_INSN_SETJMP notes into a block of their own, so that
507 they can be the target of the fake arc for the setjmp call.
508 This avoids creating cycles of fake arcs, which would happen if
509 the block after the setjmp call contained a call insn. */
510 else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
511 || prev_code == CODE_LABEL || prev_code == BARRIER)
512 && (GET_RTX_CLASS (code) == 'i'
513 || (code == NOTE
514 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
515 {
516 i += 1;
517
518 /* Emit the block separator if it hasn't already been emitted. */
519 if (flag_test_coverage && ! block_separator_emitted)
520 {
521 /* Output a zero to the .bb file to indicate that a new
522 block list is starting. */
523 __write_long (0, bb_file, 4);
524 }
525 block_separator_emitted = 0;
526 }
527 /* If flag_test_coverage is true, then we must add an entry to the
528 .bb file for every note. */
529 else if (code == NOTE && flag_test_coverage)
530 {
531 /* Must ignore the line number notes that immediately follow the
532 end of an inline function to avoid counting it twice. There
533 is a note before the call, and one after the call. */
534 if (NOTE_LINE_NUMBER (insn) == NOTE_REPEATED_LINE_NUMBER)
535 ignore_next_note = 1;
536 else if (NOTE_LINE_NUMBER (insn) > 0)
537 {
538 if (ignore_next_note)
539 ignore_next_note = 0;
540 else
541 {
542 /* Emit a block separator here to ensure that a NOTE
543 immediately following a JUMP_INSN or CALL_INSN will end
544 up in the right basic block list. */
545 if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
546 || prev_code == CODE_LABEL || prev_code == BARRIER)
547 && ! block_separator_emitted)
548 {
549 /* Output a zero to the .bb file to indicate that
550 a new block list is starting. */
551 __write_long (0, bb_file, 4);
552
553 block_separator_emitted = 1;
554 }
555
556 /* If this is a new source file, then output the file's
557 name to the .bb file. */
558 if (! last_bb_file_name
559 || strcmp (NOTE_SOURCE_FILE (insn),
560 last_bb_file_name))
561 {
562 if (last_bb_file_name)
563 free (last_bb_file_name);
564 last_bb_file_name
565 = xmalloc (strlen (NOTE_SOURCE_FILE (insn)) + 1);
566 strcpy (last_bb_file_name, NOTE_SOURCE_FILE (insn));
567 output_gcov_string (NOTE_SOURCE_FILE (insn), (long)-1);
568 }
569
570 /* Output the line number to the .bb file. Must be done
571 after the output_bb_profile_data() call, and after the
572 file name is written, to ensure that it is correctly
573 handled by gcov. */
574 __write_long (NOTE_LINE_NUMBER (insn), bb_file, 4);
575 }
576 }
577 }
578
579 if (code != NOTE)
580 prev_code = code;
581 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
582 prev_code = CALL_INSN;
583 }
584
585 /* Allocate last `normal' entry for bb_graph. */
586
587 /* The last insn was a jump, call, or label. In that case we have
588 a block at the end of the function with no insns. */
589 if (prev_code == JUMP_INSN || prev_code == CALL_INSN
590 || prev_code == CODE_LABEL || prev_code == BARRIER)
591 {
592 i++;
593
594 /* Emit the block separator if it hasn't already been emitted. */
595 if (flag_test_coverage && ! block_separator_emitted)
596 {
597 /* Output a zero to the .bb file to indicate that a new
598 block list is starting. */
599 __write_long (0, bb_file, 4);
600 }
601 }
602
603 /* Create another block to stand for EXIT, and make all return insns, and
604 the last basic block point here. Add one more to account for block
605 zero. */
606 num_blocks = i + 2;
607 }
608
609 total_num_blocks += num_blocks;
610 if (dump_file)
611 fprintf (dump_file, "%d basic blocks\n", num_blocks);
612
613 /* If we are only doing test coverage here, then return now. */
614 if (! profile_arc_flag && ! flag_branch_probabilities)
615 return;
616
617 /* Create and initialize the arrays that will hold bb_graph
618 and execution count info. */
619
620 bb_graph = (struct bb_info *) alloca (num_blocks * sizeof (struct bb_info));
621 bzero ((char *) bb_graph, (sizeof (struct bb_info) * num_blocks));
622
623 {
624 /* Scan the insns again:
625 - at the entry to each basic block, increment the predecessor count
626 (and successor of previous block) if it is a fall through entry,
627 create adj_list entries for this and the previous block
628 - at each jump insn, increment predecessor/successor counts for
629 target/source basic blocks, add this insn to pred/succ lists.
630
631 This also cannot be broken out as a separate subroutine
632 because it uses `alloca'. */
633
634 register RTX_CODE prev_code = JUMP_INSN;
635 register RTX_CODE code;
636 register rtx insn;
637 register int i;
638 int fall_through = 0;
639 struct adj_list *arcptr;
640 int dest = 0;
641
642 /* Block 0 always falls through to block 1. */
643 num_arcs = 0;
644 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
645 init_arc (arcptr, 0, 1, 0);
646 arcptr->fall_through = 1;
647 num_arcs++;
648
649 /* Add a fake fall through arc from the last block to block 0, to make the
650 graph complete. */
651 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
652 init_arc (arcptr, num_blocks - 1, 0, 0);
653 arcptr->fake = 1;
654 num_arcs++;
655
656 /* Exit must be one node of the graph, and all exits from the function
657 must point there. When see a return branch, must point the arc to the
658 exit node. */
659
660 /* Must start scan with second insn in function as above. */
661 for (insn = NEXT_INSN (f), i = 0; insn; insn = NEXT_INSN (insn))
662 {
663 code = GET_CODE (insn);
664
665 if (code == BARRIER)
666 fall_through = 0;
667 else if (code == CODE_LABEL)
668 ;
669 /* We make NOTE_INSN_SETJMP notes into a block of their own, so that
670 they can be the target of the fake arc for the setjmp call.
671 This avoids creating cycles of fake arcs, which would happen if
672 the block after the setjmp call ended with a call. */
673 else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
674 || prev_code == CODE_LABEL || prev_code == BARRIER)
675 && (GET_RTX_CLASS (code) == 'i'
676 || (code == NOTE
677 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
678 {
679 /* This is the first insn of the block. */
680 i += 1;
681 if (fall_through)
682 {
683 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
684 init_arc (arcptr, i - 1, i, 0);
685 arcptr->fall_through = 1;
686
687 num_arcs++;
688 }
689 fall_through = 1;
690 bb_graph[i].first_insn = insn;
691 }
692 else if (code == NOTE)
693 {;}
694
695 if (code == CALL_INSN)
696 {
697 /* In the normal case, the call returns, and this is just like
698 a branch fall through. */
699 fall_through = 1;
700
701 /* Setjmp may return more times than called, so to make the graph
702 solvable, add a fake arc from the function entrance to the
703 next block.
704
705 All other functions may return fewer times than called (if
706 a descendent call longjmp or exit), so to make the graph
707 solvable, add a fake arc to the function exit from the
708 current block.
709
710 Distinguish the cases by checking for a SETJUMP note.
711 A call_insn can be the last ins of a function, so must check
712 to see if next insn actually exists. */
713 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
714 if (NEXT_INSN (insn)
715 && GET_CODE (NEXT_INSN (insn)) == NOTE
716 && NOTE_LINE_NUMBER (NEXT_INSN (insn)) == NOTE_INSN_SETJMP)
717 init_arc (arcptr, 0, i+1, insn);
718 else
719 init_arc (arcptr, i, num_blocks-1, insn);
720 arcptr->fake = 1;
721 num_arcs++;
722 }
723 else if (code == JUMP_INSN)
724 {
725 rtx tem, pattern = PATTERN (insn);
726 rtx tablejump = 0;
727
728 /* If running without optimization, then jump label won't be valid,
729 so we must search for the destination label in that case.
730 We have to handle tablejumps and returns specially anyways, so
731 we don't check the JUMP_LABEL at all here. */
732
733 /* ??? This code should be rewritten. We need a more elegant way
734 to find the LABEL_REF. We need a more elegant way to
735 differentiate tablejump entries from computed gotos.
736 We should perhaps reuse code from flow to compute the CFG
737 instead of trying to compute it here.
738
739 We can't use current_function_has_computed_jump, because that
740 is calculated later by flow. We can't use computed_jump_p,
741 because that returns true for tablejump entry insns for some
742 targets, e.g. HPPA and MIPS. */
743
744 if (GET_CODE (pattern) == PARALLEL)
745 {
746 /* This assumes that PARALLEL jumps with a USE are
747 tablejump entry jumps. The same assumption can be found
748 in computed_jump_p. */
749 /* Make an arc from this jump to the label of the
750 jump table. This will instrument the number of
751 times the switch statement is executed. */
752 if (GET_CODE (XVECEXP (pattern, 0, 1)) == USE)
753 {
754 tem = XEXP (XVECEXP (pattern, 0, 1), 0);
755 if (GET_CODE (tem) != LABEL_REF)
756 abort ();
757 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
758 }
759 else if (GET_CODE (XVECEXP (pattern, 0, 0)) == SET
760 && SET_DEST (XVECEXP (pattern, 0, 0)) == pc_rtx)
761 {
762 tem = SET_SRC (XVECEXP (pattern, 0, 0));
763 if (GET_CODE (tem) == PLUS
764 && GET_CODE (XEXP (tem, 1)) == LABEL_REF)
765 {
766 tem = XEXP (tem, 1);
767 dest = label_to_bb [CODE_LABEL_NUMBER (XEXP (tem, 0))];
768 }
769 }
770 else
771 abort ();
772 }
773 else if (GET_CODE (pattern) == ADDR_VEC
774 || GET_CODE (pattern) == ADDR_DIFF_VEC)
775 tablejump = pattern;
776 else if (GET_CODE (pattern) == RETURN)
777 dest = num_blocks - 1;
778 else if (GET_CODE (pattern) != SET)
779 abort ();
780 else if ((tem = SET_SRC (pattern))
781 && GET_CODE (tem) == LABEL_REF)
782 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (tem, 0))];
783 /* Recognize HPPA table jump entry. This code is similar to
784 the code above in the PARALLEL case. */
785 else if (GET_CODE (tem) == PLUS
786 && GET_CODE (XEXP (tem, 0)) == MEM
787 && GET_CODE (XEXP (XEXP (tem, 0), 0)) == PLUS
788 && GET_CODE (XEXP (XEXP (XEXP (tem, 0), 0), 0)) == PC
789 && GET_CODE (XEXP (tem, 1)) == LABEL_REF
790 && tablejump_entry_p (insn, XEXP (tem, 1)))
791 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
792 /* Recognize the MIPS table jump entry. */
793 else if (GET_CODE (tem) == PLUS
794 && GET_CODE (XEXP (tem, 0)) == REG
795 && GET_CODE (XEXP (tem, 1)) == LABEL_REF
796 && tablejump_entry_p (insn, XEXP (tem, 1)))
797 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (XEXP (tem, 1), 0))];
798 else
799 {
800 rtx label_ref;
801
802 /* Must be an IF_THEN_ELSE branch. If it isn't, assume it
803 is a computed goto, which aren't supported yet. */
804 if (GET_CODE (tem) != IF_THEN_ELSE)
805 fatal ("-fprofile-arcs does not support computed gotos");
806 if (XEXP (tem, 1) != pc_rtx)
807 label_ref = XEXP (tem, 1);
808 else
809 label_ref = XEXP (tem, 2);
810 dest = label_to_bb[CODE_LABEL_NUMBER (XEXP (label_ref, 0))];
811 }
812
813 if (tablejump)
814 {
815 int diff_vec_p = GET_CODE (tablejump) == ADDR_DIFF_VEC;
816 int len = XVECLEN (tablejump, diff_vec_p);
817 int k;
818
819 for (k = 0; k < len; k++)
820 {
821 rtx tem = XEXP (XVECEXP (tablejump, diff_vec_p, k), 0);
822 dest = label_to_bb[CODE_LABEL_NUMBER (tem)];
823
824 arcptr = (struct adj_list *) alloca (sizeof(struct adj_list));
825 init_arc (arcptr, i, dest, insn);
826
827 num_arcs++;
828 }
829 }
830 else
831 {
832 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
833 init_arc (arcptr, i, dest, insn);
834
835 num_arcs++;
836 }
837
838 /* Determine whether or not this jump will fall through.
839 Unconditional jumps and returns are not always followed by
840 barriers. */
841 pattern = PATTERN (insn);
842 if (GET_CODE (pattern) == PARALLEL
843 || GET_CODE (pattern) == RETURN)
844 fall_through = 0;
845 else if (GET_CODE (pattern) == ADDR_VEC
846 || GET_CODE (pattern) == ADDR_DIFF_VEC)
847 /* These aren't actually jump insns, but they never fall
848 through, so... */
849 fall_through = 0;
850 else
851 {
852 if (GET_CODE (pattern) != SET || SET_DEST (pattern) != pc_rtx)
853 abort ();
854 if (GET_CODE (SET_SRC (pattern)) != IF_THEN_ELSE)
855 fall_through = 0;
856 }
857 }
858
859 if (code != NOTE)
860 prev_code = code;
861 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)
862 {
863 /* Make a fake insn to tag our notes on. */
864 bb_graph[i].first_insn = insn
865 = emit_insn_after (gen_rtx_USE (VOIDmode, stack_pointer_rtx),
866 insn);
867 prev_code = CALL_INSN;
868 }
869 }
870
871 /* If the code at the end of the function would give a new block, then
872 do the following. */
873
874 if (prev_code == JUMP_INSN || prev_code == CALL_INSN
875 || prev_code == CODE_LABEL || prev_code == BARRIER)
876 {
877 if (fall_through)
878 {
879 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
880 init_arc (arcptr, i, i + 1, 0);
881 arcptr->fall_through = 1;
882
883 num_arcs++;
884 }
885
886 /* This may not be a real insn, but that should not cause a problem. */
887 bb_graph[i+1].first_insn = get_last_insn ();
888 }
889
890 /* There is always a fake arc from the last block of the function
891 to the function exit block. */
892 arcptr = (struct adj_list *) alloca (sizeof (struct adj_list));
893 init_arc (arcptr, num_blocks-2, num_blocks-1, 0);
894 arcptr->fake = 1;
895 num_arcs++;
896 }
897
898 total_num_arcs += num_arcs;
899 if (dump_file)
900 fprintf (dump_file, "%d arcs\n", num_arcs);
901
902 /* Create spanning tree from basic block graph, mark each arc that is
903 on the spanning tree. */
904
905 /* To reduce the instrumentation cost, make two passes over the tree.
906 First, put as many must-split (crowded and fake) arcs on the tree as
907 possible, then on the second pass fill in the rest of the tree.
908 Note that the spanning tree is considered undirected, so that as many
909 must-split arcs as possible can be put on it.
910
911 Fallthrough arcs which are crowded should not be chosen on the first
912 pass, since they do not require creating a new basic block. These
913 arcs will have fall_through set. */
914
915 find_spanning_tree (num_blocks);
916
917 /* Create a .bbg file from which gcov can reconstruct the basic block
918 graph. First output the number of basic blocks, and then for every
919 arc output the source and target basic block numbers.
920 NOTE: The format of this file must be compatible with gcov. */
921
922 if (flag_test_coverage)
923 {
924 int flag_bits;
925
926 __write_long (num_blocks, bbg_file, 4);
927 __write_long (num_arcs, bbg_file, 4);
928
929 for (i = 0; i < num_blocks; i++)
930 {
931 long count = 0;
932 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
933 count++;
934 __write_long (count, bbg_file, 4);
935
936 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
937 {
938 flag_bits = 0;
939 if (arcptr->on_tree)
940 flag_bits |= 0x1;
941 if (arcptr->fake)
942 flag_bits |= 0x2;
943 if (arcptr->fall_through)
944 flag_bits |= 0x4;
945
946 __write_long (ARC_TARGET (arcptr), bbg_file, 4);
947 __write_long (flag_bits, bbg_file, 4);
948 }
949 }
950
951 /* Emit a -1 to separate the list of all arcs from the list of
952 loop back edges that follows. */
953 __write_long (-1, bbg_file, 4);
954 }
955
956 /* For each arc not on the spanning tree, add counting code as rtl. */
957
958 if (profile_arc_flag)
959 {
960 instrument_arcs (f, num_blocks, dump_file);
961 allocate_reg_info (max_reg_num (), FALSE, FALSE);
962 }
963
964 /* Execute the rest only if doing branch probabilities. */
965 if (! flag_branch_probabilities)
966 return;
967
968 /* For each arc not on the spanning tree, set its execution count from
969 the .da file. */
970
971 /* The first count in the .da file is the number of times that the function
972 was entered. This is the exec_count for block zero. */
973
974 num_arcs = 0;
975 for (i = 0; i < num_blocks; i++)
976 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
977 if (! arcptr->on_tree)
978 {
979 num_arcs++;
980 if (da_file)
981 {
982 long value;
983 __read_long (&value, da_file, 8);
984 ARC_COUNT (arcptr) = value;
985 }
986 else
987 ARC_COUNT (arcptr) = 0;
988 arcptr->count_valid = 1;
989 bb_graph[i].succ_count--;
990 bb_graph[ARC_TARGET (arcptr)].pred_count--;
991 }
992
993 if (dump_file)
994 fprintf (dump_file, "%d arc counts read\n", num_arcs);
995
996 /* For every block in the file,
997 - if every exit/entrance arc has a known count, then set the block count
998 - if the block count is known, and every exit/entrance arc but one has
999 a known execution count, then set the count of the remaining arc
1000
1001 As arc counts are set, decrement the succ/pred count, but don't delete
1002 the arc, that way we can easily tell when all arcs are known, or only
1003 one arc is unknown. */
1004
1005 /* The order that the basic blocks are iterated through is important.
1006 Since the code that finds spanning trees starts with block 0, low numbered
1007 arcs are put on the spanning tree in preference to high numbered arcs.
1008 Hence, most instrumented arcs are at the end. Graph solving works much
1009 faster if we propagate numbers from the end to the start.
1010
1011 This takes an average of slightly more than 3 passes. */
1012
1013 changes = 1;
1014 passes = 0;
1015 while (changes)
1016 {
1017 passes++;
1018 changes = 0;
1019
1020 for (i = num_blocks - 1; i >= 0; i--)
1021 {
1022 struct bb_info *binfo = &bb_graph[i];
1023 if (! binfo->count_valid)
1024 {
1025 if (binfo->succ_count == 0)
1026 {
1027 total = 0;
1028 for (arcptr = binfo->succ; arcptr;
1029 arcptr = arcptr->succ_next)
1030 total += ARC_COUNT (arcptr);
1031 binfo->exec_count = total;
1032 binfo->count_valid = 1;
1033 changes = 1;
1034 }
1035 else if (binfo->pred_count == 0)
1036 {
1037 total = 0;
1038 for (arcptr = binfo->pred; arcptr;
1039 arcptr = arcptr->pred_next)
1040 total += ARC_COUNT (arcptr);
1041 binfo->exec_count = total;
1042 binfo->count_valid = 1;
1043 changes = 1;
1044 }
1045 }
1046 if (binfo->count_valid)
1047 {
1048 if (binfo->succ_count == 1)
1049 {
1050 total = 0;
1051 /* One of the counts will be invalid, but it is zero,
1052 so adding it in also doesn't hurt. */
1053 for (arcptr = binfo->succ; arcptr;
1054 arcptr = arcptr->succ_next)
1055 total += ARC_COUNT (arcptr);
1056 /* Calculate count for remaining arc by conservation. */
1057 total = binfo->exec_count - total;
1058 /* Search for the invalid arc, and set its count. */
1059 for (arcptr = binfo->succ; arcptr;
1060 arcptr = arcptr->succ_next)
1061 if (! arcptr->count_valid)
1062 break;
1063 if (! arcptr)
1064 abort ();
1065 arcptr->count_valid = 1;
1066 ARC_COUNT (arcptr) = total;
1067 binfo->succ_count--;
1068
1069 bb_graph[ARC_TARGET (arcptr)].pred_count--;
1070 changes = 1;
1071 }
1072 if (binfo->pred_count == 1)
1073 {
1074 total = 0;
1075 /* One of the counts will be invalid, but it is zero,
1076 so adding it in also doesn't hurt. */
1077 for (arcptr = binfo->pred; arcptr;
1078 arcptr = arcptr->pred_next)
1079 total += ARC_COUNT (arcptr);
1080 /* Calculate count for remaining arc by conservation. */
1081 total = binfo->exec_count - total;
1082 /* Search for the invalid arc, and set its count. */
1083 for (arcptr = binfo->pred; arcptr;
1084 arcptr = arcptr->pred_next)
1085 if (! arcptr->count_valid)
1086 break;
1087 if (! arcptr)
1088 abort ();
1089 arcptr->count_valid = 1;
1090 ARC_COUNT (arcptr) = total;
1091 binfo->pred_count--;
1092
1093 bb_graph[ARC_SOURCE (arcptr)].succ_count--;
1094 changes = 1;
1095 }
1096 }
1097 }
1098 }
1099
1100 total_num_passes += passes;
1101 if (dump_file)
1102 fprintf (dump_file, "Graph solving took %d passes.\n\n", passes);
1103
1104 /* If the graph has been correctly solved, every block will have a
1105 succ and pred count of zero. */
1106 for (i = 0; i < num_blocks; i++)
1107 {
1108 struct bb_info *binfo = &bb_graph[i];
1109 if (binfo->succ_count || binfo->pred_count)
1110 abort ();
1111 }
1112
1113 /* For every arc, calculate its branch probability and add a reg_note
1114 to the branch insn to indicate this. */
1115
1116 for (i = 0; i < 20; i++)
1117 hist_br_prob[i] = 0;
1118 num_never_executed = 0;
1119 num_branches = 0;
1120
1121 for (i = 0; i < num_blocks; i++)
1122 {
1123 struct bb_info *binfo = &bb_graph[i];
1124
1125 total = binfo->exec_count;
1126 for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
1127 {
1128 if (arcptr->branch_insn)
1129 {
1130 /* This calculates the branch probability as an integer between
1131 0 and REG_BR_PROB_BASE, properly rounded to the nearest
1132 integer. Perform the arithmetic in double to avoid
1133 overflowing the range of ints. */
1134
1135 if (total == 0)
1136 prob = -1;
1137 else
1138 {
1139 rtx pat = PATTERN (arcptr->branch_insn);
1140
1141 prob = (((double)ARC_COUNT (arcptr) * REG_BR_PROB_BASE)
1142 + (total >> 1)) / total;
1143 if (prob < 0 || prob > REG_BR_PROB_BASE)
1144 {
1145 if (dump_file)
1146 fprintf (dump_file, "bad count: prob for %d-%d thought to be %d (forcibly normalized)\n",
1147 ARC_SOURCE (arcptr), ARC_TARGET (arcptr),
1148 prob);
1149
1150 bad_counts = 1;
1151 prob = REG_BR_PROB_BASE / 2;
1152 }
1153
1154 /* Match up probability with JUMP pattern. */
1155
1156 if (GET_CODE (pat) == SET
1157 && GET_CODE (SET_SRC (pat)) == IF_THEN_ELSE)
1158 {
1159 if (ARC_TARGET (arcptr) == ARC_SOURCE (arcptr) + 1)
1160 {
1161 /* A fall through arc should never have a
1162 branch insn. */
1163 abort ();
1164 }
1165 else
1166 {
1167 /* This is the arc for the taken branch. */
1168 if (GET_CODE (XEXP (SET_SRC (pat), 2)) != PC)
1169 prob = REG_BR_PROB_BASE - prob;
1170 }
1171 }
1172 }
1173
1174 if (prob == -1)
1175 num_never_executed++;
1176 else
1177 {
1178 int index = prob * 20 / REG_BR_PROB_BASE;
1179 if (index == 20)
1180 index = 19;
1181 hist_br_prob[index]++;
1182 }
1183 num_branches++;
1184
1185 REG_NOTES (arcptr->branch_insn)
1186 = gen_rtx_EXPR_LIST (REG_BR_PROB, GEN_INT (prob),
1187 REG_NOTES (arcptr->branch_insn));
1188 }
1189 }
1190
1191 /* Add a REG_EXEC_COUNT note to the first instruction of this block. */
1192 if (! binfo->first_insn
1193 || GET_RTX_CLASS (GET_CODE (binfo->first_insn)) != 'i')
1194 {
1195 /* Block 0 is a fake block representing function entry, and does
1196 not have a real first insn. The second last block might not
1197 begin with a real insn. */
1198 if (i == num_blocks - 1)
1199 return_label_execution_count = total;
1200 else if (i != 0 && i != num_blocks - 2)
1201 abort ();
1202 }
1203 else
1204 {
1205 REG_NOTES (binfo->first_insn)
1206 = gen_rtx_EXPR_LIST (REG_EXEC_COUNT, GEN_INT (total),
1207 REG_NOTES (binfo->first_insn));
1208 if (i == num_blocks - 1)
1209 return_label_execution_count = total;
1210 }
1211 }
1212
1213 /* This should never happen. */
1214 if (bad_counts)
1215 warning ("Arc profiling: some arc counts were bad.");
1216
1217 if (dump_file)
1218 {
1219 fprintf (dump_file, "%d branches\n", num_branches);
1220 fprintf (dump_file, "%d branches never executed\n",
1221 num_never_executed);
1222 if (num_branches)
1223 for (i = 0; i < 10; i++)
1224 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1225 (hist_br_prob[i]+hist_br_prob[19-i])*100/num_branches,
1226 5*i, 5*i+5);
1227
1228 total_num_branches += num_branches;
1229 total_num_never_executed += num_never_executed;
1230 for (i = 0; i < 20; i++)
1231 total_hist_br_prob[i] += hist_br_prob[i];
1232 }
1233
1234}
1235
1236/* Initialize a new arc.
1237 ARCPTR is the empty adj_list this function fills in.
1238 SOURCE is the block number of the source block.
1239 TARGET is the block number of the target block.
1240 INSN is the insn which transfers control from SOURCE to TARGET,
1241 or zero if the transfer is implicit. */
1242
1243static void
1244init_arc (arcptr, source, target, insn)
1245 struct adj_list *arcptr;
1246 int source, target;
1247 rtx insn;
1248{
1249 ARC_TARGET (arcptr) = target;
1250 ARC_SOURCE (arcptr) = source;
1251
1252 ARC_COUNT (arcptr) = 0;
1253 arcptr->count_valid = 0;
1254 arcptr->on_tree = 0;
1255 arcptr->fake = 0;
1256 arcptr->fall_through = 0;
1257 arcptr->branch_insn = insn;
1258
1259 arcptr->succ_next = bb_graph[source].succ;
1260 bb_graph[source].succ = arcptr;
1261 bb_graph[source].succ_count++;
1262
1263 arcptr->pred_next = bb_graph[target].pred;
1264 bb_graph[target].pred = arcptr;
1265 bb_graph[target].pred_count++;
1266}
1267
1268/* This function searches all of the arcs in the program flow graph, and puts
1269 as many bad arcs as possible onto the spanning tree. Bad arcs include
1270 fake arcs (needed for setjmp(), longjmp(), exit()) which MUST be on the
1271 spanning tree as they can't be instrumented. Also, arcs which must be
1272 split when instrumented should be part of the spanning tree if possible. */
1273
1274static void
1275find_spanning_tree (num_blocks)
1276 int num_blocks;
1277{
1278 int i;
1279 struct adj_list *arcptr;
1280 struct bb_info *binfo = &bb_graph[0];
1281
1282 /* Fake arcs must be part of the spanning tree, and are always safe to put
1283 on the spanning tree. Fake arcs will either be a successor of node 0,
1284 a predecessor of the last node, or from the last node to node 0. */
1285
1286 for (arcptr = bb_graph[0].succ; arcptr; arcptr = arcptr->succ_next)
1287 if (arcptr->fake)
1288 {
1289 /* Adding this arc should never cause a cycle. This is a fatal
1290 error if it would. */
1291 if (bb_graph[ARC_TARGET (arcptr)].on_tree && binfo->on_tree)
1292 abort();
1293 else
1294 {
1295 arcptr->on_tree = 1;
1296 bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
1297 binfo->on_tree = 1;
1298 }
1299 }
1300
1301 binfo = &bb_graph[num_blocks-1];
1302 for (arcptr = binfo->pred; arcptr; arcptr = arcptr->pred_next)
1303 if (arcptr->fake)
1304 {
1305 /* Adding this arc should never cause a cycle. This is a fatal
1306 error if it would. */
1307 if (bb_graph[ARC_SOURCE (arcptr)].on_tree && binfo->on_tree)
1308 abort();
1309 else
1310 {
1311 arcptr->on_tree = 1;
1312 bb_graph[ARC_SOURCE (arcptr)].on_tree = 1;
1313 binfo->on_tree = 1;
1314 }
1315 }
1316 /* The only entrace to node zero is a fake arc. */
1317 bb_graph[0].pred->on_tree = 1;
1318
1319 /* Arcs which are crowded at both the source and target should be put on
1320 the spanning tree if possible, except for fall_throuch arcs which never
1321 require adding a new block even if crowded, add arcs with the same source
1322 and dest which must always be instrumented. */
1323 for (i = 0; i < num_blocks; i++)
1324 {
1325 binfo = &bb_graph[i];
1326
1327 for (arcptr = binfo->succ; arcptr; arcptr = arcptr->succ_next)
1328 if (! ((binfo->succ == arcptr && arcptr->succ_next == 0)
1329 || (bb_graph[ARC_TARGET (arcptr)].pred
1330 && arcptr->pred_next == 0))
1331 && ! arcptr->fall_through
1332 && ARC_TARGET (arcptr) != i)
1333 {
1334 /* This is a crowded arc at both source and target. Try to put
1335 in on the spanning tree. Can do this if either the source or
1336 target block is not yet on the tree. */
1337 if (! bb_graph[ARC_TARGET (arcptr)].on_tree || ! binfo->on_tree)
1338 {
1339 arcptr->on_tree = 1;
1340 bb_graph[ARC_TARGET (arcptr)].on_tree = 1;
1341 binfo->on_tree = 1;
1342 }
1343 }
1344 }
1345
1346 /* Clear all of the basic block on_tree bits, so that we can use them to
1347 create the spanning tree. */
1348 for (i = 0; i < num_blocks; i++)
1349 bb_graph[i].on_tree = 0;
1350
1351 /* Now fill in the spanning tree until every basic block is on it.
1352 Don't put the 0 to 1 fall through arc on the tree, since it is
1353 always cheap to instrument, so start filling the tree from node 1. */
1354
1355 for (i = 1; i < num_blocks; i++)
1356 for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
1357 if (! arcptr->on_tree
1358 && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1359 {
1360 fill_spanning_tree (i);
1361 break;
1362 }
1363}
1364
1365/* Add arcs reached from BLOCK to the spanning tree if they are needed and
1366 not already there. */
1367
1368static void
1369fill_spanning_tree (block)
1370 int block;
1371{
1372 struct adj_list *arcptr;
1373
1374 expand_spanning_tree (block);
1375
1376 for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
1377 if (! arcptr->on_tree
1378 && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1379 {
1380 arcptr->on_tree = 1;
1381 fill_spanning_tree (ARC_TARGET (arcptr));
1382 }
1383}
1384
1385/* When first visit a block, must add all blocks that are already connected
1386 to this block via tree arcs to the spanning tree. */
1387
1388static void
1389expand_spanning_tree (block)
1390 int block;
1391{
1392 struct adj_list *arcptr;
1393
1394 bb_graph[block].on_tree = 1;
1395
1396 for (arcptr = bb_graph[block].succ; arcptr; arcptr = arcptr->succ_next)
1397 if (arcptr->on_tree && ! bb_graph[ARC_TARGET (arcptr)].on_tree)
1398 expand_spanning_tree (ARC_TARGET (arcptr));
1399
1400 for (arcptr = bb_graph[block].pred;
1401 arcptr; arcptr = arcptr->pred_next)
1402 if (arcptr->on_tree && ! bb_graph[ARC_SOURCE (arcptr)].on_tree)
1403 expand_spanning_tree (ARC_SOURCE (arcptr));
1404}
1405
1406/* Perform file-level initialization for branch-prob processing. */
1407
1408void
1409init_branch_prob (filename)
1410 const char *filename;
1411{
1412 long len;
1413 int i;
1414
1415 if (flag_test_coverage)
1416 {
1417 /* Open an output file for the basic block/line number map. */
1418 int len = strlen (filename);
1419 char *data_file = (char *) alloca (len + 4);
1420 strcpy (data_file, filename);
1421 strip_off_ending (data_file, len);
1422 strcat (data_file, ".bb");
1423 if ((bb_file = fopen (data_file, "w")) == 0)
1424 pfatal_with_name (data_file);
1425
1426 /* Open an output file for the program flow graph. */
1427 len = strlen (filename);
1428 bbg_file_name = (char *) alloca (len + 5);
1429 strcpy (bbg_file_name, filename);
1430 strip_off_ending (bbg_file_name, len);
1431 strcat (bbg_file_name, ".bbg");
1432 if ((bbg_file = fopen (bbg_file_name, "w")) == 0)
1433 pfatal_with_name (bbg_file_name);
1434
1435 /* Initialize to zero, to ensure that the first file name will be
1436 written to the .bb file. */
1437 last_bb_file_name = 0;
1438 }
1439
1440 if (flag_branch_probabilities)
1441 {
1442 len = strlen (filename);
1443 da_file_name = (char *) alloca (len + 4);
1444 strcpy (da_file_name, filename);
1445 strip_off_ending (da_file_name, len);
1446 strcat (da_file_name, ".da");
1447 if ((da_file = fopen (da_file_name, "r")) == 0)
1448 warning ("file %s not found, execution counts assumed to be zero.",
1449 da_file_name);
1450
1451 /* The first word in the .da file gives the number of instrumented arcs,
1452 which is not needed for our purposes. */
1453
1454 if (da_file)
1455 __read_long (&len, da_file, 8);
1456 }
1457
1458 if (profile_arc_flag)
1459 init_arc_profiler ();
1460
1461 total_num_blocks = 0;
1462 total_num_arcs = 0;
1463 total_num_arcs_instrumented = 0;
1464 total_num_blocks_created = 0;
1465 total_num_passes = 0;
1466 total_num_times_called = 0;
1467 total_num_branches = 0;
1468 total_num_never_executed = 0;
1469 for (i = 0; i < 20; i++)
1470 total_hist_br_prob[i] = 0;
1471}
1472
1473/* Performs file-level cleanup after branch-prob processing
1474 is completed. */
1475
1476void
1477end_branch_prob (dump_file)
1478 FILE *dump_file;
1479{
1480 if (flag_test_coverage)
1481 {
1482 fclose (bb_file);
1483 fclose (bbg_file);
1484 }
1485
1486 if (flag_branch_probabilities)
1487 {
1488 if (da_file)
1489 {
1490 long temp;
1491 /* This seems slightly dangerous, as it presumes the EOF
1492 flag will not be set until an attempt is made to read
1493 past the end of the file. */
1494 if (feof (da_file))
1495 warning (".da file contents exhausted too early\n");
1496 /* Should be at end of file now. */
1497 if (__read_long (&temp, da_file, 8) == 0)
1498 warning (".da file contents not exhausted\n");
1499 fclose (da_file);
1500 }
1501 }
1502
1503 if (dump_file)
1504 {
1505 fprintf (dump_file, "\n");
1506 fprintf (dump_file, "Total number of blocks: %d\n", total_num_blocks);
1507 fprintf (dump_file, "Total number of arcs: %d\n", total_num_arcs);
1508 fprintf (dump_file, "Total number of instrumented arcs: %d\n",
1509 total_num_arcs_instrumented);
1510 fprintf (dump_file, "Total number of blocks created: %d\n",
1511 total_num_blocks_created);
1512 fprintf (dump_file, "Total number of graph solution passes: %d\n",
1513 total_num_passes);
1514 if (total_num_times_called != 0)
1515 fprintf (dump_file, "Average number of graph solution passes: %d\n",
1516 (total_num_passes + (total_num_times_called >> 1))
1517 / total_num_times_called);
1518 fprintf (dump_file, "Total number of branches: %d\n", total_num_branches);
1519 fprintf (dump_file, "Total number of branches never executed: %d\n",
1520 total_num_never_executed);
1521 if (total_num_branches)
1522 {
1523 int i;
1524
1525 for (i = 0; i < 10; i++)
1526 fprintf (dump_file, "%d%% branches in range %d-%d%%\n",
1527 (total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
1528 / total_num_branches, 5*i, 5*i+5);
1529 }
1530 }
1531}
1532
1533/* The label used by the arc profiling code. */
1534
1535static rtx profiler_label;
1536
1537/* Initialize the profiler_label. */
1538
1539static void
1540init_arc_profiler ()
1541{
1542 /* Generate and save a copy of this so it can be shared. */
1543 char *name = xmalloc (20);
1544 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
1545 profiler_label = gen_rtx_SYMBOL_REF (Pmode, name);
1546}
1547
1548/* Output instructions as RTL to increment the arc execution count. */
1549
1550static void
1551output_arc_profiler (arcno, insert_after)
1552 int arcno;
1553 rtx insert_after;
1554{
1555 rtx profiler_target_addr
1556 = (arcno
1557 ? gen_rtx_CONST (Pmode,
1558 gen_rtx_PLUS (Pmode, profiler_label,
1559 GEN_INT (LONG_TYPE_SIZE / BITS_PER_UNIT * arcno)))
1560 : profiler_label);
1561 enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
1562 rtx profiler_reg = gen_reg_rtx (mode);
1563 rtx address_reg = gen_reg_rtx (Pmode);
1564 rtx mem_ref, add_ref;
1565 rtx sequence;
1566
1567 /* In this case, reload can use explicitly mentioned hard registers for
1568 reloads. It is not safe to output profiling code between a call
1569 and the instruction that copies the result to a pseudo-reg. This
1570 is because reload may allocate one of the profiling code pseudo-regs
1571 to the return value reg, thus clobbering the return value. So we
1572 must check for calls here, and emit the profiling code after the
1573 instruction that uses the return value, if any.
1574
1575 ??? The code here performs the same tests that reload does so hopefully
1576 all the bases are covered. */
1577
1578 if (SMALL_REGISTER_CLASSES
1579 && GET_CODE (insert_after) == CALL_INSN
1580 && (GET_CODE (PATTERN (insert_after)) == SET
1581 || (GET_CODE (PATTERN (insert_after)) == PARALLEL
1582 && GET_CODE (XVECEXP (PATTERN (insert_after), 0, 0)) == SET)))
1583 {
1584 rtx return_reg;
1585 rtx next_insert_after = next_nonnote_insn (insert_after);
1586
1587 /* The first insn after the call may be a stack pop, skip it. */
1588 if (next_insert_after
1589 && GET_CODE (next_insert_after) == INSN
1590 && GET_CODE (PATTERN (next_insert_after)) == SET
1591 && SET_DEST (PATTERN (next_insert_after)) == stack_pointer_rtx)
1592 next_insert_after = next_nonnote_insn (next_insert_after);
1593
1594 if (next_insert_after
1595 && GET_CODE (next_insert_after) == INSN)
1596 {
1597 if (GET_CODE (PATTERN (insert_after)) == SET)
1598 return_reg = SET_DEST (PATTERN (insert_after));
1599 else
1600 return_reg = SET_DEST (XVECEXP (PATTERN (insert_after), 0, 0));
1601
1602 /* Now, NEXT_INSERT_AFTER may be an instruction that uses the
1603 return value. However, it could also be something else,
1604 like a CODE_LABEL, so check that the code is INSN. */
1605 if (next_insert_after != 0
1606 && GET_RTX_CLASS (GET_CODE (next_insert_after)) == 'i'
1607 && reg_referenced_p (return_reg, PATTERN (next_insert_after)))
1608 insert_after = next_insert_after;
1609 }
1610 }
1611
1612 start_sequence ();
1613
1614 emit_move_insn (address_reg, profiler_target_addr);
1615 mem_ref = gen_rtx_MEM (mode, address_reg);
1616 emit_move_insn (profiler_reg, mem_ref);
1617
1618 add_ref = gen_rtx_PLUS (mode, profiler_reg, GEN_INT (1));
1619 emit_move_insn (profiler_reg, add_ref);
1620
1621 /* This is the same rtx as above, but it is not legal to share this rtx. */
1622 mem_ref = gen_rtx_MEM (mode, address_reg);
1623 emit_move_insn (mem_ref, profiler_reg);
1624
1625 sequence = gen_sequence ();
1626 end_sequence ();
1627 emit_insn_after (sequence, insert_after);
1628}
1629
1630/* Output code for a constructor that will invoke __bb_init_func, if
1631 this has not already been done. */
1632
1633void
1634output_func_start_profiler ()
1635{
1636 tree fnname, fndecl;
1637 char *name, *cfnname;
1638 rtx table_address;
1639 enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
1640 int save_flag_inline_functions = flag_inline_functions;
1641
1642 /* It's either already been output, or we don't need it because we're
1643 not doing profile-arcs. */
1644 if (! need_func_profiler)
1645 return;
1646
1647 need_func_profiler = 0;
1648
1649 /* Synthesize a constructor function to invoke __bb_init_func with a
1650 pointer to this object file's profile block. */
1651 start_sequence ();
1652
1653 /* Try and make a unique name given the "file function name".
1654
1655 And no, I don't like this either. */
1656
1657 fnname = get_file_function_name ('I');
1658 cfnname = IDENTIFIER_POINTER (fnname);
1659 name = xmalloc (strlen (cfnname) + 5);
1660 sprintf (name, "%sGCOV",cfnname);
1661 fnname = get_identifier (name);
1662 free (name);
1663
1664 fndecl = build_decl (FUNCTION_DECL, fnname,
1665 build_function_type (void_type_node, NULL_TREE));
1666 DECL_EXTERNAL (fndecl) = 0;
1667 TREE_PUBLIC (fndecl) = 1;
1668 DECL_ASSEMBLER_NAME (fndecl) = fnname;
1669 DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
1670
1671 fndecl = pushdecl (fndecl);
1672 rest_of_decl_compilation (fndecl, 0, 1, 0);
1673 announce_function (fndecl);
1674 current_function_decl = fndecl;
1675 DECL_INITIAL (fndecl) = error_mark_node;
1676 temporary_allocation ();
1677 pushlevel (0);
1678 make_function_rtl (fndecl);
1679 init_function_start (fndecl, input_filename, lineno);
1680 expand_function_start (fndecl, 0);
1681
1682 /* Actually generate the code to call __bb_init_func. */
1683 name = xmalloc (20);
1684 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0);
1685 table_address = force_reg (Pmode, gen_rtx_SYMBOL_REF (Pmode, name));
1686 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_init_func"), 0,
1687 mode, 1, table_address, Pmode);
1688
1689 expand_function_end (input_filename, lineno, 0);
1690 poplevel (1, 0, 1);
1691
1692 /* Since fndecl isn't in the list of globals, it would never be emitted
1693 when it's considered to be 'safe' for inlining, so turn off
1694 flag_inline_functions. */
1695 flag_inline_functions = 0;
1696
1697 rest_of_compilation (fndecl);
1698
1699 /* Reset flag_inline_functions to its original value. */
1700 flag_inline_functions = save_flag_inline_functions;
1701
1702 if (! quiet_flag)
1703 fflush (asm_out_file);
1704 current_function_decl = NULL_TREE;
1705
1706 assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
1707}