OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert: 

2007-04-23  Jan Hubicka  <jh@suse.cz>
	* function.c (init_function_start): Don't init line number info.
	(expand_function_end): Update.
	(reset_block_changes, record_block_change, finalize_block_changes,
	check_block_change, free_block_changes): Kill.
	* function.h (reset_block_changes, record_block_change,
	finalize_block_changes, check_block_change, free_block_changes): Remove
	prototypes.
	(struct function): Remove ib_boundaries_block.
	* emit-rtl.c (make_insn_raw, make_jump_insn_raw, make_call_insn_raw):
	Use curr_insn_locator to initialize locator.
	(emit_line_note): Remove.
	* cfgexpand.c (expand_gimple_cond_expr): Update.
	(construct_exit_block): Likewise.
	(tree_expand_cfg): Initialize/finalize locators.
	* expr.c (expand_expr_real): Update.
	* cfglayout.c (line_locators_locs, line_locators_lines,
	file_locators_locs, file_locators_files): Remove.
	(set_block_levels): Move to cfgexpand.c.
	(insn_locators_initialize): Remove.
	(pass_insn_locators_initialize): Remove.
	(locations_locators_locs, locations_locators_vals): New static vars.
	(curr_location, last_location, curr_block, last_block, curr_rtl_loc):
	Likewise.
	(insn_locators_alloc, insn_locators_finalize,
	set_curr_insn_source_location, set_curr_insn_block, curr_insn_locator):
	New functions.
	(locator_location): New.
	(locator_line, locator_file): Rewrite.
	* rtl.h (emit_line_note): Kill.
	(insn_locators_alloc, insn_locators_finalize,
	set_curr_insn_source_location, set_curr_insn_block, curr_insn_locator):
	Declare.
	* tree-inline.c (initialize_cfun): Do not initialize
	ib_boundaries_block.
	* passes.c (pass_insn_locators_initialize): Remove.

From-SVN: r124094
This commit is contained in:
Jan Hubicka 2007-04-24 00:05:57 +00:00 committed by Jan Hubicka
parent edc5f63bf6
commit ec9ac2bc42
11 changed files with 318 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
gcc/ChangeLog
View File

@ -1,3 +1,44 @@
2007-04-24 Jan Hubicka <j@suse.cz>
Revert:
2007-04-23 Jan Hubicka <jh@suse.cz>
* function.c (init_function_start): Don't init line number info.
(expand_function_end): Update.
(reset_block_changes, record_block_change, finalize_block_changes,
check_block_change, free_block_changes): Kill.
* function.h (reset_block_changes, record_block_change,
finalize_block_changes, check_block_change, free_block_changes): Remove
prototypes.
(struct function): Remove ib_boundaries_block.
* emit-rtl.c (make_insn_raw, make_jump_insn_raw, make_call_insn_raw):
Use curr_insn_locator to initialize locator.
(emit_line_note): Remove.
* cfgexpand.c (expand_gimple_cond_expr): Update.
(construct_exit_block): Likewise.
(tree_expand_cfg): Initialize/finalize locators.
* expr.c (expand_expr_real): Update.
* cfglayout.c (line_locators_locs, line_locators_lines,
file_locators_locs, file_locators_files): Remove.
(set_block_levels): Move to cfgexpand.c.
(insn_locators_initialize): Remove.
(pass_insn_locators_initialize): Remove.
(locations_locators_locs, locations_locators_vals): New static vars.
(curr_location, last_location, curr_block, last_block, curr_rtl_loc):
Likewise.
(insn_locators_alloc, insn_locators_finalize,
set_curr_insn_source_location, set_curr_insn_block, curr_insn_locator):
New functions.
(locator_location): New.
(locator_line, locator_file): Rewrite.
* rtl.h (emit_line_note): Kill.
(insn_locators_alloc, insn_locators_finalize,
set_curr_insn_source_location, set_curr_insn_block, curr_insn_locator):
Declare.
* tree-inline.c (initialize_cfun): Do not initialize
ib_boundaries_block.
* passes.c (pass_insn_locators_initialize): Remove.
2007-04-24 Daniel Franke <franke.daniel@gmail.com>
* doc/invoke.texi: Removed leading '-' from option index entries.

44
gcc/cfgexpand.c
View File

