+2000-02-27 Mark Mitchell <mark@codesourcery.com>
+
+ * emit-rtl.c (remove_unncessary_notes): Remove notes for empty
+ blocks.
+ * final.c (next_block_index): Remove.
+ (max_block_depth): Likewise.
+ (pending_blocks): Likewise.
+ (init_final): Don't initialize them.
+ (final_start_function): Don't set next_block_index. Set up
+ BLOCK_NUMBER.
+ (final_scan_insn): Use BLOCK_NUMBER, not next_block_index.
+ * function.h (number_blocks): New function.
+ * function.c (get_block_vector): New function.
+ (identify_blocks): Use it.
+ (reorder_blocks): Set NOTE_BLOCK.
+ (number_blocks): New function.
+ * tree.def (BLOCK): Add documentation for TREE_ASM_WRITTEN flag.
+ * tree.h (BLOCK_NUMBER): New macro.
+ (tree_block): Add block_num field.
+ * dbxout.c (next_block_number): Remove.
+ (dbxout_init): Don't set it.
+ (dbxout_block): Only output blocks that have TREE_ASM_WRITTEN
+ set. Use BLOCK_NUMBER, rather than next_block_num, to determine
+ block numbers.
+ * toplev.c (rest_of_compilation): Always call
+ find_loop_tree_blocks. Fix indentation.
+ * dwarf2out.c (next_block_number): Remove.
+ (gen_lexical_block_die): Use BLOCK_NUMBER, not next_block_number,
+ to determine block numbers.
+ (gen_inlined_subroutine_die): Likewise.
+ (gen_block_die): Only output blocks that have TREE_ASM_WRITTEN set.
+ (decls_for_scope): Don't increment next_block_number.
+ * dwarfout.c (next_block_number): Remove.
+ (output_lexical_block_die): Use BLOCK_NUMBER, not next_block_number,
+ to determine block numbers.
+ (output_inlined_subroutine_die): Likewise.
+ (output_block): Only output blocks that have TREE_ASM_WRITTEN set.
+ (output_decls_for_scope): Don't increment next_block_number.
+ * sdbout.c (next_block_number): Remove.
+ (sdbout_block): Use BLOCK_NUMBER.
+ (sdbout_begin_block): Simplify.
+ * xcoffout.c (next_block_number): Remove.
+ (xcoffout_block): Use BLOCK_NUMBER, not next_block_number.
+ (xcoffout_begin_block): Don't set next_block_number.
+ (xcoffout_begin_function): Likewise. Use BLOCK_NUMBER, not
+ next_block_number.
+
Sun Feb 27 16:40:33 2000 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* builtins.c (c_strlen): Use size_diffop and return ssizetype value.
#endif /* DBX_USE_BINCL */
-/* In dbx output, we must assign symbol-blocks id numbers
- in the order in which their beginnings are encountered.
- We output debugging info that refers to the beginning and
- end of the ranges of code in each block
- with assembler labels LBBn and LBEn, where n is the block number.
- The labels are generated in final, which assigns numbers to the
- blocks in the same way. */
-
-static int next_block_number;
-
/* These variables are for dbxout_symbol to communicate to
dbxout_finish_symbol.
current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
lastfile = input_file_name;
next_type_number = 1;
- next_block_number = 2;
#ifdef DBX_USE_BINCL
current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
while (block)
{
/* Ignore blocks never expanded or otherwise marked as real. */
- if (TREE_USED (block))
+ if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
{
#ifndef DBX_LBRAC_FIRST
/* In dbx format, the syms of a block come before the N_LBRAC. */
if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
{
char buf[20];
- blocknum = next_block_number++;
+ blocknum = BLOCK_NUMBER (block);
ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
if (BLOCK_HANDLER_BLOCK (block))
fprintf (asmfile, "\n");
#endif
}
- else if (depth > 0)
- /* Count blocks the same way regardless of debug_info_level. */
- next_block_number++;
#ifdef DBX_LBRAC_FIRST
/* On some weird machines, the syms of a block
dwarf2out_init. */
static char *primary_filename;
-/* For Dwarf output, we must assign lexical-blocks id numbers in the order in
- which their beginnings are encountered. We output Dwarf debugging info
- that refers to the beginnings and ends of the ranges of code for each
- lexical block. The labels themselves are generated in final.c, which
- assigns numbers to the blocks in the same way. */
-static unsigned next_block_number = 2;
-
/* A pointer to the base of a table of references to DIE's that describe
declarations. The table is indexed by DECL_UID() which is a unique
number identifying each decl. */
if (! BLOCK_ABSTRACT (stmt))
{
ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
- next_block_number);
+ BLOCK_NUMBER (stmt));
add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
- ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
+ ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
+ BLOCK_NUMBER (stmt));
add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
}
add_abstract_origin_attribute (subr_die, decl);
ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
- next_block_number);
+ BLOCK_NUMBER (stmt));
add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
- ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
+ ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
+ BLOCK_NUMBER (stmt));
add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
decls_for_scope (stmt, subr_die, depth);
current_function_has_inlines = 1;
/* Ignore blocks never really used to make RTL. */
- if (stmt == NULL_TREE || !TREE_USED (stmt))
+ if (stmt == NULL_TREE || !TREE_USED (stmt) || !TREE_ASM_WRITTEN (stmt))
return;
/* Determine the "ultimate origin" of this block. This block may be an
if (stmt == NULL_TREE || ! TREE_USED (stmt))
return;
- if (!BLOCK_ABSTRACT (stmt) && depth > 0)
- next_block_number++;
-
/* Output the DIEs to represent all of the data objects and typedefs
declared directly within this block but not within any nested
sub-blocks. Also, nested function and tag DIEs have been
static char *last_filename;
-/* For Dwarf output, we must assign lexical-blocks id numbers
- in the order in which their beginnings are encountered.
- We output Dwarf debugging info that refers to the beginnings
- and ends of the ranges of code for each lexical block with
- assembler labels ..Bn and ..Bn.e, where n is the block number.
- The labels themselves are generated in final.c, which assigns
- numbers to the blocks in the same way. */
-
-static unsigned next_block_number = 2;
-
/* Counter to generate unique names for DIEs. */
static unsigned next_unused_dienum = 1;
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
+ sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
+ sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
high_pc_attribute (end_label);
}
}
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
- sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
+ sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, BLOCK_NUMBER (stmt));
low_pc_attribute (begin_label);
- sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
+ sprintf (end_label, BLOCK_END_LABEL_FMT, BLOCK_NUMBER (stmt));
high_pc_attribute (end_label);
}
}
/* Ignore blocks never really used to make RTL. */
- if (! stmt || ! TREE_USED (stmt))
+ if (! stmt || ! TREE_USED (stmt) || !TREE_ASM_WRITTEN (stmt))
return;
/* Determine the "ultimate origin" of this block. This block may be an
if (! stmt || ! TREE_USED (stmt))
return;
- if (! BLOCK_ABSTRACT (stmt) && depth > 0)
- next_block_number++;
-
/* Output the DIEs to represent all of the data objects, functions,
typedefs, and tagged types declared directly within this block
but not within any nested sub-blocks. */
if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
remove_insn (insn);
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ {
+ /* Scan back to see if there are any non-note instructions
+ between INSN and the beginning of this block. If not,
+ then there is no PC range in the generated code that will
+ actually be in this block, so there's no point in
+ remembering the existence of the block. */
+ rtx prev;
+
+ for (prev = PREV_INSN (insn); prev; prev = PREV_INSN (prev))
+ {
+ /* This block contains a real instruction. Note that we
+ don't include labels; if the only thing in the block
+ is a label, then there are still no PC values that
+ lie within the block. */
+ if (GET_RTX_CLASS (GET_CODE (prev)) == 'i')
+ break;
+
+ /* We're only interested in NOTEs. */
+ if (GET_CODE (prev) != NOTE)
+ continue;
+
+ if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_BLOCK_BEG)
+ {
+ /* If the BLOCKs referred to by these notes don't
+ match, then something is wrong with our BLOCK
+ nesting structure. */
+ if (NOTE_BLOCK (prev) != NOTE_BLOCK (insn))
+ abort ();
+
+ remove_insn (prev);
+ remove_insn (insn);
+ break;
+ }
+ else if (NOTE_LINE_NUMBER (prev) == NOTE_INSN_BLOCK_END)
+ /* There's a nested block. We need to leave the
+ current block in place since otherwise the debugger
+ wouldn't be able to show symbols from our block in
+ the nested block. */
+ break;
+ }
+ }
}
}
static int new_block = 1;
-/* All the symbol-blocks (levels of scoping) in the compilation
- are assigned sequence numbers in order of appearance of the
- beginnings of the symbol-blocks. Both final and dbxout do this,
- and assume that they will both give the same number to each block.
- Final uses these sequence numbers to generate assembler label names
- LBBnnn and LBEnnn for the beginning and end of the symbol-block.
- Dbxout uses the sequence numbers to generate references to the same labels
- from the dbx debugging information.
-
- Sdb records this level at the beginning of each function,
- in order to find the current level when recursing down declarations.
- It outputs the block beginning and endings
- at the point in the asm file where the blocks would begin and end. */
-
-int next_block_index;
-
/* Assign a unique number to each insn that is output.
This can be used to generate unique local labels. */
int profile_label_no;
-/* Length so far allocated in PENDING_BLOCKS. */
-
-static int max_block_depth;
-
-/* Stack of sequence numbers of symbol-blocks of which we have seen the
- beginning but not yet the end. Sequence numbers are assigned at
- the beginning; this stack allows us to find the sequence number
- of a block that is ending. */
-
-static int *pending_blocks;
-
-/* Number of elements currently in use in PENDING_BLOCKS. */
+/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
static int block_depth;
init_final (filename)
const char *filename ATTRIBUTE_UNUSED;
{
- next_block_index = 2;
app_on = 0;
- max_block_depth = 20;
- pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks);
final_sequence = 0;
#ifdef ASSEMBLER_DIALECT
dwarf2out_frame_debug (NULL_RTX);
#endif
+ /* If debugging, assign block numbers to all of the blocks in this
+ function. */
+ if (write_symbols)
+ {
+ number_blocks (current_function_decl);
+ remove_unncessary_notes ();
+ /* We never actually put out begin/end notes for the top-level
+ block in the function. But, conceptually, that block is
+ always needed. */
+ TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
+ }
+
#ifdef FUNCTION_PROLOGUE
/* First output the function prologue: code to set up the stack frame. */
FUNCTION_PROLOGUE (file, get_frame_size ());
#endif
-#if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
- if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
- next_block_index = 1;
-#endif
-
/* If the machine represents the prologue as RTL, the profiling code must
be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
#ifdef HAVE_prologue
|| write_symbols == DWARF_DEBUG
|| write_symbols == DWARF2_DEBUG))
{
- /* Beginning of a symbol-block. Assign it a sequence number
- and push the number onto the stack PENDING_BLOCKS. */
-
- if (block_depth == max_block_depth)
- {
- /* PENDING_BLOCKS is full; make it longer. */
- max_block_depth *= 2;
- pending_blocks
- = (int *) xrealloc (pending_blocks,
- max_block_depth * sizeof (int));
- }
- pending_blocks[block_depth++] = next_block_index;
+ int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
+ ++block_depth;
high_block_linenum = last_linenum;
/* Output debugging info about the symbol-block beginning. */
-
#ifdef SDB_DEBUGGING_INFO
if (write_symbols == SDB_DEBUG)
- sdbout_begin_block (file, last_linenum, next_block_index);
+ sdbout_begin_block (file, last_linenum, n);
#endif
#ifdef XCOFF_DEBUGGING_INFO
if (write_symbols == XCOFF_DEBUG)
- xcoffout_begin_block (file, last_linenum, next_block_index);
+ xcoffout_begin_block (file, last_linenum, n);
#endif
#ifdef DBX_DEBUGGING_INFO
if (write_symbols == DBX_DEBUG)
- ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", n);
#endif
#ifdef DWARF_DEBUGGING_INFO
if (write_symbols == DWARF_DEBUG)
- dwarfout_begin_block (next_block_index);
+ dwarfout_begin_block (n);
#endif
#ifdef DWARF2_DEBUGGING_INFO
if (write_symbols == DWARF2_DEBUG)
- dwarf2out_begin_block (next_block_index);
+ dwarf2out_begin_block (n);
#endif
- next_block_index++;
+ /* Mark this block as output. */
+ TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
}
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
&& (debug_info_level == DINFO_LEVEL_NORMAL
|| write_symbols == DWARF_DEBUG
|| write_symbols == DWARF2_DEBUG))
{
- /* End of a symbol-block. Pop its sequence number off
- PENDING_BLOCKS and output debugging info based on that. */
+ int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
+
+ /* End of a symbol-block. */
--block_depth;
if (block_depth < 0)
#ifdef XCOFF_DEBUGGING_INFO
if (write_symbols == XCOFF_DEBUG)
- xcoffout_end_block (file, high_block_linenum,
- pending_blocks[block_depth]);
+ xcoffout_end_block (file, high_block_linenum, n);
#endif
#ifdef DBX_DEBUGGING_INFO
if (write_symbols == DBX_DEBUG)
- ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
- pending_blocks[block_depth]);
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LBE", n);
#endif
#ifdef SDB_DEBUGGING_INFO
if (write_symbols == SDB_DEBUG)
- sdbout_end_block (file, high_block_linenum,
- pending_blocks[block_depth]);
+ sdbout_end_block (file, high_block_linenum, n);
#endif
#ifdef DWARF_DEBUGGING_INFO
if (write_symbols == DWARF_DEBUG)
- dwarfout_end_block (pending_blocks[block_depth]);
+ dwarfout_end_block (n);
#endif
#ifdef DWARF2_DEBUGGING_INFO
if (write_symbols == DWARF2_DEBUG)
- dwarf2out_end_block (pending_blocks[block_depth]);
+ dwarf2out_end_block (n);
#endif
}
else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL
static rtx round_trampoline_addr PARAMS ((rtx));
static tree blocks_nreverse PARAMS ((tree));
static int all_blocks PARAMS ((tree, tree *));
+static tree *get_block_vector PARAMS ((tree, int *));
/* We always define `record_insns' even if its not used so that we
can always export `prologue_epilogue_contains'. */
static int *record_insns PARAMS ((rtx)) ATTRIBUTE_UNUSED;
/* Fill the BLOCK_VECTOR with all of the BLOCKs in this function, in
depth-first order. */
- n_blocks = all_blocks (block, 0);
- block_vector = (tree *) xmalloc (n_blocks * sizeof (tree));
- all_blocks (block, block_vector);
-
+ block_vector = get_block_vector (block, &n_blocks);
block_stack = (tree *) xmalloc (n_blocks * sizeof (tree));
for (insn = insns; insn; insn = NEXT_INSN (insn))
}
}
- /* In whole-function mode, we might not have seen the whole function
- yet, so we might not use up all the blocks. */
- if (n_blocks != current_block_number
- && !cfun->x_whole_function_mode_p)
- abort ();
-
free (block_vector);
free (block_stack);
}
{
tree current_block = block;
rtx insn;
+ varray_type block_stack;
if (block == NULL_TREE)
return NULL_TREE;
+ VARRAY_TREE_INIT (block_stack, 10, "block_stack");
+
/* Prune the old trees away, so that it doesn't get in the way. */
BLOCK_SUBBLOCKS (current_block) = 0;
BLOCK_CHAIN (current_block) = 0;
tree block = NOTE_BLOCK (insn);
/* If we have seen this block before, copy it. */
if (TREE_ASM_WRITTEN (block))
- block = copy_node (block);
+ {
+ block = copy_node (block);
+ NOTE_BLOCK (insn) = block;
+ }
BLOCK_SUBBLOCKS (block) = 0;
TREE_ASM_WRITTEN (block) = 1;
BLOCK_SUPERCONTEXT (block) = current_block;
BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
BLOCK_SUBBLOCKS (current_block) = block;
current_block = block;
+ VARRAY_PUSH_TREE (block_stack, block);
}
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
+ else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
{
+ NOTE_BLOCK (insn) = VARRAY_TOP_TREE (block_stack);
+ VARRAY_POP (block_stack);
BLOCK_SUBBLOCKS (current_block)
= blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
current_block = BLOCK_SUPERCONTEXT (current_block);
BLOCK_SUBBLOCKS (current_block)
= blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
+
+ VARRAY_FREE (block_stack);
+
return current_block;
}
return prev;
}
-/* Count the subblocks of the list starting with BLOCK, and list them
- all into the vector VECTOR. Also clear TREE_ASM_WRITTEN in all
+/* Count the subblocks of the list starting with BLOCK. If VECTOR is
+ non-NULL, list them all into VECTOR, in a depth-first preorder
+ traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
blocks. */
static int
return n_blocks;
}
+
+/* Return a vector containing all the blocks rooted at BLOCK. The
+ number of elements in the vector is stored in N_BLOCKS_P. The
+ vector is dynamically allocated; it is the caller's responsibility
+ to call `free' on the pointer returned. */
+
+static tree *
+get_block_vector (block, n_blocks_p)
+ tree block;
+ int *n_blocks_p;
+{
+ tree *block_vector;
+
+ *n_blocks_p = all_blocks (block, NULL);
+ block_vector = (tree *) xmalloc (*n_blocks_p * sizeof (tree));
+ all_blocks (block, block_vector);
+
+ return block_vector;
+}
+
+static int next_block_index = 2;
+
+/* Set BLOCK_NUMBER for all the blocks in FN. */
+
+void
+number_blocks (fn)
+ tree fn;
+{
+ int i;
+ int n_blocks;
+ tree *block_vector;
+
+ /* For SDB and XCOFF debugging output, we start numbering the blocks
+ from 1 within each function, rather than keeping a running
+ count. */
+#if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
+ next_block_index = 1;
+#endif
+
+ block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
+
+ /* The top-level BLOCK isn't numbered at all. */
+ for (i = 1; i < n_blocks; ++i)
+ /* We number the blocks from two. */
+ BLOCK_NUMBER (block_vector[i]) = next_block_index++;
+
+ free (block_vector);
+
+ return;
+}
+
\f
/* Allocate a function structure and reset its contents to the defaults. */
static void
the index of that block in the vector. */
extern void identify_blocks PARAMS ((tree, rtx));
+/* Set BLOCK_NUMBER for all the blocks in FN. */
+extern void number_blocks PARAMS ((tree));
+
/* Return size needed for stack frame based on slots so far allocated.
This size counts from zero. It is not rounded to STACK_BOUNDARY;
the caller may have to do that. */
}
\f
/* Output the symbols defined in block number DO_BLOCK.
- Set NEXT_BLOCK_NUMBER to 0 before calling.
This function works by walking the tree structure of blocks,
counting blocks until it finds the desired block. */
static int do_block = 0;
-static int next_block_number;
-
static void
sdbout_block (block)
register tree block;
if (TREE_USED (block))
{
/* When we reach the specified block, output its symbols. */
- if (next_block_number == do_block)
- {
- sdbout_syms (BLOCK_VARS (block));
- }
+ if (BLOCK_NUMBER (block) == do_block)
+ sdbout_syms (BLOCK_VARS (block));
/* If we are past the specified block, stop the scan. */
- if (next_block_number > do_block)
+ if (BLOCK_NUMBER (block) > do_block)
return;
- next_block_number++;
-
/* Scan the blocks within this block. */
sdbout_block (BLOCK_SUBBLOCKS (block));
}
if (n == 1)
{
/* Include the outermost BLOCK's variables in block 1. */
- next_block_number = 0;
- do_block = 0;
+ do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
sdbout_block (DECL_INITIAL (decl));
}
/* If -g1, suppress all the internal symbols of functions
except for arguments. */
if (debug_info_level != DINFO_LEVEL_TERSE)
{
- next_block_number = 0;
do_block = n;
sdbout_block (DECL_INITIAL (decl));
}
collector to reclaim the memory used by the notes. */
remove_unncessary_notes ();
+ /* We need to make sure that NOTE_BLOCK is set correctly
+ for each NOTE_INSN_BLOCK_BEG/NOTE_INSN_BLOCK_END note. */
+ find_loop_tree_blocks ();
/* In function-at-a-time mode, we do not attempt to keep the BLOCK
tree in sensible shape. So, we just recalculate it here. */
if (cfun->x_whole_function_mode_p)
- {
- find_loop_tree_blocks ();
- unroll_block_trees ();
- }
+ unroll_block_trees ();
/* If we are reconsidering an inline function
at the end of compilation, skip the stuff for making it inline. */
regset_release_memory ();
});
- if (ggc_p)
- ggc_collect ();
+ if (ggc_p)
+ ggc_collect ();
/* Write DBX symbols if requested */
/* This file contains the definitions and documentation for the
tree codes used in the GNU C compiler.
- Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1993, 1995, 1997, 1998, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
outermost scope of a particular inlining of a function).
BLOCK_ABSTRACT is non-zero if the block represents an abstract
instance of a block (i.e. one which is nested within an abstract
- instance of an inline function). */
+ instance of an inline function).
+ TREE_ASM_WRITTEN is non-zero if the block was actually referenced
+ in the generated assembly. */
DEFTREECODE (BLOCK, "block", 'b', 0)
\f
/* Each data type is represented by a tree node whose code is one of
listed in the BLOCK_VARS slot. */
#define BLOCK_HANDLER_BLOCK(NODE) (BLOCK_CHECK (NODE)->block.handler_block_flag)
+/* An index number for this block. These values are not guaranteed to
+ be unique across functions -- whether or not they are depends on
+ the debugging output format in use. */
+#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
+
struct tree_block
{
char common[sizeof (struct tree_common)];
unsigned handler_block_flag : 1;
unsigned abstract_flag : 1;
+ unsigned block_num : 30;
union tree_node *vars;
union tree_node *subblocks;
}
\f
/* Output the symbols defined in block number DO_BLOCK.
- Set NEXT_BLOCK_NUMBER to 0 before calling.
This function works by walking the tree structure of blocks,
counting blocks until it finds the desired block. */
static int do_block = 0;
-static int next_block_number;
-
static void
xcoffout_block (block, depth, args)
register tree block;
if (TREE_USED (block))
{
/* When we reach the specified block, output its symbols. */
- if (next_block_number == do_block)
+ if (BLOCK_NUMBER (block) == do_block)
{
/* Output the syms of the block. */
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
return;
}
/* If we are past the specified block, stop the scan. */
- else if (next_block_number >= do_block)
+ else if (BLOCK_NUMBER (block) >= do_block)
return;
- next_block_number++;
-
/* Output the subblocks. */
xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
}
ASM_OUTPUT_LBB (file, line, n);
do_block = n;
- next_block_number = 0;
xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
}
in sdbout_begin_block, but there is no guarantee that there will be any
inner block 1, so we must do it here. This gives a result similar to
dbxout, so it does make some sense. */
- do_block = 0;
- next_block_number = 0;
+ do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
xcoffout_block (DECL_INITIAL (current_function_decl), 0,
DECL_ARGUMENTS (current_function_decl));
OSDN Git Service
