dw_separate_line_info_entry;
/* The dw_val_node describes an attibute's value, as it is
- represnted internally. */
+ represented internally. */
typedef struct dw_val_struct
{
dw_val_class val_class;
{
register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
- if (immediate_origin == NULL)
+ if (immediate_origin == NULL || immediate_origin == decl)
return NULL;
else
{
register unsigned num_allocated;
if (decl_id >= decl_die_table_allocated)
{
- num_allocated = (((decl_id + 1)
- + DECL_DIE_TABLE_INCREMENT - 1)
- / DECL_DIE_TABLE_INCREMENT)
- * DECL_DIE_TABLE_INCREMENT;
- decl_die_table = (dw_die_ref *) xrealloc (decl_die_table,
- sizeof (dw_die_ref) * num_allocated);
- bzero (&decl_die_table[decl_die_table_allocated],
- (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
+ num_allocated
+ = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
+ / DECL_DIE_TABLE_INCREMENT)
+ * DECL_DIE_TABLE_INCREMENT;
+
+ decl_die_table
+ = (dw_die_ref *) xrealloc (decl_die_table,
+ sizeof (dw_die_ref) * num_allocated);
+
+ bzero ((char *) &decl_die_table[decl_die_table_allocated],
+ (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
decl_die_table_allocated = num_allocated;
}
+
if (decl_id >= decl_die_table_in_use)
- {
- decl_die_table_in_use = (decl_id + 1);
- }
+ decl_die_table_in_use = (decl_id + 1);
+
decl_die_table[decl_id] = decl_die;
}
if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
{
n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
- abbrev_die_table = (dw_die_ref *)
- xmalloc (abbrev_die_table,
- sizeof (dw_die_ref) * n_alloc);
- bzero (&abbrev_die_table[abbrev_die_table_allocated],
- (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
+ abbrev_die_table
+ = (dw_die_ref *) xmalloc (abbrev_die_table,
+ sizeof (dw_die_ref) * n_alloc);
+
+ bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
+ (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
abbrev_die_table_allocated = n_alloc;
}
+
++abbrev_die_table_in_use;
abbrev_die_table[abbrev_id] = die;
}
+
die->die_abbrev = abbrev_id;
for (c = die->die_child; c != NULL; c = c->die_sib)
- {
- build_abbrev_table (c);
- }
+ build_abbrev_table (c);
}
-
\f
-/********************** DWARF Information Sizing *****************************/
+/********************** DWARF Information Sizing ****************************/
/* Return the size of an unsigned LEB128 quantity. */
inline unsigned long
log = log / 8;
log = 1 << (floor_log2 (log) + 1);
- return log;
+ return MIN (log, 4);
}
/* Return the size of a DIE, as it is represented in the
return DW_FORM_data2;
case 4:
return DW_FORM_data4;
+ case 8:
+ return DW_FORM_data8;
default:
abort ();
}
case REG:
assert (cfa_reg == REGNO (src));
assert (REGNO (dest) == STACK_POINTER_REGNUM
- || frame_pointer_needed && REGNO (dest) == FRAME_POINTER_REGNUM);
+ || (frame_pointer_needed
+ && REGNO (dest) == HARD_FRAME_POINTER_REGNUM));
cfa_reg = REGNO (dest);
break;
registers, since the RTL for local variables is relative to one of
them. */
register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
- ? FRAME_POINTER_REGNUM
+ ? HARD_FRAME_POINTER_REGNUM
: STACK_POINTER_REGNUM);
if (reg == fp_reg)
{
add_AT_unsigned (subrange_die, bound_attr, bound_value);
break;
- /* Dynamic bounds may be represented by NOP_EXPR nodes containing
- SAVE_EXPR nodes. */
+ case CONVERT_EXPR:
case NOP_EXPR:
- bound = TREE_OPERAND (bound, 0);
- /* ... fall thru... */
-
+ case NON_LVALUE_EXPR:
+ add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
+ break;
+
case SAVE_EXPR:
/* If optimization is turned on, the SAVE_EXPRs that describe how to
access the upper bound values may be bogus. If they refer to a
}
/* else leave out the attribute. */
break;
-
- default:
- abort ();
}
}
register enum tree_code code = TREE_CODE (type);
register dw_die_ref type_die = NULL;
+ /* If this type is an unnamed subtype of an integral or floating-point
+ type, use the inner type. */
+ if ((code == INTEGER_TYPE || code == REAL_TYPE)
+ && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
+ type = TREE_TYPE (type), code = TREE_CODE (type);
+
if (code == ERROR_MARK)
- {
- return;
- }
+ return;
/* Handle a special case. For functions whose return type is void, we
generate *no* type attribute. (Note that no object may have type
`void', so this only applies to function return types). */
if (code == VOID_TYPE)
- {
- return;
- }
+ return;
type_die = modified_type_die (type,
decl_const || TYPE_READONLY (type),
register tree origin = decl_ultimate_origin (decl);
register dw_die_ref subr_die;
register dw_loc_descr_ref fp_loc = NULL;
- register unsigned fp_reg;
+ register rtx fp_reg;
register tree fn_arg_types;
register tree outer_scope;
register dw_die_ref old_die = lookup_decl_die (decl);
/* Define the "frame base" location for this routine. We use the
frame pointer or stack pointer registers, since the RTL for local
variables is relative to one of them. */
- fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
- ? FRAME_POINTER_REGNUM
- : STACK_POINTER_REGNUM);
- assert (fp_reg >= 0 && fp_reg <= 31);
- fp_loc = new_loc_descr (DW_OP_reg0 + fp_reg);
- add_AT_loc (subr_die, DW_AT_frame_base, fp_loc);
+ fp_reg
+ = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
+ add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
if (current_function_needs_context)
add_AT_loc (subr_die, DW_AT_static_link,
builtin function. Explicit programmer-supplied declarations of
these same functions should NOT be ignored however. */
if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
- {
- return;
- }
+ return;
/* What we would really like to do here is to filter out all mere
file-scope declarations of file-scope functions which are never
within include files which also contain
`#pragma interface' pragmas. */
if (DECL_INITIAL (decl) == NULL_TREE)
- {
- return;
- }
+ return;
- /* If we're a nested function, initially use a parent of NULL; if we're
- a plain function, this will be fixed up in decls_for_scope. If
- we're a method, it will be ignored, since we already have a DIE. */
+ /* Ignore nested functions, since they will be written in decl_for_scope.
+ ??? There was an old comment here about methods, which now need to
+ be handled. */
if (decl_function_context (decl))
- context_die = NULL;
+ return;
break;
/* If we're a function-scope tag, initially use a parent of NULL;
this will be fixed up in decls_for_scope. */
if (decl_function_context (decl))
- context_die = NULL;
+ return;
+/* context_die = NULL; */
break;
/* Allocate the initial hunk of the file_table. */
file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
- bzero (file_table, FILE_TABLE_INCREMENT * sizeof (char *));
+ bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
file_table_allocated = FILE_TABLE_INCREMENT;
/* skip the first entry - file numbers begin at 1 */
file_table_in_use = 1;
/* Allocate the initial hunk of the decl_die_table. */
decl_die_table
= (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
- bzero (decl_die_table, DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
+ bzero ((char *) decl_die_table,
+ DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
decl_die_table_in_use = 0;
/* Allocate the initial hunk of the decl_scope_table. */
decl_scope_table
= (tree *) xmalloc (DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
- bzero (decl_scope_table, DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
+ bzero ((char *) decl_scope_table,
+ DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
decl_scope_depth = 0;
abbrev_die_table
= (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref));
- bzero (abbrev_die_table, ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
+ bzero ((char *) abbrev_die_table,
+ ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
/* zero-th entry is allocated, but unused */
abbrev_die_table_in_use = 1;
line_info_table
= (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry));
- bzero (line_info_table, LINE_INFO_TABLE_INCREMENT
- * sizeof (dw_line_info_entry));
+ bzero ((char *) line_info_table,
+ LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
/* zero-th entry is allocated, but unused */
line_info_table_in_use = 1;
/* Allocate the initial hunk of the fde_table. */
- fde_table = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
- bzero (fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
+ fde_table
+ = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
+ bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
fde_table_allocated = FDE_TABLE_INCREMENT;
fde_table_in_use = 0;
OSDN Git Service