@ -1265,8 +1265,8 @@ expand_gimple_cond_expr (basic_block bb, tree stmt)
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
if (EXPR_LOCUS (stmt))
{
set_curr_insn_source_location (*(EXPR_LOCUS (stmt)));
set_curr_insn_block (TREE_BLOCK (stmt));
emit_line_note (*(EXPR_LOCUS (stmt)));
record_block_change (TREE_BLOCK (stmt));
}
/* These flags have no purpose in RTL land. */
@ -1281,7 +1281,7 @@ expand_gimple_cond_expr (basic_block bb, tree stmt)
add_reg_br_prob_note (last, true_edge->probability);
maybe_dump_rtl_for_tree_stmt (stmt, last);
if (EXPR_LOCUS (then_exp))
set_curr_insn_source_location (*(EXPR_LOCUS (then_exp)));
emit_line_note (*(EXPR_LOCUS (then_exp)));
return NULL;
}
if (TREE_CODE (else_exp) == GOTO_EXPR && IS_EMPTY_STMT (then_exp))
@ -1290,7 +1290,7 @@ expand_gimple_cond_expr (basic_block bb, tree stmt)
add_reg_br_prob_note (last, false_edge->probability);
maybe_dump_rtl_for_tree_stmt (stmt, last);
if (EXPR_LOCUS (else_exp))
set_curr_insn_source_location (*(EXPR_LOCUS (else_exp)));
emit_line_note (*(EXPR_LOCUS (else_exp)));
return NULL;
}
gcc_assert (TREE_CODE (then_exp) == GOTO_EXPR
@ -1322,7 +1322,7 @@ expand_gimple_cond_expr (basic_block bb, tree stmt)
maybe_dump_rtl_for_tree_stmt (stmt, last2);
if (EXPR_LOCUS (else_exp))
set_curr_insn_source_location (*(EXPR_LOCUS (else_exp)));
emit_line_note (*(EXPR_LOCUS (else_exp)));
return new_bb;
}
@ -1613,19 +1613,6 @@ construct_init_block (void)
return init_block;
}
/* For each lexical block, set BLOCK_NUMBER to the depth at which it is
found in the block tree. */
static void
set_block_levels (tree block, int level)
{
while (block)
{
BLOCK_NUMBER (block) = level;
set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
block = BLOCK_CHAIN (block);
}
}
/* Create a block containing landing pads and similar stuff. */
@ -1650,7 +1637,7 @@ construct_exit_block (void)
input_location = cfun->function_end_locus;
/* The following insns belong to the top scope. */
set_curr_insn_block (DECL_INITIAL (current_function_decl));
record_block_change (DECL_INITIAL (current_function_decl));
/* Generate rtl for function exit. */
expand_function_end ();
@ -1778,16 +1765,8 @@ tree_expand_cfg (void)
/* Some backends want to know that we are expanding to RTL. */
currently_expanding_to_rtl = 1;
insn_locators_alloc ();
if (!DECL_BUILT_IN (current_function_decl))
set_curr_insn_source_location (DECL_SOURCE_LOCATION (current_function_decl));
set_curr_insn_block (DECL_INITIAL (current_function_decl));
prologue_locator = curr_insn_locator ();
/* Make sure first insn is a note even if we don't want linenums.
This makes sure the first insn will never be deleted.
Also, final expects a note to appear there. */
emit_note (NOTE_INSN_DELETED);
/* Prepare the rtl middle end to start recording block changes. */
reset_block_changes ();
/* Mark arrays indexed with non-constant indices with TREE_ADDRESSABLE. */
discover_nonconstant_array_refs ();
@ -1834,8 +1813,6 @@ tree_expand_cfg (void)
bb = expand_gimple_basic_block (bb);
construct_exit_block ();
set_curr_insn_block (DECL_INITIAL (current_function_decl));
insn_locators_finalize ();
/* We're done expanding trees to RTL. */
currently_expanding_to_rtl = 0;
@ -1866,6 +1843,8 @@ tree_expand_cfg (void)
more CONCATs anywhere. */
generating_concat_p = 0;
finalize_block_changes ();
if (dump_file)
{
fprintf (dump_file,
@ -1896,9 +1875,6 @@ tree_expand_cfg (void)
return_label = NULL;
naked_return_label = NULL;
free_histograms ();
/* Tag the blocks with a depth number so that change_scope can find
the common parent easily. */
set_block_levels (DECL_INITIAL (cfun->decl), 0);
return 0;
}

253
gcc/cfglayout.c
View File

@ -48,6 +48,7 @@ static void record_effective_endpoints (void);
static rtx label_for_bb (basic_block);
static void fixup_reorder_chain (void);
static void set_block_levels (tree, int);
static void change_scope (rtx, tree, tree);
void verify_insn_chain (void);
@ -231,106 +232,121 @@ record_effective_endpoints (void)
than the following one. Similarly for the other properties. */
static VEC(int,heap) *block_locators_locs;
static GTY(()) VEC(tree,gc) *block_locators_blocks;
static VEC(int,heap) *locations_locators_locs;
DEF_VEC_O(location_t);
DEF_VEC_ALLOC_O(location_t,heap);
static VEC(location_t,heap) *locations_locators_vals;
static VEC(int,heap) *line_locators_locs;
static VEC(int,heap) *line_locators_lines;
static VEC(int,heap) *file_locators_locs;
static GTY(()) varray_type file_locators_files;
int prologue_locator;
int epilogue_locator;
/* Hold current location information and last location information, so the
datastructures are built lazilly only when some instructions in given
place are needed. */
location_t curr_location, last_location;
static tree curr_block, last_block;
static int curr_rtl_loc = -1;
/* During the RTL expansion the lexical blocks and line numbers are
represented via INSN_NOTEs. Replace them by representation using
INSN_LOCATORs. */
/* Allocate insn locator datastructure. */
void
insn_locators_alloc (void)
unsigned int
insn_locators_initialize (void)
{
tree block = NULL;
tree last_block = NULL;
rtx insn, next;
int loc = 0;
int line_number = 0, last_line_number = 0;
const char *file_name = NULL, *last_file_name = NULL;
prologue_locator = epilogue_locator = 0;
block_locators_locs = VEC_alloc (int, heap, 32);
block_locators_blocks = VEC_alloc (tree, gc, 32);
locations_locators_locs = VEC_alloc (int, heap, 32);
locations_locators_vals = VEC_alloc (location_t, heap, 32);
line_locators_locs = VEC_alloc (int, heap, 32);
line_locators_lines = VEC_alloc (int, heap, 32);
file_locators_locs = VEC_alloc (int, heap, 32);
VARRAY_CHAR_PTR_INIT (file_locators_files, 32, "file_locators_files");
#ifdef USE_MAPPED_LOCATION
last_location = -1;
curr_location = -1;
#else
last_location.line = -1;
curr_location.line = -1;
#endif
curr_block = NULL;
last_block = NULL;
curr_rtl_loc = 0;
}
/* At the end of emit stage, clear current location. */
void
insn_locators_finalize (void)
{
if (curr_rtl_loc >= 0)
epilogue_locator = curr_insn_locator ();
curr_rtl_loc = -1;
}
/* Set current location. */
void
set_curr_insn_source_location (location_t location)
{
gcc_assert (curr_rtl_loc >= 0);
#ifdef USE_MAPPED_LOCATION
if (location == last_location)
return;
#else
if (location.file && last_location.file
&& !strcmp (location.file, last_location.file)
&& location.line == last_location.line)
return;
#endif
curr_location = location;
}
/* Set current scope block. */
void
set_curr_insn_block (tree b)
{
gcc_assert (curr_rtl_loc >= 0);
if (b)
curr_block = b;
}
/* Return current insn locator. */
int
curr_insn_locator (void)
{
if (curr_rtl_loc == -1)
return 0;
if (last_block != curr_block)
for (insn = get_insns (); insn; insn = next)
{
curr_rtl_loc++;
VEC_safe_push (int, heap, block_locators_locs, curr_rtl_loc);
VEC_safe_push (tree, gc, block_locators_blocks, curr_block);
last_block = curr_block;
int active = 0;
next = NEXT_INSN (insn);
if (NOTE_P (insn))
{
gcc_assert (NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_BEG
&& NOTE_LINE_NUMBER (insn) != NOTE_INSN_BLOCK_END);
if (NOTE_LINE_NUMBER (insn) > 0)
{
expanded_location xloc;
NOTE_EXPANDED_LOCATION (xloc, insn);
line_number = xloc.line;
file_name = xloc.file;
delete_insn (insn);
}
}
else
active = (active_insn_p (insn)
&& GET_CODE (PATTERN (insn)) != ADDR_VEC
&& GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC);
check_block_change (insn, &block);
if (active
|| !next
|| (!prologue_locator && file_name))
{
if (last_block != block)
{
loc++;
VEC_safe_push (int, heap, block_locators_locs, loc);
VEC_safe_push (tree, gc, block_locators_blocks, block);
last_block = block;
}
if (last_line_number != line_number)
{
loc++;
VEC_safe_push (int, heap, line_locators_locs, loc);
VEC_safe_push (int, heap, line_locators_lines, line_number);
last_line_number = line_number;
}
if (last_file_name != file_name)
{
loc++;
VEC_safe_push (int, heap, file_locators_locs, loc);
VARRAY_PUSH_CHAR_PTR (file_locators_files, (char *) file_name);
last_file_name = file_name;
}
if (!prologue_locator && file_name)
prologue_locator = loc;
if (!next)
epilogue_locator = loc;
if (active)
INSN_LOCATOR (insn) = loc;
}
}
#ifdef USE_MAPPED_LOCATION
if (last_location != curr_location)
#else
if (last_location.file != curr_location.file
|| last_location.line != curr_location.line)
#endif
{
curr_rtl_loc++;
VEC_safe_push (int, heap, locations_locators_locs, curr_rtl_loc);
VEC_safe_push (location_t, heap, locations_locators_vals, &curr_location);
last_location = curr_location;
}
return curr_rtl_loc;
/* Tag the blocks with a depth number so that change_scope can find
the common parent easily. */
set_block_levels (DECL_INITIAL (cfun->decl), 0);
free_block_changes ();
return 0;
}
struct tree_opt_pass pass_insn_locators_initialize =
{
"locators", /* name */
NULL, /* gate */
insn_locators_initialize, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
0, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
TODO_dump_func, /* todo_flags_finish */
0 /* letter */
};
static unsigned int
into_cfg_layout_mode (void)
{
@ -385,6 +401,20 @@ struct tree_opt_pass pass_outof_cfg_layout_mode =
TODO_dump_func, /* todo_flags_finish */
0 /* letter */
};
/* For each lexical block, set BLOCK_NUMBER to the depth at which it is
found in the block tree. */
static void
set_block_levels (tree block, int level)
{
while (block)
{
BLOCK_NUMBER (block) = level;
set_block_levels (BLOCK_SUBBLOCKS (block), level + 1);
block = BLOCK_CHAIN (block);
}
}
/* Return sope resulting from combination of S1 and S2. */
static tree
@ -484,16 +514,18 @@ insn_scope (rtx insn)
}
/* Return line number of the statement specified by the locator. */
static location_t
locator_location (int loc)
int
locator_line (int loc)
{
int max = VEC_length (int, locations_locators_locs);
int max = VEC_length (int, line_locators_locs);
int min = 0;
if (!max || !loc)
return 0;
while (1)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, locations_locators_locs, pos);
int tmp = VEC_index (int, line_locators_locs, pos);
if (tmp <= loc && min != pos)
min = pos;
@ -505,19 +537,7 @@ locator_location (int loc)
break;
}
}
return *VEC_index (location_t, locations_locators_vals, min);
}
/* Return source line of the statement that produced this insn. */
int
locator_line (int loc)
{
expanded_location xloc;
if (!loc)
return 0;
else
xloc = expand_location (locator_location (loc));
return xloc.line;
return VEC_index (int, line_locators_lines, min);
}
/* Return line number of the statement that produced this insn. */
@ -531,12 +551,27 @@ insn_line (rtx insn)
const char *
locator_file (int loc)
{
expanded_location xloc;
if (!loc)
return 0;
else
xloc = expand_location (locator_location (loc));
return xloc.file;
int max = VEC_length (int, file_locators_locs);
int min = 0;
if (!max || !loc)
return NULL;
while (1)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, file_locators_locs, pos);
if (tmp <= loc && min != pos)
min = pos;
else if (tmp > loc && max != pos)
max = pos;
else
{
min = pos;
break;
}
}
return VARRAY_CHAR_PTR (file_locators_files, min);
}
/* Return source file of the statement that produced this insn. */

