static void
handle_pragma_interface (cpp_reader* /*dfile*/)
{
tree fname = parse_strconst_pragma ("interface", 1);
struct c_fileinfo *finfo;
const char *filename;
if (fname == error_mark_node)
return;
else if (fname == 0)
filename = lbasename (LOCATION_FILE (input_location));
else
filename = TREE_STRING_POINTER (fname);
finfo = get_fileinfo (LOCATION_FILE (input_location));
if (impl_file_chain == 0)
{
/* If this is zero at this point, then we are
auto-implementing. */
if (main_input_filename == 0)
main_input_filename = LOCATION_FILE (input_location);
}
finfo->interface_only = interface_strcmp (filename);
/* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
a definition in another file. */
if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
finfo->interface_unknown = 0;
}
static void
maybe_print_line_1 (source_location src_loc, FILE *stream)
{
int src_line = LOCATION_LINE (src_loc);
const char *src_file = LOCATION_FILE (src_loc);
/* End the previous line of text. */
if (print.printed)
{
putc ('\n', stream);
print.src_line++;
print.printed = 0;
}
if (!flag_no_line_commands
&& src_line >= print.src_line
&& src_line < print.src_line + 8
&& strcmp (src_file, print.src_file) == 0)
{
while (src_line > print.src_line)
{
putc ('\n', stream);
print.src_line++;
}
}
else
print_line_1 (src_loc, "", stream);
}
static bool
maybe_print_line_1 (source_location src_loc, FILE *stream)
{
bool emitted_line_marker = false;
int src_line = LOCATION_LINE (src_loc);
const char *src_file = LOCATION_FILE (src_loc);
/* End the previous line of text. */
if (print.printed)
{
putc ('\n', stream);
print.src_line++;
print.printed = false;
}
if (!flag_no_line_commands
&& src_line >= print.src_line
&& src_line < print.src_line + 8
&& strcmp (src_file, print.src_file) == 0)
{
while (src_line > print.src_line)
{
putc ('\n', stream);
print.src_line++;
}
}
else
emitted_line_marker = print_line_1 (src_loc, "", stream);
return emitted_line_marker;
}
/* Prints out, if necessary, the name of the current function
that caused an error. Called from all error and warning functions. */
void
diagnostic_report_current_function (diagnostic_context *context,
diagnostic_info *diagnostic)
{
diagnostic_report_current_module (context, diagnostic_location (diagnostic));
lang_hooks.print_error_function (context, LOCATION_FILE (input_location),
diagnostic);
}
void
dump_time_statistics (void)
{
struct c_fileinfo *file = get_fileinfo (LOCATION_FILE (input_location));
int this_time = get_run_time ();
file->time += this_time - body_time;
fprintf (stderr, "\n******\n");
print_time ("header files (total)", header_time);
print_time ("main file (total)", this_time - body_time);
fprintf (stderr, "ratio = %g : 1\n",
(double) header_time / (double) (this_time - body_time));
fprintf (stderr, "\n******\n");
splay_tree_foreach (file_info_tree, dump_one_header, 0);
}
static bool
print_line_1 (source_location src_loc, const char *special_flags, FILE *stream)
{
bool emitted_line_marker = false;
/* End any previous line of text. */
if (print.printed)
putc ('\n', stream);
print.printed = 0;
if (!flag_no_line_commands)
{
const char *file_path = LOCATION_FILE (src_loc);
int sysp;
size_t to_file_len = strlen (file_path);
unsigned char *to_file_quoted =
(unsigned char *) alloca (to_file_len * 4 + 1);
unsigned char *p;
print.src_line = LOCATION_LINE (src_loc);
print.src_file = file_path;
/* cpp_quote_string does not nul-terminate, so we have to do it
ourselves. */
p = cpp_quote_string (to_file_quoted,
(const unsigned char *) file_path,
to_file_len);
*p = '\0';
fprintf (stream, "# %u \"%s\"%s",
print.src_line == 0 ? 1 : print.src_line,
to_file_quoted, special_flags);
sysp = in_system_header_at (src_loc);
if (sysp == 2)
fputs (" 3 4", stream);
else if (sysp == 1)
fputs (" 3", stream);
putc ('\n', stream);
emitted_line_marker = true;
}
return emitted_line_marker;
}
static void
handle_pragma_implementation (cpp_reader* /*dfile*/)
{
tree fname = parse_strconst_pragma ("implementation", 1);
const char *filename;
struct impl_files *ifiles = impl_file_chain;
if (fname == error_mark_node)
return;
if (fname == 0)
{
if (main_input_filename)
filename = main_input_filename;
else
filename = LOCATION_FILE (input_location);
filename = lbasename (filename);
}
else
{
filename = TREE_STRING_POINTER (fname);
if (cpp_included_before (parse_in, filename, input_location))
warning (0, "#pragma implementation for %qs appears after "
"file is included", filename);
}
for (; ifiles; ifiles = ifiles->next)
{
if (! filename_cmp (ifiles->filename, filename))
break;
}
if (ifiles == 0)
{
ifiles = XNEW (struct impl_files);
ifiles->filename = xstrdup (filename);
ifiles->next = impl_file_chain;
impl_file_chain = ifiles;
}
static bool
shrink_wrap_one_built_in_call (gimple bi_call)
{
gimple_stmt_iterator bi_call_bsi;
basic_block bi_call_bb, join_tgt_bb, guard_bb, guard_bb0;
edge join_tgt_in_edge_from_call, join_tgt_in_edge_fall_thru;
edge bi_call_in_edge0, guard_bb_in_edge;
unsigned tn_cond_stmts, nconds;
unsigned ci;
gimple cond_expr = NULL;
gimple cond_expr_start;
tree bi_call_label_decl;
gimple bi_call_label;
auto_vec<gimple, 12> conds;
gen_shrink_wrap_conditions (bi_call, conds, &nconds);
/* This can happen if the condition generator decides
it is not beneficial to do the transformation. Just
return false and do not do any transformation for
the call. */
if (nconds == 0)
return false;
bi_call_bb = gimple_bb (bi_call);
/* Now find the join target bb -- split bi_call_bb if needed. */
if (stmt_ends_bb_p (bi_call))
{
/* If the call must be the last in the bb, don't split the block,
it could e.g. have EH edges. */
join_tgt_in_edge_from_call = find_fallthru_edge (bi_call_bb->succs);
if (join_tgt_in_edge_from_call == NULL)
return false;
}
else
join_tgt_in_edge_from_call = split_block (bi_call_bb, bi_call);
bi_call_bsi = gsi_for_stmt (bi_call);
join_tgt_bb = join_tgt_in_edge_from_call->dest;
/* Now it is time to insert the first conditional expression
into bi_call_bb and split this bb so that bi_call is
shrink-wrapped. */
tn_cond_stmts = conds.length ();
cond_expr = NULL;
cond_expr_start = conds[0];
for (ci = 0; ci < tn_cond_stmts; ci++)
{
gimple c = conds[ci];
gcc_assert (c || ci != 0);
if (!c)
break;
gsi_insert_before (&bi_call_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
nconds--;
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
/* Now the label. */
bi_call_label_decl = create_artificial_label (gimple_location (bi_call));
bi_call_label = gimple_build_label (bi_call_label_decl);
gsi_insert_before (&bi_call_bsi, bi_call_label, GSI_SAME_STMT);
bi_call_in_edge0 = split_block (bi_call_bb, cond_expr);
bi_call_in_edge0->flags &= ~EDGE_FALLTHRU;
bi_call_in_edge0->flags |= EDGE_TRUE_VALUE;
guard_bb0 = bi_call_bb;
bi_call_bb = bi_call_in_edge0->dest;
join_tgt_in_edge_fall_thru = make_edge (guard_bb0, join_tgt_bb,
EDGE_FALSE_VALUE);
bi_call_in_edge0->probability = REG_BR_PROB_BASE * ERR_PROB;
bi_call_in_edge0->count =
apply_probability (guard_bb0->count,
bi_call_in_edge0->probability);
join_tgt_in_edge_fall_thru->probability =
inverse_probability (bi_call_in_edge0->probability);
join_tgt_in_edge_fall_thru->count =
guard_bb0->count - bi_call_in_edge0->count;
/* Code generation for the rest of the conditions */
guard_bb = guard_bb0;
while (nconds > 0)
{
unsigned ci0;
edge bi_call_in_edge;
gimple_stmt_iterator guard_bsi = gsi_for_stmt (cond_expr_start);
ci0 = ci;
cond_expr_start = conds[ci0];
for (; ci < tn_cond_stmts; ci++)
{
gimple c = conds[ci];
gcc_assert (c || ci != ci0);
if (!c)
break;
gsi_insert_before (&guard_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
nconds--;
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
guard_bb_in_edge = split_block (guard_bb, cond_expr);
guard_bb_in_edge->flags &= ~EDGE_FALLTHRU;
guard_bb_in_edge->flags |= EDGE_FALSE_VALUE;
bi_call_in_edge = make_edge (guard_bb, bi_call_bb, EDGE_TRUE_VALUE);
bi_call_in_edge->probability = REG_BR_PROB_BASE * ERR_PROB;
bi_call_in_edge->count =
apply_probability (guard_bb->count,
bi_call_in_edge->probability);
guard_bb_in_edge->probability =
inverse_probability (bi_call_in_edge->probability);
guard_bb_in_edge->count = guard_bb->count - bi_call_in_edge->count;
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
location_t loc;
loc = gimple_location (bi_call);
fprintf (dump_file,
"%s:%d: note: function call is shrink-wrapped"
" into error conditions.\n",
LOCATION_FILE (loc), LOCATION_LINE (loc));
}
return true;
}
static void
shrink_wrap_one_built_in_call_with_conds (gcall *bi_call, vec <gimple *> conds,
unsigned int nconds)
{
gimple_stmt_iterator bi_call_bsi;
basic_block bi_call_bb, join_tgt_bb, guard_bb;
edge join_tgt_in_edge_from_call, join_tgt_in_edge_fall_thru;
edge bi_call_in_edge0, guard_bb_in_edge;
unsigned tn_cond_stmts;
unsigned ci;
gimple *cond_expr = NULL;
gimple *cond_expr_start;
/* The cfg we want to create looks like this:
[guard n-1] <- guard_bb (old block)
| \
| [guard n-2] }
| / \ }
| / ... } new blocks
| / [guard 0] }
| / / | }
[ call ] | <- bi_call_bb }
| \ |
| \ |
| [ join ] <- join_tgt_bb (old iff call must end bb)
|
possible EH edges (only if [join] is old)
When [join] is new, the immediate dominators for these blocks are:
1. [guard n-1]: unchanged
2. [call]: [guard n-1]
3. [guard m]: [guard m+1] for 0 <= m <= n-2
4. [join]: [guard n-1]
We punt for the more complex case case of [join] being old and
simply free the dominance info. We also punt on postdominators,
which aren't expected to be available at this point anyway. */
bi_call_bb = gimple_bb (bi_call);
/* Now find the join target bb -- split bi_call_bb if needed. */
if (stmt_ends_bb_p (bi_call))
{
/* We checked that there was a fallthrough edge in
can_guard_call_p. */
join_tgt_in_edge_from_call = find_fallthru_edge (bi_call_bb->succs);
gcc_assert (join_tgt_in_edge_from_call);
/* We don't want to handle PHIs. */
if (EDGE_COUNT (join_tgt_in_edge_from_call->dest->preds) > 1)
join_tgt_bb = split_edge (join_tgt_in_edge_from_call);
else
{
join_tgt_bb = join_tgt_in_edge_from_call->dest;
/* We may have degenerate PHIs in the destination. Propagate
those out. */
for (gphi_iterator i = gsi_start_phis (join_tgt_bb); !gsi_end_p (i);)
{
gphi *phi = i.phi ();
replace_uses_by (gimple_phi_result (phi),
gimple_phi_arg_def (phi, 0));
remove_phi_node (&i, true);
}
}
}
else
{
join_tgt_in_edge_from_call = split_block (bi_call_bb, bi_call);
join_tgt_bb = join_tgt_in_edge_from_call->dest;
}
bi_call_bsi = gsi_for_stmt (bi_call);
/* Now it is time to insert the first conditional expression
into bi_call_bb and split this bb so that bi_call is
shrink-wrapped. */
tn_cond_stmts = conds.length ();
cond_expr = NULL;
cond_expr_start = conds[0];
for (ci = 0; ci < tn_cond_stmts; ci++)
{
gimple *c = conds[ci];
gcc_assert (c || ci != 0);
if (!c)
break;
gsi_insert_before (&bi_call_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
typedef std::pair<edge, edge> edge_pair;
auto_vec<edge_pair, 8> edges;
bi_call_in_edge0 = split_block (bi_call_bb, cond_expr);
bi_call_in_edge0->flags &= ~EDGE_FALLTHRU;
bi_call_in_edge0->flags |= EDGE_FALSE_VALUE;
guard_bb = bi_call_bb;
bi_call_bb = bi_call_in_edge0->dest;
join_tgt_in_edge_fall_thru = make_edge (guard_bb, join_tgt_bb,
EDGE_TRUE_VALUE);
edges.reserve (nconds);
edges.quick_push (edge_pair (bi_call_in_edge0, join_tgt_in_edge_fall_thru));
/* Code generation for the rest of the conditions */
for (unsigned int i = 1; i < nconds; ++i)
{
unsigned ci0;
edge bi_call_in_edge;
gimple_stmt_iterator guard_bsi = gsi_for_stmt (cond_expr_start);
ci0 = ci;
cond_expr_start = conds[ci0];
for (; ci < tn_cond_stmts; ci++)
{
gimple *c = conds[ci];
gcc_assert (c || ci != ci0);
if (!c)
break;
gsi_insert_before (&guard_bsi, c, GSI_SAME_STMT);
cond_expr = c;
}
ci++;
gcc_assert (cond_expr && gimple_code (cond_expr) == GIMPLE_COND);
guard_bb_in_edge = split_block (guard_bb, cond_expr);
guard_bb_in_edge->flags &= ~EDGE_FALLTHRU;
guard_bb_in_edge->flags |= EDGE_TRUE_VALUE;
bi_call_in_edge = make_edge (guard_bb, bi_call_bb, EDGE_FALSE_VALUE);
edges.quick_push (edge_pair (bi_call_in_edge, guard_bb_in_edge));
}
/* Now update the probability and profile information, processing the
guards in order of execution.
There are two approaches we could take here. On the one hand we
could assign a probability of X to the call block and distribute
that probability among its incoming edges. On the other hand we
could assign a probability of X to each individual call edge.
The choice only affects calls that have more than one condition.
In those cases, the second approach would give the call block
a greater probability than the first. However, the difference
is only small, and our chosen X is a pure guess anyway.
Here we take the second approach because it's slightly simpler
and because it's easy to see that it doesn't lose profile counts. */
bi_call_bb->count = profile_count::zero ();
while (!edges.is_empty ())
{
edge_pair e = edges.pop ();
edge call_edge = e.first;
edge nocall_edge = e.second;
basic_block src_bb = call_edge->src;
gcc_assert (src_bb == nocall_edge->src);
call_edge->probability = profile_probability::very_unlikely ();
nocall_edge->probability = profile_probability::always ()
- call_edge->probability;
bi_call_bb->count += call_edge->count ();
if (nocall_edge->dest != join_tgt_bb)
nocall_edge->dest->count = src_bb->count - bi_call_bb->count;
}
if (dom_info_available_p (CDI_DOMINATORS))
{
/* The split_blocks leave [guard 0] as the immediate dominator
of [call] and [call] as the immediate dominator of [join].
Fix them up. */
set_immediate_dominator (CDI_DOMINATORS, bi_call_bb, guard_bb);
set_immediate_dominator (CDI_DOMINATORS, join_tgt_bb, guard_bb);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
location_t loc;
loc = gimple_location (bi_call);
fprintf (dump_file,
"%s:%d: note: function call is shrink-wrapped"
" into error conditions.\n",
LOCATION_FILE (loc), LOCATION_LINE (loc));
}
}
static void
test_show_locus (function *fun)
{
tree fndecl = fun->decl;
tree identifier = DECL_NAME (fndecl);
const char *fnname = IDENTIFIER_POINTER (identifier);
location_t fnstart = fun->function_start_locus;
int fnstart_line = LOCATION_LINE (fnstart);
diagnostic_finalizer (global_dc) = custom_diagnostic_finalizer;
/* Hardcode the "terminal width", to verify the behavior of
very wide lines. */
global_dc->caret_max_width = 70;
if (0 == strcmp (fnname, "test_simple"))
{
const int line = fnstart_line + 2;
rich_location richloc (line_table, get_loc (line, 15));
add_range (&richloc, get_loc (line, 10), get_loc (line, 14), false);
add_range (&richloc, get_loc (line, 16), get_loc (line, 16), false);
warning_at_rich_loc (&richloc, 0, "test");
}
if (0 == strcmp (fnname, "test_simple_2"))
{
const int line = fnstart_line + 2;
rich_location richloc (line_table, get_loc (line, 24));
add_range (&richloc, get_loc (line, 6), get_loc (line, 22), false);
add_range (&richloc, get_loc (line, 26), get_loc (line, 43), false);
warning_at_rich_loc (&richloc, 0, "test");
}
if (0 == strcmp (fnname, "test_multiline"))
{
const int line = fnstart_line + 2;
rich_location richloc (line_table, get_loc (line + 1, 7));
add_range (&richloc, get_loc (line, 7), get_loc (line, 23), false);
add_range (&richloc, get_loc (line + 1, 9), get_loc (line + 1, 26),
false);
warning_at_rich_loc (&richloc, 0, "test");
}
if (0 == strcmp (fnname, "test_many_lines"))
{
const int line = fnstart_line + 2;
rich_location richloc (line_table, get_loc (line + 5, 7));
add_range (&richloc, get_loc (line, 7), get_loc (line + 4, 65), false);
add_range (&richloc, get_loc (line + 5, 9), get_loc (line + 10, 61),
false);
warning_at_rich_loc (&richloc, 0, "test");
}
/* Example of a rich_location where the range is larger than
one character. */
if (0 == strcmp (fnname, "test_richloc_from_proper_range"))
{
const int line = fnstart_line + 2;
location_t start = get_loc (line, 12);
location_t finish = get_loc (line, 16);
rich_location richloc (line_table, make_location (start, start, finish));
warning_at_rich_loc (&richloc, 0, "test");
}
/* Example of a single-range location where the range starts
before the caret. */
if (0 == strcmp (fnname, "test_caret_within_proper_range"))
{
const int line = fnstart_line + 2;
warning_at (make_location (get_loc (line, 16), get_loc (line, 12),
get_loc (line, 20)),
0, "test");
}
/* Example of a very wide line, where the information of interest
is beyond the width of the terminal (hardcoded above). */
if (0 == strcmp (fnname, "test_very_wide_line"))
{
const int line = fnstart_line + 2;
global_dc->show_ruler_p = true;
warning_at (make_location (get_loc (line, 94), get_loc (line, 90),
get_loc (line, 98)),
0, "test");
global_dc->show_ruler_p = false;
}
/* Example of multiple carets. */
if (0 == strcmp (fnname, "test_multiple_carets"))
{
const int line = fnstart_line + 2;
location_t caret_a = get_loc (line, 7);
location_t caret_b = get_loc (line, 11);
rich_location richloc (line_table, caret_a);
add_range (&richloc, caret_b, caret_b, true);
global_dc->caret_chars[0] = 'A';
global_dc->caret_chars[1] = 'B';
warning_at_rich_loc (&richloc, 0, "test");
global_dc->caret_chars[0] = '^';
global_dc->caret_chars[1] = '^';
}
/* Tests of rendering fixit hints. */
if (0 == strcmp (fnname, "test_fixit_insert"))
{
const int line = fnstart_line + 2;
location_t start = get_loc (line, 19);
location_t finish = get_loc (line, 22);
rich_location richloc (line_table, make_location (start, start, finish));
richloc.add_fixit_insert_before ("{");
richloc.add_fixit_insert_after ("}");
warning_at_rich_loc (&richloc, 0, "example of insertion hints");
}
if (0 == strcmp (fnname, "test_fixit_remove"))
{
const int line = fnstart_line + 2;
location_t start = get_loc (line, 8);
location_t finish = get_loc (line, 8);
rich_location richloc (line_table, make_location (start, start, finish));
source_range src_range;
src_range.m_start = start;
src_range.m_finish = finish;
richloc.add_fixit_remove (src_range);
warning_at_rich_loc (&richloc, 0, "example of a removal hint");
}
if (0 == strcmp (fnname, "test_fixit_replace"))
{
const int line = fnstart_line + 2;
location_t start = get_loc (line, 2);
location_t finish = get_loc (line, 19);
rich_location richloc (line_table, make_location (start, start, finish));
source_range src_range;
src_range.m_start = start;
src_range.m_finish = finish;
richloc.add_fixit_replace (src_range, "gtk_widget_show_all");
warning_at_rich_loc (&richloc, 0, "example of a replacement hint");
}
/* Example of two carets where both carets appear to have an off-by-one
error appearing one column early.
Seen with gfortran.dg/associate_5.f03.
In an earlier version of the printer, the printing of caret 0 aka
"1" was suppressed due to it appearing within the leading whitespace
before the text in its line. Ensure that we at least faithfully
print both carets, at the given (erroneous) locations. */
if (0 == strcmp (fnname, "test_caret_on_leading_whitespace"))
{
const int line = fnstart_line + 3;
location_t caret_a = get_loc (line, 5);
location_t caret_b = get_loc (line - 1, 19);
rich_location richloc (line_table, caret_a);
richloc.add_range (caret_b, true);
global_dc->caret_chars[0] = '1';
global_dc->caret_chars[1] = '2';
warning_at_rich_loc (&richloc, 0, "test");
global_dc->caret_chars[0] = '^';
global_dc->caret_chars[1] = '^';
}
/* Example of using the "%q+D" format code, which as well as printing
a quoted decl, overrides the given location to use the location of
the decl. */
if (0 == strcmp (fnname, "test_percent_q_plus_d"))
{
const int line = fnstart_line + 3;
tree local = (*fun->local_decls)[0];
warning_at (input_location, 0,
"example of plus in format code for %q+D", local);
}
/* Example of many locations and many fixits.
Underline (separately) every word in a comment, and convert them
to upper case. */
if (0 == strcmp (fnname, "test_many_nested_locations"))
{
const char *file = LOCATION_FILE (fnstart);
const int start_line = fnstart_line + 2;
const int finish_line = start_line + 7;
location_t loc = get_loc (start_line - 1, 2);
rich_location richloc (line_table, loc);
for (int line = start_line; line <= finish_line; line++)
{
int line_size;
const char *content = location_get_source_line (file, line,
&line_size);
gcc_assert (content);
/* Split line up into words. */
for (int idx = 0; idx < line_size; idx++)
{
if (ISALPHA (content[idx]))
{
int start_idx = idx;
while (idx < line_size && ISALPHA (content[idx]))
idx++;
if (idx == line_size || !ISALPHA (content[idx]))
{
location_t start_of_word = get_loc (line, start_idx);
location_t end_of_word = get_loc (line, idx - 1);
location_t word
= make_location (start_of_word, start_of_word,
end_of_word);
richloc.add_range (word, true);
/* Add a fixit, converting to upper case. */
char *copy = xstrndup (content + start_idx,
idx - start_idx);
for (char *ch = copy; *ch; ch++)
*ch = TOUPPER (*ch);
richloc.add_fixit_replace (word, copy);
free (copy);
}
}
}
}
/* Verify that we added enough locations to fully exercise
rich_location. We want to exceed both the
statically-allocated buffer in class rich_location,
and then trigger a reallocation of the dynamic buffer. */
gcc_assert (richloc.get_num_locations () > 3 + (2 * 16));
warning_at_rich_loc (&richloc, 0, "test of %i locations",
richloc.get_num_locations ());
}
}
gcc_location_get_filename (gcc_location loc)
{
return LOCATION_FILE (loc.inner);
}
static void
print_rtx (const_rtx in_rtx)
{
int i = 0;
int j;
const char *format_ptr;
int is_insn;
if (sawclose)
{
if (flag_simple)
fputc (' ', outfile);
else
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
sawclose = 0;
}
if (in_rtx == 0)
{
fputs ("(nil)", outfile);
sawclose = 1;
return;
}
else if (GET_CODE (in_rtx) > NUM_RTX_CODE)
{
fprintf (outfile, "(??? bad code %d\n%s%*s)", GET_CODE (in_rtx),
print_rtx_head, indent * 2, "");
sawclose = 1;
return;
}
is_insn = INSN_P (in_rtx);
/* Print name of expression code. */
if (flag_simple && CONST_INT_P (in_rtx))
fputc ('(', outfile);
else
fprintf (outfile, "(%s", GET_RTX_NAME (GET_CODE (in_rtx)));
if (! flag_simple)
{
if (RTX_FLAG (in_rtx, in_struct))
fputs ("/s", outfile);
if (RTX_FLAG (in_rtx, volatil))
fputs ("/v", outfile);
if (RTX_FLAG (in_rtx, unchanging))
fputs ("/u", outfile);
if (RTX_FLAG (in_rtx, frame_related))
fputs ("/f", outfile);
if (RTX_FLAG (in_rtx, jump))
fputs ("/j", outfile);
if (RTX_FLAG (in_rtx, call))
fputs ("/c", outfile);
if (RTX_FLAG (in_rtx, return_val))
fputs ("/i", outfile);
/* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
if ((GET_CODE (in_rtx) == EXPR_LIST
|| GET_CODE (in_rtx) == INSN_LIST
|| GET_CODE (in_rtx) == INT_LIST)
&& (int)GET_MODE (in_rtx) < REG_NOTE_MAX)
fprintf (outfile, ":%s",
GET_REG_NOTE_NAME (GET_MODE (in_rtx)));
/* For other rtl, print the mode if it's not VOID. */
else if (GET_MODE (in_rtx) != VOIDmode)
fprintf (outfile, ":%s", GET_MODE_NAME (GET_MODE (in_rtx)));
#ifndef GENERATOR_FILE
if (GET_CODE (in_rtx) == VAR_LOCATION)
{
if (TREE_CODE (PAT_VAR_LOCATION_DECL (in_rtx)) == STRING_CST)
fputs (" <debug string placeholder>", outfile);
else
print_mem_expr (outfile, PAT_VAR_LOCATION_DECL (in_rtx));
fputc (' ', outfile);
print_rtx (PAT_VAR_LOCATION_LOC (in_rtx));
if (PAT_VAR_LOCATION_STATUS (in_rtx)
== VAR_INIT_STATUS_UNINITIALIZED)
fprintf (outfile, " [uninit]");
sawclose = 1;
i = GET_RTX_LENGTH (VAR_LOCATION);
}
#endif
}
#ifndef GENERATOR_FILE
if (CONST_DOUBLE_AS_FLOAT_P (in_rtx))
i = 5;
#endif
/* Get the format string and skip the first elements if we have handled
them already. */
format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx)) + i;
for (; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
switch (*format_ptr++)
{
const char *str;
case 'T':
str = XTMPL (in_rtx, i);
goto string;
case 'S':
case 's':
str = XSTR (in_rtx, i);
string:
if (str == 0)
fputs (" \"\"", outfile);
else
fprintf (outfile, " (\"%s\")", str);
sawclose = 1;
break;
/* 0 indicates a field for internal use that should not be printed.
An exception is the third field of a NOTE, where it indicates
that the field has several different valid contents. */
case '0':
if (i == 1 && REG_P (in_rtx))
{
if (REGNO (in_rtx) != ORIGINAL_REGNO (in_rtx))
fprintf (outfile, " [%d]", ORIGINAL_REGNO (in_rtx));
}
#ifndef GENERATOR_FILE
else if (i == 1 && GET_CODE (in_rtx) == SYMBOL_REF)
{
int flags = SYMBOL_REF_FLAGS (in_rtx);
if (flags)
fprintf (outfile, " [flags %#x]", flags);
}
else if (i == 2 && GET_CODE (in_rtx) == SYMBOL_REF)
{
tree decl = SYMBOL_REF_DECL (in_rtx);
if (decl)
print_node_brief (outfile, "", decl, dump_flags);
}
#endif
else if (i == 4 && NOTE_P (in_rtx))
{
switch (NOTE_KIND (in_rtx))
{
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
if (flag_dump_unnumbered)
fprintf (outfile, " #");
else
fprintf (outfile, " %d", NOTE_EH_HANDLER (in_rtx));
sawclose = 1;
break;
case NOTE_INSN_BLOCK_BEG:
case NOTE_INSN_BLOCK_END:
#ifndef GENERATOR_FILE
dump_addr (outfile, " ", NOTE_BLOCK (in_rtx));
#endif
sawclose = 1;
break;
case NOTE_INSN_BASIC_BLOCK:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_DELETED_LABEL:
case NOTE_INSN_DELETED_DEBUG_LABEL:
{
const char *label = NOTE_DELETED_LABEL_NAME (in_rtx);
if (label)
fprintf (outfile, " (\"%s\")", label);
else
fprintf (outfile, " \"\"");
}
break;
case NOTE_INSN_SWITCH_TEXT_SECTIONS:
{
#ifndef GENERATOR_FILE
basic_block bb = NOTE_BASIC_BLOCK (in_rtx);
if (bb != 0)
fprintf (outfile, " [bb %d]", bb->index);
#endif
break;
}
case NOTE_INSN_VAR_LOCATION:
case NOTE_INSN_CALL_ARG_LOCATION:
#ifndef GENERATOR_FILE
fputc (' ', outfile);
print_rtx (NOTE_VAR_LOCATION (in_rtx));
#endif
break;
case NOTE_INSN_CFI:
#ifndef GENERATOR_FILE
fputc ('\n', outfile);
output_cfi_directive (outfile, NOTE_CFI (in_rtx));
fputc ('\t', outfile);
#endif
break;
default:
break;
}
}
else if (i == 8 && JUMP_P (in_rtx) && JUMP_LABEL (in_rtx) != NULL)
{
/* Output the JUMP_LABEL reference. */
fprintf (outfile, "\n%s%*s -> ", print_rtx_head, indent * 2, "");
if (GET_CODE (JUMP_LABEL (in_rtx)) == RETURN)
fprintf (outfile, "return");
else if (GET_CODE (JUMP_LABEL (in_rtx)) == SIMPLE_RETURN)
fprintf (outfile, "simple_return");
else
fprintf (outfile, "%d", INSN_UID (JUMP_LABEL (in_rtx)));
}
else if (i == 0 && GET_CODE (in_rtx) == VALUE)
{
#ifndef GENERATOR_FILE
cselib_val *val = CSELIB_VAL_PTR (in_rtx);
fprintf (outfile, " %u:%u", val->uid, val->hash);
dump_addr (outfile, " @", in_rtx);
dump_addr (outfile, "/", (void*)val);
#endif
}
else if (i == 0 && GET_CODE (in_rtx) == DEBUG_EXPR)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " D#%i",
DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (in_rtx)));
#endif
}
else if (i == 0 && GET_CODE (in_rtx) == ENTRY_VALUE)
{
indent += 2;
if (!sawclose)
fprintf (outfile, " ");
print_rtx (ENTRY_VALUE_EXP (in_rtx));
indent -= 2;
}
break;
case 'e':
do_e:
indent += 2;
if (i == 7 && INSN_P (in_rtx))
/* Put REG_NOTES on their own line. */
fprintf (outfile, "\n%s%*s",
print_rtx_head, indent * 2, "");
if (!sawclose)
fprintf (outfile, " ");
print_rtx (XEXP (in_rtx, i));
indent -= 2;
break;
case 'E':
case 'V':
indent += 2;
if (sawclose)
{
fprintf (outfile, "\n%s%*s",
print_rtx_head, indent * 2, "");
sawclose = 0;
}
fputs (" [", outfile);
if (NULL != XVEC (in_rtx, i))
{
indent += 2;
if (XVECLEN (in_rtx, i))
sawclose = 1;
for (j = 0; j < XVECLEN (in_rtx, i); j++)
print_rtx (XVECEXP (in_rtx, i, j));
indent -= 2;
}
if (sawclose)
fprintf (outfile, "\n%s%*s", print_rtx_head, indent * 2, "");
fputs ("]", outfile);
sawclose = 1;
indent -= 2;
break;
case 'w':
if (! flag_simple)
fprintf (outfile, " ");
fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, XWINT (in_rtx, i));
if (! flag_simple)
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_HEX "]",
(unsigned HOST_WIDE_INT) XWINT (in_rtx, i));
break;
case 'i':
if (i == 5 && INSN_P (in_rtx))
{
#ifndef GENERATOR_FILE
/* Pretty-print insn locations. Ignore scoping as it is mostly
redundant with line number information and do not print anything
when there is no location information available. */
if (INSN_LOCATION (in_rtx) && insn_file (in_rtx))
fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
#endif
}
else if (i == 6 && GET_CODE (in_rtx) == ASM_OPERANDS)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " %s:%i",
LOCATION_FILE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)),
LOCATION_LINE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx)));
#endif
}
else if (i == 1 && GET_CODE (in_rtx) == ASM_INPUT)
{
#ifndef GENERATOR_FILE
fprintf (outfile, " %s:%i",
LOCATION_FILE (ASM_INPUT_SOURCE_LOCATION (in_rtx)),
LOCATION_LINE (ASM_INPUT_SOURCE_LOCATION (in_rtx)));
#endif
}
else if (i == 6 && NOTE_P (in_rtx))
{
/* This field is only used for NOTE_INSN_DELETED_LABEL, and
other times often contains garbage from INSN->NOTE death. */
if (NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_LABEL
|| NOTE_KIND (in_rtx) == NOTE_INSN_DELETED_DEBUG_LABEL)
fprintf (outfile, " %d", XINT (in_rtx, i));
}
#if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
else if (i == 1
&& GET_CODE (in_rtx) == UNSPEC_VOLATILE
&& XINT (in_rtx, 1) >= 0
&& XINT (in_rtx, 1) < NUM_UNSPECV_VALUES)
fprintf (outfile, " %s", unspecv_strings[XINT (in_rtx, 1)]);
#endif
#if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
else if (i == 1
&& (GET_CODE (in_rtx) == UNSPEC
|| GET_CODE (in_rtx) == UNSPEC_VOLATILE)
&& XINT (in_rtx, 1) >= 0
&& XINT (in_rtx, 1) < NUM_UNSPEC_VALUES)
fprintf (outfile, " %s", unspec_strings[XINT (in_rtx, 1)]);
#endif
else
{
int value = XINT (in_rtx, i);
const char *name;
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && (unsigned) value < FIRST_PSEUDO_REGISTER)
fprintf (outfile, " %d %s", value, reg_names[value]);
else if (REG_P (in_rtx)
&& (unsigned) value <= LAST_VIRTUAL_REGISTER)
{
if (value == VIRTUAL_INCOMING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-incoming-args", value);
else if (value == VIRTUAL_STACK_VARS_REGNUM)
fprintf (outfile, " %d virtual-stack-vars", value);
else if (value == VIRTUAL_STACK_DYNAMIC_REGNUM)
fprintf (outfile, " %d virtual-stack-dynamic", value);
else if (value == VIRTUAL_OUTGOING_ARGS_REGNUM)
fprintf (outfile, " %d virtual-outgoing-args", value);
else if (value == VIRTUAL_CFA_REGNUM)
fprintf (outfile, " %d virtual-cfa", value);
else if (value == VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM)
fprintf (outfile, " %d virtual-preferred-stack-boundary",
value);
else
fprintf (outfile, " %d virtual-reg-%d", value,
value-FIRST_VIRTUAL_REGISTER);
}
else
#endif
if (flag_dump_unnumbered
&& (is_insn || NOTE_P (in_rtx)))
fputc ('#', outfile);
else
fprintf (outfile, " %d", value);
#ifndef GENERATOR_FILE
if (REG_P (in_rtx) && REG_ATTRS (in_rtx))
{
fputs (" [", outfile);
if (ORIGINAL_REGNO (in_rtx) != REGNO (in_rtx))
fprintf (outfile, "orig:%i", ORIGINAL_REGNO (in_rtx));
if (REG_EXPR (in_rtx))
print_mem_expr (outfile, REG_EXPR (in_rtx));
if (REG_OFFSET (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
REG_OFFSET (in_rtx));
fputs (" ]", outfile);
}
#endif
if (is_insn && &INSN_CODE (in_rtx) == &XINT (in_rtx, i)
&& XINT (in_rtx, i) >= 0
&& (name = get_insn_name (XINT (in_rtx, i))) != NULL)
fprintf (outfile, " {%s}", name);
sawclose = 0;
}
break;
/* Print NOTE_INSN names rather than integer codes. */
case 'n':
fprintf (outfile, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx, i)));
sawclose = 0;
break;
case 'u':
if (XEXP (in_rtx, i) != NULL)
{
rtx sub = XEXP (in_rtx, i);
enum rtx_code subc = GET_CODE (sub);
if (GET_CODE (in_rtx) == LABEL_REF)
{
if (subc == NOTE
&& NOTE_KIND (sub) == NOTE_INSN_DELETED_LABEL)
{
if (flag_dump_unnumbered)
fprintf (outfile, " [# deleted]");
else
fprintf (outfile, " [%d deleted]", INSN_UID (sub));
sawclose = 0;
break;
}
if (subc != CODE_LABEL)
goto do_e;
}
if (flag_dump_unnumbered
|| (flag_dump_unnumbered_links && (i == 1 || i == 2)
&& (INSN_P (in_rtx) || NOTE_P (in_rtx)
|| LABEL_P (in_rtx) || BARRIER_P (in_rtx))))
fputs (" #", outfile);
else
fprintf (outfile, " %d", INSN_UID (sub));
}
else
fputs (" 0", outfile);
sawclose = 0;
break;
case 't':
#ifndef GENERATOR_FILE
if (i == 0 && GET_CODE (in_rtx) == DEBUG_IMPLICIT_PTR)
print_mem_expr (outfile, DEBUG_IMPLICIT_PTR_DECL (in_rtx));
else if (i == 0 && GET_CODE (in_rtx) == DEBUG_PARAMETER_REF)
print_mem_expr (outfile, DEBUG_PARAMETER_REF_DECL (in_rtx));
else
dump_addr (outfile, " ", XTREE (in_rtx, i));
#endif
break;
case '*':
fputs (" Unknown", outfile);
sawclose = 0;
break;
case 'B':
#ifndef GENERATOR_FILE
if (XBBDEF (in_rtx, i))
fprintf (outfile, " %i", XBBDEF (in_rtx, i)->index);
#endif
break;
default:
gcc_unreachable ();
}
switch (GET_CODE (in_rtx))
{
#ifndef GENERATOR_FILE
case MEM:
if (__builtin_expect (final_insns_dump_p, false))
fprintf (outfile, " [");
else
fprintf (outfile, " [" HOST_WIDE_INT_PRINT_DEC,
(HOST_WIDE_INT) MEM_ALIAS_SET (in_rtx));
if (MEM_EXPR (in_rtx))
print_mem_expr (outfile, MEM_EXPR (in_rtx));
if (MEM_OFFSET_KNOWN_P (in_rtx))
fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC, MEM_OFFSET (in_rtx));
if (MEM_SIZE_KNOWN_P (in_rtx))
fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC, MEM_SIZE (in_rtx));
if (MEM_ALIGN (in_rtx) != 1)
fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
if (!ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (in_rtx)))
fprintf (outfile, " AS%u", MEM_ADDR_SPACE (in_rtx));
fputc (']', outfile);
break;
case CONST_DOUBLE:
if (FLOAT_MODE_P (GET_MODE (in_rtx)))
{
char s[60];
real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " %s", s);
real_to_hexadecimal (s, CONST_DOUBLE_REAL_VALUE (in_rtx),
sizeof (s), 0, 1);
fprintf (outfile, " [%s]", s);
}
break;
#endif
case CODE_LABEL:
fprintf (outfile, " [%d uses]", LABEL_NUSES (in_rtx));
switch (LABEL_KIND (in_rtx))
{
case LABEL_NORMAL: break;
case LABEL_STATIC_ENTRY: fputs (" [entry]", outfile); break;
case LABEL_GLOBAL_ENTRY: fputs (" [global entry]", outfile); break;
case LABEL_WEAK_ENTRY: fputs (" [weak entry]", outfile); break;
default: gcc_unreachable ();
}
break;
default:
break;
}
fputc (')', outfile);
sawclose = 1;
}
static unsigned int on_execute_pass(void)
{
basic_block bb;
gimple_stmt_iterator gsi;
const char* name;
const char* file = EXPR_FILENAME(cfun->decl);
const unsigned int line = EXPR_LINENO(cfun->decl);
TRACE();
if (DECL_ASSEMBLER_NAME(cfun->decl) == NULL)
{
printf("--- skipping anonymous function\n");
return 0;
}
name = IDENTIFIER_POINTER(DECL_ASSEMBLER_NAME(cfun->decl));
#if 0 /* debug */
printf("--- passing on function: %s\n", name);
#endif
track_pragmed_func(file, line, name);
FOR_EACH_BB(bb)
{
for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi))
{
const_gimple stmt = gsi_stmt(gsi);
const enum gimple_code code = gimple_code(stmt);
if (code == GIMPLE_CALL)
{
const char* const name = get_called_name(stmt);
const tracked_func_t* const tf = find_tracked_func(name);
printf("CALL%s: %s()\n", tf ? "_TASK" : "", name);
if (tf != NULL) handle_task_call(gsi, tf);
}
#if 0 /* debug */
if (gimple_has_location(stmt))
{
const location_t loc = gimple_location(stmt);
const char* type = "STMT";
if (code == GIMPLE_CALL)
printf
(
"%s locus: .%s/%u.\n",
type, LOCATION_FILE(loc), LOCATION_LINE(loc)
);
}
#endif /* debug */
}
}
return 0;
}
static int parse_pragma_line
(struct cpp_reader* reader, pragma_type_t type)
{
pragma_expr_t* const px = alloc_add_pragma_expr();
if (px == NULL) return 0;
px->type = type;
px->file = xstrdup(LOCATION_FILE(input_location));
px->line = LOCATION_LINE(input_location);
#if 0 /* debug */
printf("pragma: %s/%u\n", px->file, px->line);
#endif
#if 0 /* TODO */
while (1)
{
/* in cpplib.h */
tree expr;
const enum cpp_ttype ttype = pragma_lex(&expr);
switch (ttype)
{
case CPP_PRAGMA_EOL:
case CPP_EOF:
goto on_done;
break ;
case CPP_COMMA:
printf(",");
break ;
case CPP_OPEN_PAREN:
printf("(");
break ;
case CPP_CLOSE_PAREN:
printf(")");
break ;
case CPP_STRING:
printf("str<%s>", TREE_STRING_POINTER(expr));
break ;
case CPP_NAME:
printf("nam<%s>", IDENTIFIER_POINTER(expr));
break ;
default:
printf("unk<%u>", ttype);
break ;
}
}
on_done:
printf("\n");
#endif /* TODO */
return 0;
}
