#include "config.h"
#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "flags.h"
#include "insn-config.h"
#include "output.h"
#include "regs.h"
#include "expr.h"
#include "function.h"
#include "toplev.h"
#include "ggc.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "gcov-io.h"
#include "target.h"
#include "profile.h"
#include "libfuncs.h"
#include "langhooks.h"
struct edge_info {
unsigned int count_valid : 1;
unsigned int on_tree : 1;
unsigned int ignore : 1;
};
struct bb_info {
unsigned int count_valid : 1;
gcov_type succ_count;
gcov_type pred_count;
};
#define EDGE_INFO(e) ((struct edge_info *) (e)->aux)
#define BB_INFO(b) ((struct bb_info *) (b)->aux)
#define BB_TO_GCOV_INDEX(bb) ((bb) == ENTRY_BLOCK_PTR ? 0 \
: ((bb) == EXIT_BLOCK_PTR \
? last_basic_block + 1 : (bb)->index + 1))
struct profile_info profile_info;
static FILE *bbg_file;
static FILE *da_file;
static char *da_file_name;
static FILE *bb_file;
static char *last_bb_file_name;
static int total_num_blocks;
static int total_num_edges;
static int total_num_edges_ignored;
static int total_num_edges_instrumented;
static int total_num_blocks_created;
static int total_num_passes;
static int total_num_times_called;
static int total_hist_br_prob[20];
static int total_num_never_executed;
static int total_num_branches;
static void find_spanning_tree PARAMS ((struct edge_list *));
static void init_edge_profiler PARAMS ((void));
static rtx gen_edge_profiler PARAMS ((int));
static void instrument_edges PARAMS ((struct edge_list *));
static void output_gcov_string PARAMS ((const char *, long));
static void compute_branch_probabilities PARAMS ((void));
static gcov_type * get_exec_counts PARAMS ((void));
static long compute_checksum PARAMS ((void));
static basic_block find_group PARAMS ((basic_block));
static void union_groups PARAMS ((basic_block, basic_block));
static int need_func_profiler = 0;
static void
instrument_edges (el)
struct edge_list *el;
{
int num_instr_edges = 0;
int num_edges = NUM_EDGES (el);
basic_block bb;
remove_fake_edges ();
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e = bb->succ;
while (e)
{
struct edge_info *inf = EDGE_INFO (e);
if (!inf->ignore && !inf->on_tree)
{
if (e->flags & EDGE_ABNORMAL)
abort ();
if (rtl_dump_file)
fprintf (rtl_dump_file, "Edge %d to %d instrumented%s\n",
e->src->index, e->dest->index,
EDGE_CRITICAL_P (e) ? " (and split)" : "");
need_func_profiler = 1;
insert_insn_on_edge (
gen_edge_profiler (total_num_edges_instrumented
+ num_instr_edges++), e);
}
e = e->succ_next;
}
}
profile_info.count_edges_instrumented_now = num_instr_edges;
total_num_edges_instrumented += num_instr_edges;
profile_info.count_instrumented_edges = total_num_edges_instrumented;
total_num_blocks_created += num_edges;
if (rtl_dump_file)
fprintf (rtl_dump_file, "%d edges instrumented\n", num_instr_edges);
commit_edge_insertions_watch_calls ();
}
static void
output_gcov_string (string, delimiter)
const char *string;
long delimiter;
{
size_t temp;
__write_long (delimiter, bb_file, 4);
temp = strlen (string) + 1;
fwrite (string, temp, 1, bb_file);
temp = temp & 0x3;
if (temp)
{
char c[4];
c[0] = c[1] = c[2] = c[3] = 0;
fwrite (c, sizeof (char), 4 - temp, bb_file);
}
__write_long (delimiter, bb_file, 4);
}
static gcov_type *
get_exec_counts ()
{
int num_edges = 0;
basic_block bb;
int okay = 1, i;
int mismatch = 0;
gcov_type *profile;
char *function_name_buffer;
int function_name_buffer_len;
gcov_type max_counter_in_run;
const char *name = IDENTIFIER_POINTER
(DECL_ASSEMBLER_NAME (current_function_decl));
profile_info.max_counter_in_program = 0;
profile_info.count_profiles_merged = 0;
if (!da_file)
return 0;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
for (e = bb->succ; e; e = e->succ_next)
if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
num_edges++;
}
profile = xmalloc (sizeof (gcov_type) * num_edges);
rewind (da_file);
function_name_buffer_len = strlen (name) + 1;
function_name_buffer = xmalloc (function_name_buffer_len + 1);
for (i = 0; i < num_edges; i++)
profile[i] = 0;
while (1)
{
long magic, extra_bytes;
long func_count;
int i;
if (__read_long (&magic, da_file, 4) != 0)
break;
if (magic != -123)
{
okay = 0;
break;
}
if (__read_long (&func_count, da_file, 4) != 0)
{
okay = 0;
break;
}
if (__read_long (&extra_bytes, da_file, 4) != 0)
{
okay = 0;
break;
}
fseek (da_file, 4 + 8, SEEK_CUR);
__read_gcov_type (&max_counter_in_run, da_file, 8);
fseek (da_file, extra_bytes - (4 + 8 + 8), SEEK_CUR);
for (i = 0; i < func_count; i++)
{
long arc_count;
long chksum;
int j;
if (__read_gcov_string
(function_name_buffer, function_name_buffer_len, da_file,
-1) != 0)
{
okay = 0;
break;
}
if (__read_long (&chksum, da_file, 4) != 0)
{
okay = 0;
break;
}
if (__read_long (&arc_count, da_file, 4) != 0)
{
okay = 0;
break;
}
if (strcmp (function_name_buffer, name) != 0)
{
if (fseek (da_file, arc_count * 8, SEEK_CUR) < 0)
{
okay = 0;
break;
}
}
else if (arc_count != num_edges
|| chksum != profile_info.current_function_cfg_checksum)
okay = 0, mismatch = 1;
else
{
gcov_type tmp;
profile_info.max_counter_in_program += max_counter_in_run;
profile_info.count_profiles_merged++;
for (j = 0; j < arc_count; j++)
if (__read_gcov_type (&tmp, da_file, 8) != 0)
{
okay = 0;
break;
}
else
{
profile[j] += tmp;
}
}
}
if (!okay)
break;
}
free (function_name_buffer);
if (!okay)
{
if (mismatch)
error
("Profile does not match flowgraph of function %s (out of date?)",
current_function_name);
else
error (".da file corrupted");
free (profile);
return 0;
}
if (rtl_dump_file)
{
fprintf(rtl_dump_file, "Merged %i profiles with maximal count %i.\n",
profile_info.count_profiles_merged,
(int)profile_info.max_counter_in_program);
}
return profile;
}
static void
compute_branch_probabilities ()
{
basic_block bb;
int i;
int num_edges = 0;
int changes;
int passes;
int hist_br_prob[20];
int num_never_executed;
int num_branches;
gcov_type *exec_counts = get_exec_counts ();
int exec_counts_pos = 0;
alloc_aux_for_blocks (sizeof (struct bb_info));
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
for (e = bb->succ; e; e = e->succ_next)
if (!EDGE_INFO (e)->ignore)
BB_INFO (bb)->succ_count++;
for (e = bb->pred; e; e = e->pred_next)
if (!EDGE_INFO (e)->ignore)
BB_INFO (bb)->pred_count++;
}
BB_INFO (EXIT_BLOCK_PTR)->succ_count = 2;
BB_INFO (ENTRY_BLOCK_PTR)->pred_count = 2;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
for (e = bb->succ; e; e = e->succ_next)
if (!EDGE_INFO (e)->ignore && !EDGE_INFO (e)->on_tree)
{
num_edges++;
if (exec_counts)
{
e->count = exec_counts[exec_counts_pos++];
}
else
e->count = 0;
EDGE_INFO (e)->count_valid = 1;
BB_INFO (bb)->succ_count--;
BB_INFO (e->dest)->pred_count--;
if (rtl_dump_file)
{
fprintf (rtl_dump_file, "\nRead edge from %i to %i, count:",
bb->index, e->dest->index);
fprintf (rtl_dump_file, HOST_WIDEST_INT_PRINT_DEC,
(HOST_WIDEST_INT) e->count);
}
}
}
if (rtl_dump_file)
fprintf (rtl_dump_file, "\n%d edge counts read\n", num_edges);
changes = 1;
passes = 0;
while (changes)
{
passes++;
changes = 0;
FOR_BB_BETWEEN (bb, EXIT_BLOCK_PTR, NULL, prev_bb)
{
struct bb_info *bi = BB_INFO (bb);
if (! bi->count_valid)
{
if (bi->succ_count == 0)
{
edge e;
gcov_type total = 0;
for (e = bb->succ; e; e = e->succ_next)
total += e->count;
bb->count = total;
bi->count_valid = 1;
changes = 1;
}
else if (bi->pred_count == 0)
{
edge e;
gcov_type total = 0;
for (e = bb->pred; e; e = e->pred_next)
total += e->count;
bb->count = total;
bi->count_valid = 1;
changes = 1;
}
}
if (bi->count_valid)
{
if (bi->succ_count == 1)
{
edge e;
gcov_type total = 0;
for (e = bb->succ; e; e = e->succ_next)
total += e->count;
for (e = bb->succ; e; e = e->succ_next)
if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
break;
total = bb->count - total;
if (! e)
abort ();
EDGE_INFO (e)->count_valid = 1;
e->count = total;
bi->succ_count--;
BB_INFO (e->dest)->pred_count--;
changes = 1;
}
if (bi->pred_count == 1)
{
edge e;
gcov_type total = 0;
for (e = bb->pred; e; e = e->pred_next)
total += e->count;
for (e = bb->pred; e; e = e->pred_next)
if (! EDGE_INFO (e)->count_valid && ! EDGE_INFO (e)->ignore)
break;
total = bb->count - total + e->count;
if (! e)
abort ();
EDGE_INFO (e)->count_valid = 1;
e->count = total;
bi->pred_count--;
BB_INFO (e->src)->succ_count--;
changes = 1;
}
}
}
}
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
total_num_passes += passes;
if (rtl_dump_file)
fprintf (rtl_dump_file, "Graph solving took %d passes.\n\n", passes);
FOR_EACH_BB (bb)
{
if (BB_INFO (bb)->succ_count || BB_INFO (bb)->pred_count)
abort ();
}
for (i = 0; i < 20; i++)
hist_br_prob[i] = 0;
num_never_executed = 0;
num_branches = 0;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
{
edge e;
gcov_type total;
rtx note;
total = bb->count;
if (total)
{
for (e = bb->succ; e; e = e->succ_next)
{
e->probability = (e->count * REG_BR_PROB_BASE + total / 2) / total;
if (e->probability < 0 || e->probability > REG_BR_PROB_BASE)
{
error ("corrupted profile info: prob for %d-%d thought to be %d",
e->src->index, e->dest->index, e->probability);
e->probability = REG_BR_PROB_BASE / 2;
}
}
if (bb->index >= 0
&& any_condjump_p (bb->end)
&& bb->succ->succ_next)
{
int prob;
edge e;
int index;
for (e = bb->succ; e->flags & (EDGE_FAKE | EDGE_FALLTHRU);
e = e->succ_next)
continue;
prob = e->probability;
index = prob * 20 / REG_BR_PROB_BASE;
if (index == 20)
index = 19;
hist_br_prob[index]++;
note = find_reg_note (bb->end, REG_BR_PROB, 0);
if (note)
XEXP (note, 0) = GEN_INT (prob);
else
REG_NOTES (bb->end)
= gen_rtx_EXPR_LIST (REG_BR_PROB, GEN_INT (prob),
REG_NOTES (bb->end));
num_branches++;
}
}
else
{
for (e = bb->succ; e; e = e->succ_next)
if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
total ++;
if (total)
{
for (e = bb->succ; e; e = e->succ_next)
if (!(e->flags & (EDGE_COMPLEX | EDGE_FAKE)))
e->probability = REG_BR_PROB_BASE / total;
else
e->probability = 0;
}
else
{
for (e = bb->succ; e; e = e->succ_next)
total ++;
for (e = bb->succ; e; e = e->succ_next)
e->probability = REG_BR_PROB_BASE / total;
}
if (bb->index >= 0
&& any_condjump_p (bb->end)
&& bb->succ->succ_next)
num_branches++, num_never_executed;
}
}
if (rtl_dump_file)
{
fprintf (rtl_dump_file, "%d branches\n", num_branches);
fprintf (rtl_dump_file, "%d branches never executed\n",
num_never_executed);
if (num_branches)
for (i = 0; i < 10; i++)
fprintf (rtl_dump_file, "%d%% branches in range %d-%d%%\n",
(hist_br_prob[i] + hist_br_prob[19-i]) * 100 / num_branches,
5 * i, 5 * i + 5);
total_num_branches += num_branches;
total_num_never_executed += num_never_executed;
for (i = 0; i < 20; i++)
total_hist_br_prob[i] += hist_br_prob[i];
fputc ('\n', rtl_dump_file);
fputc ('\n', rtl_dump_file);
}
free_aux_for_blocks ();
if (exec_counts)
free (exec_counts);
}
#define CHSUM_HASH 500000003
#define CHSUM_SHIFT 2
static long
compute_checksum ()
{
long chsum = 0;
basic_block bb;
FOR_EACH_BB (bb)
{
edge e;
for (e = bb->succ; e; e = e->succ_next)
{
chsum = ((chsum << CHSUM_SHIFT) + (BB_TO_GCOV_INDEX (e->dest) + 1)) % CHSUM_HASH;
}
chsum = (chsum << CHSUM_SHIFT) % CHSUM_HASH;
}
return chsum;
}
void
branch_prob ()
{
basic_block bb;
int i;
int num_edges, ignored_edges;
struct edge_list *el;
const char *name = IDENTIFIER_POINTER
(DECL_ASSEMBLER_NAME (current_function_decl));
profile_info.current_function_cfg_checksum = compute_checksum ();
if (rtl_dump_file)
fprintf (rtl_dump_file, "CFG checksum is %ld\n",
profile_info.current_function_cfg_checksum);
if (flag_test_coverage)
output_gcov_string (name, (long) -2);
total_num_times_called++;
flow_call_edges_add (NULL);
add_noreturn_fake_exit_edges ();
FOR_EACH_BB (bb)
{
int need_exit_edge = 0, need_entry_edge = 0;
int have_exit_edge = 0, have_entry_edge = 0;
rtx insn;
edge e;
for (insn = bb->head; insn != NEXT_INSN (bb->end);
insn = NEXT_INSN (insn))
{
if (GET_CODE (insn) == CALL_INSN
&& find_reg_note (insn, REG_SETJMP, NULL))
{
if (GET_CODE (bb->head) == CODE_LABEL
|| insn != NEXT_INSN (bb->head))
{
e = split_block (bb, PREV_INSN (insn));
make_edge (ENTRY_BLOCK_PTR, e->dest, EDGE_FAKE);
break;
}
else
{
if (bb == ENTRY_BLOCK_PTR)
abort ();
make_edge (ENTRY_BLOCK_PTR, bb, EDGE_FAKE);
}
}
}
for (e = bb->succ; e; e = e->succ_next)
{
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->dest != EXIT_BLOCK_PTR)
need_exit_edge = 1;
if (e->dest == EXIT_BLOCK_PTR)
have_exit_edge = 1;
}
for (e = bb->pred; e; e = e->pred_next)
{
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->src != ENTRY_BLOCK_PTR)
need_entry_edge = 1;
if (e->src == ENTRY_BLOCK_PTR)
have_entry_edge = 1;
}
if (need_exit_edge && !have_exit_edge)
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "Adding fake exit edge to bb %i\n",
bb->index);
make_edge (bb, EXIT_BLOCK_PTR, EDGE_FAKE);
}
if (need_entry_edge && !have_entry_edge)
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "Adding fake entry edge to bb %i\n",
bb->index);
make_edge (ENTRY_BLOCK_PTR, bb, EDGE_FAKE);
}
}
el = create_edge_list ();
num_edges = NUM_EDGES (el);
alloc_aux_for_edges (sizeof (struct edge_info));
compact_blocks ();
ignored_edges = 0;
for (i = 0 ; i < num_edges ; i++)
{
edge e = INDEX_EDGE (el, i);
e->count = 0;
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->src != ENTRY_BLOCK_PTR && e->dest != EXIT_BLOCK_PTR)
{
EDGE_INFO (e)->ignore = 1;
ignored_edges++;
}
}
#ifdef ENABLE_CHECKING
verify_flow_info ();
#endif
if (flag_test_coverage)
{
FOR_EACH_BB (bb)
{
rtx insn = bb->head;
static int ignore_next_note = 0;
insn = prev_nonnote_insn (insn);
if (!insn)
insn = get_insns ();
else
insn = NEXT_INSN (insn);
__write_long (0, bb_file, 4);
while (insn != bb->end)
{
if (GET_CODE (insn) == NOTE)
{
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_REPEATED_LINE_NUMBER)
ignore_next_note = 1;
else if (NOTE_LINE_NUMBER (insn) > 0)
{
if (ignore_next_note)
ignore_next_note = 0;
else
{
if (! last_bb_file_name
|| strcmp (NOTE_SOURCE_FILE (insn),
last_bb_file_name))
{
if (last_bb_file_name)
free (last_bb_file_name);
last_bb_file_name
= xstrdup (NOTE_SOURCE_FILE (insn));
output_gcov_string (NOTE_SOURCE_FILE (insn),
(long)-1);
}
__write_long (NOTE_LINE_NUMBER (insn), bb_file, 4);
}
}
}
insn = NEXT_INSN (insn);
}
}
__write_long (0, bb_file, 4);
}
find_spanning_tree (el);
for (i = 0; i < num_edges; i++)
{
edge e = INDEX_EDGE (el, i);
struct edge_info *inf = EDGE_INFO (e);
if ((e->flags & EDGE_FAKE) && !inf->ignore && !inf->on_tree)
{
inf->ignore = 1;
ignored_edges++;
}
}
total_num_blocks += n_basic_blocks + 2;
if (rtl_dump_file)
fprintf (rtl_dump_file, "%d basic blocks\n", n_basic_blocks);
total_num_edges += num_edges;
if (rtl_dump_file)
fprintf (rtl_dump_file, "%d edges\n", num_edges);
total_num_edges_ignored += ignored_edges;
if (rtl_dump_file)
fprintf (rtl_dump_file, "%d ignored edges\n", ignored_edges);
if (flag_test_coverage)
{
int flag_bits;
__write_gcov_string (name, strlen (name), bbg_file, -1);
__write_long (profile_info.current_function_cfg_checksum, bbg_file, 4);
__write_long (n_basic_blocks + 2, bbg_file, 4);
__write_long (num_edges - ignored_edges + 1, bbg_file, 4);
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
{
edge e;
long count = 0;
for (e = bb->succ; e; e = e->succ_next)
if (!EDGE_INFO (e)->ignore)
count++;
__write_long (count, bbg_file, 4);
for (e = bb->succ; e; e = e->succ_next)
{
struct edge_info *i = EDGE_INFO (e);
if (!i->ignore)
{
flag_bits = 0;
if (i->on_tree)
flag_bits |= 0x1;
if (e->flags & EDGE_FAKE)
flag_bits |= 0x2;
if (e->flags & EDGE_FALLTHRU)
flag_bits |= 0x4;
__write_long (BB_TO_GCOV_INDEX (e->dest), bbg_file, 4);
__write_long (flag_bits, bbg_file, 4);
}
}
}
__write_long (1, bbg_file, 4);
__write_long (0, bbg_file, 4);
__write_long (0x1, bbg_file, 4);
__write_long (-1, bbg_file, 4);
}
if (flag_branch_probabilities)
compute_branch_probabilities ();
if (profile_arc_flag)
{
instrument_edges (el);
allocate_reg_info (max_reg_num (), FALSE, FALSE);
}
remove_fake_edges ();
cleanup_cfg (profile_arc_flag ? CLEANUP_EXPENSIVE : 0);
if (rtl_dump_file)
dump_flow_info (rtl_dump_file);
free_aux_for_edges ();
free_edge_list (el);
}
static basic_block
find_group (bb)
basic_block bb;
{
basic_block group = bb, bb1;
while ((basic_block) group->aux != group)
group = (basic_block) group->aux;
while ((basic_block) bb->aux != group)
{
bb1 = (basic_block) bb->aux;
bb->aux = (void *) group;
bb = bb1;
}
return group;
}
static void
union_groups (bb1, bb2)
basic_block bb1, bb2;
{
basic_block bb1g = find_group (bb1);
basic_block bb2g = find_group (bb2);
if (bb1g == bb2g)
abort ();
bb1g->aux = bb2g;
}
static void
find_spanning_tree (el)
struct edge_list *el;
{
int i;
int num_edges = NUM_EDGES (el);
basic_block bb;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
bb->aux = bb;
union_groups (EXIT_BLOCK_PTR, ENTRY_BLOCK_PTR);
for (i = 0; i < num_edges; i++)
{
edge e = INDEX_EDGE (el, i);
if (((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_FAKE))
|| e->dest == EXIT_BLOCK_PTR
)
&& !EDGE_INFO (e)->ignore
&& (find_group (e->src) != find_group (e->dest)))
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "Abnormal edge %d to %d put to tree\n",
e->src->index, e->dest->index);
EDGE_INFO (e)->on_tree = 1;
union_groups (e->src, e->dest);
}
}
for (i = 0; i < num_edges; i++)
{
edge e = INDEX_EDGE (el, i);
if ((EDGE_CRITICAL_P (e))
&& !EDGE_INFO (e)->ignore
&& (find_group (e->src) != find_group (e->dest)))
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "Critical edge %d to %d put to tree\n",
e->src->index, e->dest->index);
EDGE_INFO (e)->on_tree = 1;
union_groups (e->src, e->dest);
}
}
for (i = 0; i < num_edges; i++)
{
edge e = INDEX_EDGE (el, i);
if (find_group (e->src) != find_group (e->dest)
&& !EDGE_INFO (e)->ignore)
{
if (rtl_dump_file)
fprintf (rtl_dump_file, "Normal edge %d to %d put to tree\n",
e->src->index, e->dest->index);
EDGE_INFO (e)->on_tree = 1;
union_groups (e->src, e->dest);
}
}
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
bb->aux = NULL;
}
void
init_branch_prob (filename)
const char *filename;
{
int len = strlen (filename);
int i;
if (flag_test_coverage)
{
char *data_file, *bbg_file_name;
data_file = (char *) alloca (len + 4);
strcpy (data_file, filename);
strcat (data_file, ".bb");
if ((bb_file = fopen (data_file, "wb")) == 0)
fatal_io_error ("can't open %s", data_file);
bbg_file_name = (char *) alloca (len + 5);
strcpy (bbg_file_name, filename);
strcat (bbg_file_name, ".bbg");
if ((bbg_file = fopen (bbg_file_name, "wb")) == 0)
fatal_io_error ("can't open %s", bbg_file_name);
last_bb_file_name = 0;
}
da_file_name = (char *) xmalloc (len + 4);
strcpy (da_file_name, filename);
strcat (da_file_name, ".da");
if (flag_branch_probabilities)
{
da_file = fopen (da_file_name, "rb");
if (!da_file)
warning ("file %s not found, execution counts assumed to be zero",
da_file_name);
}
if (profile_arc_flag)
init_edge_profiler ();
total_num_blocks = 0;
total_num_edges = 0;
total_num_edges_ignored = 0;
total_num_edges_instrumented = 0;
total_num_blocks_created = 0;
total_num_passes = 0;
total_num_times_called = 0;
total_num_branches = 0;
total_num_never_executed = 0;
for (i = 0; i < 20; i++)
total_hist_br_prob[i] = 0;
}
void
end_branch_prob ()
{
if (flag_test_coverage)
{
fclose (bb_file);
fclose (bbg_file);
unlink (da_file_name);
}
if (flag_branch_probabilities && da_file)
fclose (da_file);
if (rtl_dump_file)
{
fprintf (rtl_dump_file, "\n");
fprintf (rtl_dump_file, "Total number of blocks: %d\n",
total_num_blocks);
fprintf (rtl_dump_file, "Total number of edges: %d\n", total_num_edges);
fprintf (rtl_dump_file, "Total number of ignored edges: %d\n",
total_num_edges_ignored);
fprintf (rtl_dump_file, "Total number of instrumented edges: %d\n",
total_num_edges_instrumented);
fprintf (rtl_dump_file, "Total number of blocks created: %d\n",
total_num_blocks_created);
fprintf (rtl_dump_file, "Total number of graph solution passes: %d\n",
total_num_passes);
if (total_num_times_called != 0)
fprintf (rtl_dump_file, "Average number of graph solution passes: %d\n",
(total_num_passes + (total_num_times_called >> 1))
/ total_num_times_called);
fprintf (rtl_dump_file, "Total number of branches: %d\n",
total_num_branches);
fprintf (rtl_dump_file, "Total number of branches never executed: %d\n",
total_num_never_executed);
if (total_num_branches)
{
int i;
for (i = 0; i < 10; i++)
fprintf (rtl_dump_file, "%d%% branches in range %d-%d%%\n",
(total_hist_br_prob[i] + total_hist_br_prob[19-i]) * 100
/ total_num_branches, 5*i, 5*i+5);
}
}
}
static GTY(()) rtx profiler_label;
static void
init_edge_profiler ()
{
char buf[20];
ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", 2);
profiler_label = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
}
static rtx
gen_edge_profiler (edgeno)
int edgeno;
{
enum machine_mode mode = mode_for_size (GCOV_TYPE_SIZE, MODE_INT, 0);
rtx mem_ref, tmp;
rtx sequence;
start_sequence ();
tmp = force_reg (Pmode, profiler_label);
tmp = plus_constant (tmp, GCOV_TYPE_SIZE / BITS_PER_UNIT * edgeno);
mem_ref = validize_mem (gen_rtx_MEM (mode, tmp));
set_mem_alias_set (mem_ref, new_alias_set ());
tmp = expand_simple_binop (mode, PLUS, mem_ref, const1_rtx,
mem_ref, 0, OPTAB_WIDEN);
if (tmp != mem_ref)
emit_move_insn (copy_rtx (mem_ref), tmp);
sequence = get_insns ();
end_sequence ();
return sequence;
}
void
output_func_start_profiler ()
{
tree fnname, fndecl;
char *name;
char buf[20];
const char *cfnname;
rtx table_address;
enum machine_mode mode = mode_for_size (GCOV_TYPE_SIZE, MODE_INT, 0);
int save_flag_inline_functions = flag_inline_functions;
if (! need_func_profiler)
return;
need_func_profiler = 0;
fnname = get_file_function_name ('I');
cfnname = IDENTIFIER_POINTER (fnname);
name = concat (cfnname, "GCOV", NULL);
fnname = get_identifier (name);
free (name);
fndecl = build_decl (FUNCTION_DECL, fnname,
build_function_type (void_type_node, NULL_TREE));
DECL_EXTERNAL (fndecl) = 0;
TREE_PUBLIC (fndecl) = ! targetm.have_ctors_dtors;
TREE_USED (fndecl) = 1;
DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
fndecl = (*lang_hooks.decls.pushdecl) (fndecl);
rest_of_decl_compilation (fndecl, 0, 1, 0);
announce_function (fndecl);
current_function_decl = fndecl;
DECL_INITIAL (fndecl) = error_mark_node;
make_decl_rtl (fndecl, NULL);
init_function_start (fndecl, input_filename, lineno);
(*lang_hooks.decls.pushlevel) (0);
expand_function_start (fndecl, 0);
cfun->arc_profile = 0;
ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", 0);
table_address = force_reg (Pmode,
gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf)));
emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_init_func"), LCT_NORMAL,
mode, 1, table_address, Pmode);
expand_function_end (input_filename, lineno, 0);
(*lang_hooks.decls.poplevel) (1, 0, 1);
flag_inline_functions = 0;
rest_of_compilation (fndecl);
flag_inline_functions = save_flag_inline_functions;
if (! quiet_flag)
fflush (asm_out_file);
current_function_decl = NULL_TREE;
if (targetm.have_ctors_dtors)
(* targetm.asm_out.constructor) (XEXP (DECL_RTL (fndecl), 0),
DEFAULT_INIT_PRIORITY);
}
#include "gt-profile.h"