42
gcc/emit-rtl.c
View File

@ -3336,7 +3336,7 @@ make_insn_raw (rtx pattern)
INSN_CODE (insn) = -1;
LOG_LINKS (insn) = NULL;
REG_NOTES (insn) = NULL;
INSN_LOCATOR (insn) = curr_insn_locator ();
INSN_LOCATOR (insn) = 0;
BLOCK_FOR_INSN (insn) = NULL;
#ifdef ENABLE_RTL_CHECKING
@ -3369,7 +3369,7 @@ make_jump_insn_raw (rtx pattern)
LOG_LINKS (insn) = NULL;
REG_NOTES (insn) = NULL;
JUMP_LABEL (insn) = NULL;
INSN_LOCATOR (insn) = curr_insn_locator ();
INSN_LOCATOR (insn) = 0;
BLOCK_FOR_INSN (insn) = NULL;
return insn;
@ -3390,7 +3390,7 @@ make_call_insn_raw (rtx pattern)
LOG_LINKS (insn) = NULL;
REG_NOTES (insn) = NULL;
CALL_INSN_FUNCTION_USAGE (insn) = NULL;
INSN_LOCATOR (insn) = curr_insn_locator ();
INSN_LOCATOR (insn) = 0;
BLOCK_FOR_INSN (insn) = NULL;
return insn;
@ -4460,6 +4460,42 @@ emit_barrier (void)
return barrier;
}
/* Make line numbering NOTE insn for LOCATION add it to the end
of the doubly-linked list, but only if line-numbers are desired for
debugging info and it doesn't match the previous one. */
rtx
emit_line_note (location_t location)
{
rtx note;
#ifdef USE_MAPPED_LOCATION
if (location == last_location)
return NULL_RTX;
#else
if (location.file && last_location.file
&& !strcmp (location.file, last_location.file)
&& location.line == last_location.line)
return NULL_RTX;
#endif
last_location = location;
if (no_line_numbers)
{
cur_insn_uid++;
return NULL_RTX;
}
#ifdef USE_MAPPED_LOCATION
note = emit_note ((int) location);
#else
note = emit_note (location.line);
NOTE_SOURCE_FILE (note) = location.file;
#endif
return note;
}
/* Emit a copy of note ORIG. */
rtx

