(if it has one - it may be just a declaration). */
outer_scope = DECL_INITIAL (decl);
+ /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
+ node created to represent a function. This outermost BLOCK actually
+ represents the outermost binding contour for the function, i.e. the
+ contour in which the function's formal parameters and labels get
+ declared. Curiously, it appears that the front end doesn't actually
+ put the PARM_DECL nodes for the current function onto the BLOCK_VARS
+ list for this outer scope. (They are strung off of the DECL_ARGUMENTS
+ list for the function instead.) The BLOCK_VARS list for the
+ `outer_scope' does provide us with a list of the LABEL_DECL nodes for
+ the function however, and we output DWARF info for those in
+ decls_for_scope. Just within the `outer_scope' there will be a BLOCK
+ node representing the function's outermost pair of curly braces, and
+ any blocks used for the base and member initializers of a C++
+ constructor function. */
if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
- {
- /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
- node created to represent a function. This outermost BLOCK actually
- represents the outermost binding contour for the function, i.e. the
- contour in which the function's formal parameters and labels get
- declared. Curiously, it appears that the front end doesn't actually
- put the PARM_DECL nodes for the current function onto the BLOCK_VARS
- list for this outer scope. (They are strung off of the
- DECL_ARGUMENTS list for the function instead.) The BLOCK_VARS list
- for the `outer_scope' does provide us with a list of the LABEL_DECL
- nodes for the function however, and we output DWARF info for those
- here. Just within the `outer_scope' there will be another BLOCK node
- representing the function's outermost pair of curly braces. We
- musn't generate a lexical_block DIE for this outermost pair of curly
- braces because that is not really an independent scope according to
- ANSI C rules. Rather, it is the same scope in which the parameters
- were declared. */
- for (label = BLOCK_VARS (outer_scope);
- label;
- label = TREE_CHAIN (label))
- {
- gen_decl_die (label, subr_die);
- }
-
- /* Note here that `BLOCK_SUBBLOCKS (outer_scope)' points to a list of
- BLOCK nodes which is always only one element long. That one element
- represents the outermost pair of curley braces for the function
- body. */
- decls_for_scope (BLOCK_SUBBLOCKS (outer_scope), subr_die);
- }
+ decls_for_scope (outer_scope, subr_die, 0);
}
/* Generate a DIE to represent a declared data object. */
/* Generate a DIE for a lexical block. */
static void
-gen_lexical_block_die (stmt, context_die)
+gen_lexical_block_die (stmt, context_die, depth)
register tree stmt;
register dw_die_ref context_die;
+ int depth;
{
register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
char label[MAX_ARTIFICIAL_LABEL_BYTES];
sprintf (label, BLOCK_END_LABEL_FMT, next_block_number);
add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
}
- decls_for_scope (stmt, stmt_die);
+ decls_for_scope (stmt, stmt_die, depth);
}
/* Generate a DIE for an inlined subprogram. */
static void
-gen_inlined_subroutine_die (stmt, context_die)
+gen_inlined_subroutine_die (stmt, context_die, depth)
register tree stmt;
register dw_die_ref context_die;
+ int depth;
{
- register dw_die_ref subr_die = new_die (DW_TAG_inlined_subroutine,
- context_die);
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
- add_abstract_origin_attribute (subr_die, block_ultimate_origin (stmt));
if (!BLOCK_ABSTRACT (stmt))
{
+ register dw_die_ref subr_die = new_die (DW_TAG_inlined_subroutine,
+ context_die);
+ char label[MAX_ARTIFICIAL_LABEL_BYTES];
+ add_abstract_origin_attribute (subr_die, block_ultimate_origin (stmt));
sprintf (label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
sprintf (label, BLOCK_END_LABEL_FMT, next_block_number);
add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
+ decls_for_scope (stmt, subr_die, depth);
}
- decls_for_scope (stmt, subr_die);
}
/* Generate a DIE for a field in a record, or structure. */
/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
things which are local to the given block. */
static void
-gen_block_die (stmt, context_die)
+gen_block_die (stmt, context_die, depth)
register tree stmt;
register dw_die_ref context_die;
+ int depth;
{
register int must_output_die = 0;
register tree origin;
rules. So we check here to make sure that this block does not
represent a "body block inlining" before trying to set the
`must_output_die' flag. */
- if (origin == NULL || !is_body_block (origin))
+ if (! is_body_block (origin ? origin : stmt))
{
/* Determine if this block directly contains any "significant"
local declarations which we will need to output DIEs for. */
{
if (origin_code == FUNCTION_DECL)
{
- gen_inlined_subroutine_die (stmt, context_die);
+ gen_inlined_subroutine_die (stmt, context_die, depth);
}
else
{
- gen_lexical_block_die (stmt, context_die);
+ gen_lexical_block_die (stmt, context_die, depth);
}
}
else
- decls_for_scope (stmt, context_die);
+ decls_for_scope (stmt, context_die, depth);
}
/* Generate all of the decls declared within a given scope and (recursively)
all of it's sub-blocks. */
static void
-decls_for_scope (stmt, context_die)
+decls_for_scope (stmt, context_die, depth)
register tree stmt;
register dw_die_ref context_die;
+ int depth;
{
register tree decl;
register tree subblocks;
{
return;
}
- if (!BLOCK_ABSTRACT (stmt))
+ if (!BLOCK_ABSTRACT (stmt) && depth > 0)
{
next_block_number++;
}
subblocks != NULL;
subblocks = BLOCK_CHAIN (subblocks))
{
- gen_block_die (subblocks, context_die);
+ gen_block_die (subblocks, context_die, depth + 1);
}
}
projects / gcc.git / commitdiff