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.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@124094
138bc75d-0d04-0410-961f-
82ee72b054a4
+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.
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. */
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))
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
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;
}
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. */
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 ();
/* 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 ();
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;
more CONCATs anywhere. */
generating_concat_p = 0;
+ finalize_block_changes ();
+
if (dump_file)
{
fprintf (dump_file,
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;
}
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);
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);
-
-#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;
-}
+ 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");
-/* 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;
-}
+ for (insn = get_insns (); insn; insn = next)
+ {
+ int active = 0;
-/* 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;
-}
+ next = NEXT_INSN (insn);
-/* Set current scope block. */
-void
-set_curr_insn_block (tree b)
-{
- gcc_assert (curr_rtl_loc >= 0);
- if (b)
- curr_block = b;
-}
+ 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);
-/* Return current insn locator. */
-int
-curr_insn_locator (void)
-{
- if (curr_rtl_loc == -1)
- return 0;
- if (last_block != curr_block)
- {
- 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;
- }
-#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;
+ 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;
+ }
}
- 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)
{
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);
+ }
+}
\f
/* Return sope resulting from combination of S1 and S2. */
static tree
}
/* 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;
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. */
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. */
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
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;
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;
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
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);
{
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))))
/* 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
#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)
/* 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;
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;
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);
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);
/* 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 */
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 ();
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;
projects / platform / upstream / linaro-gcc.git / commitdiff