6
gcc/expr.c
View File

@ -6777,14 +6777,14 @@ expand_expr_real (tree exp, rtx target, enum machine_mode tmode,
information. It would be better of the diagnostic routines
used the file/line information embedded in the tree nodes rather
than globals. */
if (cfun && EXPR_HAS_LOCATION (exp))
if (cfun && cfun->ib_boundaries_block && EXPR_HAS_LOCATION (exp))
{
location_t saved_location = input_location;
input_location = EXPR_LOCATION (exp);
set_curr_insn_source_location (input_location);
emit_line_note (input_location);
/* Record where the insns produced belong. */
set_curr_insn_block (TREE_BLOCK (exp));
record_block_change (TREE_BLOCK (exp));
ret = expand_expr_real_1 (exp, target, tmode, modifier, alt_rtl);

70
gcc/function.c
View File

@ -3843,6 +3843,18 @@ init_function_start (tree subr)
{
prepare_function_start (subr);
/* Prevent ever trying to delete the first instruction of a
function. Also tell final how to output a linenum before the
function prologue. Note linenums could be missing, e.g. when
compiling a Java .class file. */
if (! DECL_IS_BUILTIN (subr))
emit_line_note (DECL_SOURCE_LOCATION (subr));
/* Make sure first insn is a note even if we don't want linenums.
This makes sure the first insn will never be deleted.
Also, final expects a note to appear there. */
emit_note (NOTE_INSN_DELETED);
/* Warn if this value is an aggregate type,
regardless of which calling convention we are using for it. */
if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
@ -4293,7 +4305,7 @@ expand_function_end (void)
/* Output a linenumber for the end of the function.
SDB depends on this. */
force_next_line_note ();
set_curr_insn_source_location (input_location);
emit_line_note (input_location);
/* Before the return label (if any), clobber the return
registers so that they are not propagated live to the rest of
@ -5336,6 +5348,62 @@ reposition_prologue_and_epilogue_notes (rtx f ATTRIBUTE_UNUSED)
#endif /* HAVE_prologue or HAVE_epilogue */
}
/* Resets insn_block_boundaries array. */
void
reset_block_changes (void)
{
cfun->ib_boundaries_block = VEC_alloc (tree, gc, 100);
VEC_quick_push (tree, cfun->ib_boundaries_block, NULL_TREE);
}
/* Record the boundary for BLOCK. */
void
record_block_change (tree block)
{
int i, n;
tree last_block;
if (!block)
return;
if(!cfun->ib_boundaries_block)
return;
last_block = VEC_pop (tree, cfun->ib_boundaries_block);
n = get_max_uid ();
for (i = VEC_length (tree, cfun->ib_boundaries_block); i < n; i++)
VEC_safe_push (tree, gc, cfun->ib_boundaries_block, last_block);
VEC_safe_push (tree, gc, cfun->ib_boundaries_block, block);
}
/* Finishes record of boundaries. */
void
finalize_block_changes (void)
{
record_block_change (DECL_INITIAL (current_function_decl));
}
/* For INSN return the BLOCK it belongs to. */
void
check_block_change (rtx insn, tree *block)
{
unsigned uid = INSN_UID (insn);
if (uid >= VEC_length (tree, cfun->ib_boundaries_block))
return;
*block = VEC_index (tree, cfun->ib_boundaries_block, uid);
}
/* Releases the ib_boundaries_block records. */
void
free_block_changes (void)
{
VEC_free (tree, gc, cfun->ib_boundaries_block);
}
/* Returns the name of the current function. */
const char *
current_function_name (void)

8
gcc/function.h
View File

@ -347,6 +347,9 @@ struct function GTY(())
/* Line number of the end of the function. */
location_t function_end_locus;
/* Array mapping insn uids to blocks. */
VEC(tree,gc) *ib_boundaries_block;
/* The variables unexpanded so far. */
tree unexpanded_var_list;
@ -549,6 +552,11 @@ extern void number_blocks (tree);
extern void clear_block_marks (tree);
extern tree blocks_nreverse (tree);
extern void reset_block_changes (void);
extern void record_block_change (tree);
extern void finalize_block_changes (void);
extern void check_block_change (rtx, tree *);
extern void free_block_changes (void);
/* Return size needed for stack frame based on slots so far allocated.
This size counts from zero. It is not rounded to STACK_BOUNDARY;

1
gcc/passes.c
View File

@ -654,6 +654,7 @@ init_optimization_passes (void)
struct tree_opt_pass **p = &pass_rest_of_compilation.sub;
NEXT_PASS (pass_init_function);
NEXT_PASS (pass_jump);
NEXT_PASS (pass_insn_locators_initialize);
NEXT_PASS (pass_rtl_eh);
NEXT_PASS (pass_initial_value_sets);
NEXT_PASS (pass_unshare_all_rtl);

7
gcc/rtl.h
View File

@ -1562,6 +1562,7 @@ extern rtx emit_label (rtx);
extern rtx emit_barrier (void);
extern rtx emit_note (int);
extern rtx emit_note_copy (rtx);
extern rtx emit_line_note (location_t);
extern rtx make_insn_raw (rtx);
extern rtx make_jump_insn_raw (rtx);
extern void add_function_usage_to (rtx, rtx);
@ -2297,10 +2298,4 @@ extern const struct rtl_hooks general_rtl_hooks;
/* Keep this for the nonce. */
#define gen_lowpart rtl_hooks.gen_lowpart
extern void insn_locators_alloc (void);
extern void insn_locators_finalize (void);
extern void set_curr_insn_source_location (location_t);
extern void set_curr_insn_block (tree);
extern int curr_insn_locator (void);
#endif /* ! GCC_RTL_H */

1
gcc/tree-inline.c
View File

@ -1117,6 +1117,7 @@ initialize_cfun (tree new_fndecl, tree callee_fndecl, gcov_type count,
new_cfun->unexpanded_var_list = NULL;
new_cfun->cfg = NULL;
new_cfun->decl = new_fndecl /*= copy_node (callee_fndecl)*/;
new_cfun->ib_boundaries_block = NULL;
DECL_STRUCT_FUNCTION (new_fndecl) = new_cfun;
push_cfun (new_cfun);
init_empty_tree_cfg ();

1
gcc/tree-pass.h
View File

@ -329,6 +329,7 @@ extern struct tree_opt_pass pass_fixup_cfg;
extern struct tree_opt_pass pass_init_function;
extern struct tree_opt_pass pass_jump;
extern struct tree_opt_pass pass_insn_locators_initialize;
extern struct tree_opt_pass pass_rtl_eh;
extern struct tree_opt_pass pass_initial_value_sets;
extern struct tree_opt_pass pass_unshare_all_rtl;