{
unsigned long dw_fde_offset;
char *dw_fde_begin;
- char *dw_fde_end_prolog;
- char *dw_fde_begin_epilogue;
+ char *dw_fde_current_label;
char *dw_fde_end;
dw_cfi_ref dw_fde_cfi;
}
#define DWARF_ARANGES_HEADER_SIZE \
(DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
-/* Length of the target-dependent instructions in the
- Common Information Entry (CIE).
- ??? This should be computed when the frame info is genericized. */
-#ifdef MIPS_DEBUGGING_INFO
-#define DWARF_CIE_INSN_SIZE (2*3)
-#endif
-
-#ifndef DWARF_CIE_INSN_SIZE
-#define DWARF_CIE_INSN_SIZE 0
-#endif
-
/* Fixed size portion of the CIE (including the length field). */
-#define DWARF_CIE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 5 + DWARF_CIE_INSN_SIZE)
+#define DWARF_CIE_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 5)
-/* Fixed size of the Common Information Entry in the call frame
- information (.debug_frame) section rounded up to a word boundary. */
-#define DWARF_CIE_SIZE DWARF_ROUND (DWARF_CIE_HEADER_SIZE, PTR_SIZE)
+/* The un-padded size of the CIE. Initialized in calc_fde_sizes, used
+ in output_call_frame_info. */
+static unsigned cie_size;
/* Offsets recorded in opcodes are a multiple of this alignment factor. */
#define DWARF_CIE_DATA_ALIGNMENT -4
/* Record the root of the DIE's built for the current compilation unit. */
dw_die_ref comp_unit_die;
+/* The number of DIEs with a NULL parent waiting to be relocated. */
+static int limbo_die_count;
+
/* Pointer to an array of filenames referenced by this compilation unit. */
static char **file_table;
assigns numbers to the blocks in the same way. */
static unsigned next_block_number = 2;
-/* A pointer to the base of a list of references to DIE's that describe
- types. The table is indexed by TYPE_UID() which is a unique number,
- indentifying each type. */
-static dw_die_ref *type_die_table;
-
-/* Number of elements currently allocated for type_die_table. */
-static unsigned type_die_table_allocated;
-
-/* Number of elements in type_die_table currently in use. */
-static unsigned type_die_table_in_use;
-
-/* Size (in elements) of increments by which we may expand the
- type_die_table. */
-#define TYPE_DIE_TABLE_INCREMENT 4096
-
/* 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, indentifying each decl. */
fde_table. */
#define FDE_TABLE_INCREMENT 256
+/* A list of call frame insns for the CIE. */
+static dw_cfi_ref cie_cfi_head;
+
/* A pointer to the base of a table that contains a list of publicly
accessible names. */
static pubname_ref pubname_table;
arange_table. */
#define ARANGE_TABLE_INCREMENT 64
+/* A pointer to the base of a list of pending types which we haven't
+ generated DIEs for yet, but which we will have to come back to
+ later on. */
+
+static tree *pending_types_list;
+
+/* Number of elements currently allocated for the pending_types_list. */
+
+static unsigned pending_types_allocated;
+
+/* Number of elements of pending_types_list currently in use. */
+
+static unsigned pending_types;
+
+/* Size (in elements) of increments by which we may expand the pending
+ types list. Actually, a single hunk of space of this size should
+ be enough for most typical programs. */
+
+#define PENDING_TYPES_INCREMENT 64
+
/* The number of the current function definition for which debugging
information is being generated. These numbers range from 1 up to the
maximum number of function definitions contained within the current
associated with the current function (body) definition. */
static unsigned current_funcdef_fde;
-/* Record the size of the frame, so that the DW_AT_frame_base
- attribute can be set properly in gen_subprogram_die. */
-static long int current_funcdef_frame_size = 0;
-
/* Record whether the function being analyzed contains inlined functions. */
static int current_function_has_inlines;
static int comp_unit_has_inlines;
static unsigned lookup_filename ();
static int constant_size PROTO((long unsigned));
static enum dwarf_form value_format PROTO((dw_val_ref));
+static unsigned reg_number ();
/* Definitions of defaults for assembler-dependent names of various
pseudo-ops and section names.
#endif
/* The DWARF 2 CFA column which tracks the return address. Normally this
- is the first column after all of the hard registers. */
+ is the column for PC, or the first column after all of the hard
+ registers. */
#ifndef DWARF_FRAME_RETURN_COLUMN
-#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
+#ifdef PC_REGNUM
+#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
+#else
+#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER + 1
+#endif
#endif
/* The mapping from gcc register number to DWARF 2 CFA column number. By
of a virtual function may refer to a base class, so we check the 'this'
parameter. */
-tree
+static tree
decl_class_context (decl)
tree decl;
{
tree context = NULL_TREE;
- if (TREE_CODE (decl) != FUNCTION_DECL
- || ! DECL_VIRTUAL_P (decl))
+ if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
context = DECL_CONTEXT (decl);
else
context = TYPE_MAIN_VARIANT
die->die_attr = NULL;
die->die_attr_last = NULL;
if (parent_die != NULL)
- {
- add_child_die (parent_die, die);
- }
+ add_child_die (parent_die, die);
+ else
+ ++limbo_die_count;
}
return die;
}
lookup_type_die (type)
register tree type;
{
- register unsigned type_id = TYPE_UID (type);
- return (type_id < type_die_table_in_use)
- ? type_die_table[type_id] : NULL;
+ return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
}
/* Equate a DIE to a given type specifier. */
register tree type;
register dw_die_ref type_die;
{
- register unsigned type_id = TYPE_UID (type);
- register unsigned num_allocated;
- if (type_id >= type_die_table_allocated)
- {
- num_allocated = (((type_id + 1)
- + TYPE_DIE_TABLE_INCREMENT - 1)
- / TYPE_DIE_TABLE_INCREMENT)
- * TYPE_DIE_TABLE_INCREMENT;
- type_die_table = (dw_die_ref *) xrealloc (type_die_table,
- sizeof (dw_die_ref) * num_allocated);
- bzero (&type_die_table[type_die_table_allocated],
- (num_allocated - type_die_table_allocated) * sizeof (dw_die_ref));
- type_die_table_allocated = num_allocated;
- }
- if (type_id >= type_die_table_in_use)
- {
- type_die_table_in_use = (type_id + 1);
- }
- type_die_table[type_id] = type_die;
+ TYPE_SYMTAB_POINTER (type) = (char *) type_die;
}
/* Return the DIE associated with a given declaration. */
fputc ('\n', asm_out_file);
}
+/* Extract the register and offset values from RTL. If no register number
+ is specified, return -1 to indicate frame-relative addressing. */
+static void
+decode_cfi_rtl (rtl, regp, offsetp)
+ register rtx rtl;
+ register unsigned long *regp;
+ register long *offsetp;
+{
+ switch (GET_CODE (rtl))
+ {
+ case REG:
+ *regp = reg_number (rtl);
+ *offsetp = 0;
+ break;
+ case PLUS:
+ *regp = reg_number (XEXP (rtl, 0));
+ *offsetp = INTVAL (XEXP (rtl, 1));
+ break;
+ case CONST_INT:
+ *regp = (unsigned long) -1;
+ *offsetp = INTVAL (rtl);
+ break;
+ default:
+ abort ();
+ }
+}
+
+/* Add CFI to the current fde at the PC value indicated by LABEL if specified,
+ or to the CIE if LABEL is NULL. */
+static void
+add_fde_cfi (label, cfi)
+ register char * label;
+ register dw_cfi_ref cfi;
+{
+ if (label)
+ {
+ register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
+ if (fde->dw_fde_current_label == NULL
+ || strcmp (label, fde->dw_fde_current_label) != 0)
+ {
+ register dw_cfi_ref xcfi;
+
+ fde->dw_fde_current_label = label = xstrdup (label);
+
+ /* Set the location counter to the new label. */
+ xcfi = new_cfi ();
+ xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
+ xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
+ add_cfi (&fde->dw_fde_cfi, xcfi);
+ }
+ add_cfi (&fde->dw_fde_cfi, cfi);
+ }
+ else
+ add_cfi (&cie_cfi_head, cfi);
+}
+
+/* Subroutine of lookup_cfa. */
+inline void
+lookup_cfa_1 (cfi, regp, offsetp)
+ register dw_cfi_ref cfi;
+ register unsigned long *regp;
+ register long *offsetp;
+{
+ switch (cfi->dw_cfi_opc)
+ {
+ case DW_CFA_def_cfa_offset:
+ *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
+ break;
+ case DW_CFA_def_cfa_register:
+ *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
+ break;
+ case DW_CFA_def_cfa:
+ *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
+ *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
+ break;
+ }
+}
+
+/* Find the previous value for the CFA. */
+static void
+lookup_cfa (regp, offsetp)
+ register unsigned long *regp;
+ register long *offsetp;
+{
+ register dw_cfi_ref cfi;
+ *regp = (unsigned long) -1;
+ *offsetp = 0;
+
+ for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
+ lookup_cfa_1 (cfi, regp, offsetp);
+ if (fde_table_in_use)
+ {
+ register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
+ for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
+ lookup_cfa_1 (cfi, regp, offsetp);
+ }
+}
+
+/* Entry point to update the canonical frame address (CFA).
+ LABEL is passed to add_fde_cfi. RTL is either:
+
+ a REG: The frame is at 0(REG).
+ a PLUS of a REG and a CONST_INT: The frame is at CONST(REG). */
+void
+dwarf2out_def_cfa (label, rtl)
+ register char * label;
+ register rtx rtl;
+{
+ register dw_cfi_ref cfi;
+ unsigned long reg, old_reg;
+ long offset, old_offset;
+
+ decode_cfi_rtl (rtl, ®, &offset);
+ lookup_cfa (&old_reg, &old_offset);
+
+ if (reg == old_reg && offset == old_offset)
+ return;
+
+ cfi = new_cfi ();
+
+ if (reg == old_reg)
+ {
+ cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
+ cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
+ }
+#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
+ else if (offset == old_offset && old_reg != (unsigned long) -1)
+ {
+ cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
+ cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
+ }
+#endif
+ else
+ {
+ cfi->dw_cfi_opc = DW_CFA_def_cfa;
+ cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
+ cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
+ }
+
+ add_fde_cfi (label, cfi);
+}
+
+/* Add the CFI for saving a register. REG is the CFA column number.
+ LABEL is passed to add_fde_cfi.
+ RTL is either:
+
+ a REG: The register is saved in REG.
+ a CONST_INT: The register is saved at an offset of CONST
+ from the CFA. */
+static void
+reg_save (label, reg, rtl)
+ register char * label;
+ register unsigned long reg;
+ register rtx rtl;
+{
+ register dw_cfi_ref cfi;
+ unsigned long sreg;
+ long offset;
+
+ cfi = new_cfi ();
+
+ cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
+
+ decode_cfi_rtl (rtl, &sreg, &offset);
+ offset /= DWARF_CIE_DATA_ALIGNMENT;
+
+ if (sreg == (unsigned long) -1)
+ {
+ if (reg & ~0x3f)
+ /* The register number won't fit in 6 bits, so we have to use
+ the long form. */
+ cfi->dw_cfi_opc = DW_CFA_offset_extended;
+ else
+ cfi->dw_cfi_opc = DW_CFA_offset;
+ cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
+ }
+ else
+ {
+ cfi->dw_cfi_opc = DW_CFA_register;
+ cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
+ }
+
+ add_fde_cfi (label, cfi);
+}
+
+/* Entry point for saving a register. REG is the GCC register number.
+ LABEL and RTL are passed to reg_save. */
+void
+dwarf2out_reg_save (label, reg, rtl)
+ register char * label;
+ register unsigned long reg;
+ register rtx rtl;
+{
+ reg_save (label, DWARF_FRAME_REGNUM (reg), rtl);
+}
+
+/* Entry point for saving the return address.
+ LABEL and RTL are passed to reg_save. */
+void
+dwarf2out_return_save (label, rtl)
+ register char * label;
+ register rtx rtl;
+{
+ reg_save (label, DWARF_FRAME_RETURN_COLUMN, rtl);
+}
+
/* Return the size of a Call Frame Instruction. */
static unsigned long
size_of_cfi (cfi)
register unsigned long i;
register dw_fde_ref fde;
register unsigned long fde_size;
+ register dw_cfi_ref cfi;
unsigned long fde_pad;
+
+ cie_size = DWARF_CIE_HEADER_SIZE;
+ for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
+ cie_size += size_of_cfi (cfi);
+
+ /* Initialize the beginning FDE offset. */
+ next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
+
for (i = 0; i < fde_table_in_use; ++i)
{
fde = &fde_table[i];
case DW_CFA_advance_loc2:
ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
cfi->dw_cfi_oprnd1.dw_cfi_addr,
- fde->dw_fde_begin);
+ fde->dw_fde_current_label);
fputc ('\n', asm_out_file);
+ fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
break;
case DW_CFA_advance_loc4:
ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
cfi->dw_cfi_oprnd1.dw_cfi_addr,
- fde->dw_fde_begin);
+ fde->dw_fde_current_label);
fputc ('\n', asm_out_file);
+ fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
break;
#ifdef MIPS_DEBUGGING_INFO
case DW_CFA_MIPS_advance_loc8:
register unsigned long i, j;
register dw_fde_ref fde;
register unsigned long fde_size;
- dw_cfi_node cfi_node;
register dw_cfi_ref cfi;
unsigned long fde_pad;
+ /* (re-)initialize the beginning FDE offset. */
+ next_fde_offset = DWARF_ROUND (cie_size, PTR_SIZE);
+
/* Output the CIE. */
- ASM_OUTPUT_DWARF_DATA (asm_out_file, DWARF_CIE_SIZE - DWARF_OFFSET_SIZE);
+ ASM_OUTPUT_DWARF_DATA (asm_out_file, next_fde_offset - DWARF_OFFSET_SIZE);
if (flag_verbose_asm)
{
fprintf (asm_out_file, "\t%s Length of Common Information Entry",
}
fputc ('\n', asm_out_file);
- /* Output the CFA instructions common to all FDE's. */
-
-#ifdef MIPS_DEBUGGING_INFO
-
- bzero (&cfi_node, sizeof (dw_cfi_node));
- cfi = &cfi_node;
-
- /* On entry, the Call Frame Address is in the stack pointer register. */
- cfi->dw_cfi_opc = DW_CFA_def_cfa;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
- cfi->dw_cfi_oprnd2.dw_cfi_offset = 0;
- output_cfi (cfi);
-
- /* Set the RA on entry to be the contents of r31. */
- cfi->dw_cfi_opc = DW_CFA_register;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_RETURN_COLUMN;
- cfi->dw_cfi_oprnd2.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (GP_REG_FIRST + 31);
- output_cfi (cfi);
-
-#endif
+ for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
+ output_cfi (cfi);
/* Pad the CIE out to an address sized boundary. */
- for (i = DWARF_CIE_HEADER_SIZE; i < DWARF_CIE_SIZE; ++i)
+ for (i = next_fde_offset - cie_size; i; --i)
{
/* Pad out to a pointer size boundary */
ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CFA_nop);
/* Loop through the Call Frame Instructions associated with
this FDE. */
+ fde->dw_fde_current_label = fde->dw_fde_begin;
for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
- {
- output_cfi (cfi, fde);
- }
+ output_cfi (cfi, fde);
/* Pad to a double word boundary. */
for (j = 0; j < fde_pad; ++j)
}
fputc ('\n', asm_out_file);
}
- if (line_info->dw_line_num != current_line)
+ line_offset = line_info->dw_line_num - current_line;
+ line_delta = line_offset - DWARF_LINE_BASE;
+ current_line = line_info->dw_line_num;
+ if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
{
- line_offset = line_info->dw_line_num - current_line;
- line_delta = line_offset - DWARF_LINE_BASE;
- current_line = line_info->dw_line_num;
- if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
+ ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
+ DWARF_LINE_OPCODE_BASE + line_delta);
+ if (flag_verbose_asm)
{
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
- DWARF_LINE_OPCODE_BASE + line_delta);
- if (flag_verbose_asm)
- {
- fprintf (asm_out_file,
- "\t%s line %d", ASM_COMMENT_START, current_line);
- }
- fputc ('\n', asm_out_file);
+ fprintf (asm_out_file,
+ "\t%s line %d", ASM_COMMENT_START, current_line);
}
- else
+ fputc ('\n', asm_out_file);
+ }
+ else
+ {
+ ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
+ if (flag_verbose_asm)
{
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
- if (flag_verbose_asm)
- {
- fprintf (asm_out_file,
- "\t%s advance to line %d",
- ASM_COMMENT_START, current_line);
- }
- fputc ('\n', asm_out_file);
- output_sleb128 (line_offset);
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
- fputc ('\n', asm_out_file);
+ fprintf (asm_out_file,
+ "\t%s advance to line %d",
+ ASM_COMMENT_START, current_line);
}
+ fputc ('\n', asm_out_file);
+ output_sleb128 (line_offset);
+ fputc ('\n', asm_out_file);
+ ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
+ fputc ('\n', asm_out_file);
}
strcpy (prev_line_label, line_label);
}
if (code != ERROR_MARK)
{
- /* Take the MAIN_VARIANT here to avoid C typedef types. */
- type = build_type_variant (TYPE_MAIN_VARIANT (type),
- is_const_type, is_volatile_type);
+ type = build_type_variant (type, is_const_type, is_volatile_type);
mod_type_die = lookup_type_die (type);
if (mod_type_die)
return mod_type_die;
- if (is_const_type)
+ /* Handle C typedef types. */
+ if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
+ && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
+ {
+ tree dtype = TREE_TYPE (TYPE_NAME (type));
+ if (type == dtype)
+ {
+ /* For a named type, use the typedef. */
+ gen_type_die (type, context_die);
+ mod_type_die = lookup_type_die (type);
+ }
+ else if (is_const_type < TYPE_READONLY (dtype)
+ || is_volatile_type < TYPE_VOLATILE (dtype))
+ /* cv-unqualified version of named type. Just use the unnamed
+ type to which it refers. */
+ mod_type_die = modified_type_die
+ (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
+ is_const_type, is_volatile_type);
+ /* else cv-qualified version of named type; fall through. */
+ }
+
+ if (mod_type_die)
+ /* OK */;
+ else if (is_const_type)
{
mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
might simply be a *copy* of some original type node (where the
copy was created to help us keep track of typedef names) and
that copy might have a different TYPE_UID from the original
- ..._TYPE node. (Note that when `equate_type_number_to_die' is
- labeling a given type DIE for future reference, it always only
- handles DIEs representing *main variants*, and it never even
- knows about non-main-variants.). */
+ ..._TYPE node. */
mod_type_die = lookup_type_die (type_main_variant (type));
- if (mod_type_die == NULL)
- abort ();
+ assert (mod_type_die != NULL);
}
}
if (sub_die != NULL)
register dw_die_ref die;
register tree func_decl;
{
- if (DECL_VIRTUAL_P (func_decl))
+ if (DECL_VINDEX (func_decl))
{
add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
add_AT_loc (die, DW_AT_vtable_elem_location, new_loc_descr
(DW_OP_constu, TREE_INT_CST_LOW (DECL_VINDEX (func_decl))));
+ /* GNU extension: Record what type this method came from originally. */
+ if (debug_info_level > DINFO_LEVEL_TERSE)
+ add_AT_die_ref (die, DW_AT_containing_type,
+ lookup_type_die (DECL_CONTEXT (func_decl)));
}
}
\f
/* Function-local tags and functions get stuck in limbo until they are
fixed up by decls_for_scope. */
- if (context_die == NULL)
+ if (context_die == NULL
+ && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
return NULL;
/* Walk back up the declaration tree looking for a place to define
this type. */
if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
containing_scope = TYPE_CONTEXT (t);
- else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VIRTUAL_P (t))
+ else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
containing_scope = decl_class_context (t);
else
containing_scope = DECL_CONTEXT (t);
/* The g++ front end makes the TYPE_NAME of *each* tagged type point to
a TYPE_DECL node, regardless of whether or not a `typedef' was
involved. */
- else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
+ && ! DECL_IGNORED_P (TYPE_NAME (type)))
t = DECL_NAME (TYPE_NAME (type));
/* Now get the name as a string, or invent one. */
if (t != 0)
- {
- name = IDENTIFIER_POINTER (t);
- }
+ name = IDENTIFIER_POINTER (t);
}
return (name == 0 || *name == '\0') ? 0 : name;
}
}
}
+/* Remember a type in the pending_types_list. */
+
+static void
+pend_type (type)
+ register tree type;
+{
+ if (pending_types == pending_types_allocated)
+ {
+ pending_types_allocated += PENDING_TYPES_INCREMENT;
+ pending_types_list
+ = (tree *) xrealloc (pending_types_list,
+ sizeof (tree) * pending_types_allocated);
+ }
+ pending_types_list[pending_types++] = type;
+}
+
+/* Output any pending types (from the pending_types list) which we can output
+ now (taking into account the scope that we are working on now).
+
+ For each type output, remove the given type from the pending_types_list
+ *before* we try to output it. */
+
+static void
+output_pending_types_for_scope (context_die)
+ register dw_die_ref context_die;
+{
+ register tree type;
+
+ while (pending_types)
+ {
+ --pending_types;
+ type = pending_types_list[pending_types];
+ gen_type_die (type, context_die);
+ assert (TREE_ASM_WRITTEN (type));
+ }
+}
+
/* Generate a DIE to represent an inlined instance of an enumeration type. */
static void
gen_inlined_enumeration_type_die (type, context_die)
it's the latter, then this function is only being called to output a
DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
argument type of some subprogram type. */
-static void
+static dw_die_ref
gen_formal_parameter_die (node, context_die)
register tree node;
register dw_die_ref context_die;
case 'd':
origin = decl_ultimate_origin (node);
if (origin != NULL)
- {
- add_abstract_origin_attribute (parm_die, origin);
- }
+ add_abstract_origin_attribute (parm_die, origin);
else
{
add_name_and_src_coords_attributes (parm_die, node);
add_AT_flag (parm_die, DW_AT_artificial, 1);
}
if (DECL_ABSTRACT (node))
- {
- equate_decl_number_to_die (node, parm_die);
- }
+ equate_decl_number_to_die (node, parm_die);
else
- {
- add_location_or_const_value_attribute (parm_die, node);
- }
+ add_location_or_const_value_attribute (parm_die, node);
break;
/* We were called with some kind of a ..._TYPE node. */
default:
abort ();
}
+ return parm_die;
}
/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
DW_TAG_formal_parameter DIE for each one. */
for (link = first_parm_type; link; link = TREE_CHAIN (link))
{
+ register dw_die_ref parm_die;
+
formal_type = TREE_VALUE (link);
if (formal_type == void_type_node)
break;
/* Output a (nameless) DIE to represent the formal parameter itself. */
- gen_formal_parameter_die (formal_type, context_die);
+ parm_die = gen_formal_parameter_die (formal_type, context_die);
+ if (TREE_CODE (function_or_method_type) == METHOD_TYPE
+ && link == first_parm_type)
+ add_AT_flag (parm_die, DW_AT_artificial, 1);
}
/* If this function type has an ellipsis, add a
register unsigned fp_reg;
register tree fn_arg_types;
register tree outer_scope;
- dw_die_ref old_die = lookup_decl_die (decl);
- int declaration = (current_function_decl != decl);
+ register dw_die_ref old_die = lookup_decl_die (decl);
+ register int declaration = (current_function_decl != decl
+ || context_die->die_tag == DW_TAG_structure_type
+ || context_die->die_tag == DW_TAG_union_type);
if (origin != NULL)
{
{
register unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl));
- if (get_AT_flag (old_die, DW_AT_declaration) != 1)
- abort ();
+
+ assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
/* If the definition comes from the same place as the declaration,
- use the old DIE. */
- if (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
+ maybe use the old DIE. We always want the DIE for this function
+ that has the *_pc attributes to be under comp_unit_die so the
+ debugger can find it. For inlines, that is the concrete instance,
+ so we can use the old DIE here. For non-inline methods, we want a
+ specification DIE at toplevel, so we need a new DIE. For local
+ class methods, this does not apply. */
+ if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
+ || context_die == NULL)
+ && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
&& (get_AT_unsigned (old_die, DW_AT_decl_line)
== DECL_SOURCE_LINE (decl)))
{
add_pure_or_virtual_attribute (subr_die, decl);
if (DECL_ARTIFICIAL (decl))
add_AT_flag (subr_die, DW_AT_artificial, 1);
+ if (TREE_PROTECTED (decl))
+ add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
+ else if (TREE_PRIVATE (decl))
+ add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
}
- if (DECL_ABSTRACT (decl))
+ if (declaration)
+ {
+ add_AT_flag (subr_die, DW_AT_declaration, 1);
+
+ /* The first time we see a member function, it is in the context of
+ the class to which it belongs. We make sure of this by emitting
+ the class first. The next time is the definition, which is
+ handled above. The two may come from the same source text. */
+ if (decl_class_context (decl))
+ equate_decl_number_to_die (decl, subr_die);
+ }
+ else if (DECL_ABSTRACT (decl))
{
if (DECL_DEFER_OUTPUT (decl))
{
equate_decl_number_to_die (decl, subr_die);
}
- else if (declaration)
- {
- add_AT_flag (subr_die, DW_AT_declaration, 1);
-
- /* The first time we see a member function, it is in the context of
- the class to which it belongs. We make sure of this by emitting
- the class first. The next time is the definition, which is
- handled above. The two may come from the same source text. */
- if (decl_class_context (decl))
- equate_decl_number_to_die (decl, subr_die);
- }
else if (!DECL_EXTERNAL (decl))
{
if (origin == NULL)
if (current_function_needs_context)
add_AT_loc (subr_die, DW_AT_static_link,
loc_descriptor (lookup_static_chain (decl)));
-
-#ifdef DWARF_GNU_EXTENSIONS
- ASM_GENERATE_INTERNAL_LABEL (label_id, BODY_BEGIN_LABEL,
- current_funcdef_number);
- add_AT_lbl_id (subr_die, DW_AT_body_begin, label_id);
- ASM_GENERATE_INTERNAL_LABEL (label_id, BODY_END_LABEL,
- current_funcdef_number);
- add_AT_lbl_id (subr_die, DW_AT_body_end, label_id);
-#endif
-
}
/* Now output descriptions of the arguments for this function. This gets
dw_die_ref old_die = lookup_decl_die (decl);
int declaration
= (DECL_EXTERNAL (decl)
- || current_function_decl != decl_function_context (decl));
+ || current_function_decl != decl_function_context (decl)
+ || context_die->die_tag == DW_TAG_structure_type
+ || context_die->die_tag == DW_TAG_union_type);
if (origin != NULL)
{
}
else if (old_die)
{
- if (get_AT_flag (old_die, DW_AT_declaration) != 1)
- abort ();
+ assert (get_AT_flag (old_die, DW_AT_declaration) == 1);
add_AT_die_ref (var_die, DW_AT_specification, old_die);
if (DECL_NAME (decl))
{
add_AT_flag (var_die, DW_AT_external, 1);
if (DECL_ARTIFICIAL (decl))
add_AT_flag (var_die, DW_AT_artificial, 1);
+ if (TREE_PROTECTED (decl))
+ add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
+ else if (TREE_PRIVATE (decl))
+ add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
}
if (declaration)
add_bit_size_attribute (decl_die, decl);
add_bit_offset_attribute (decl_die, decl);
}
- add_data_member_location_attribute (decl_die, decl);
+ if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
+ add_data_member_location_attribute (decl_die, decl);
if (DECL_ARTIFICIAL (decl))
add_AT_flag (decl_die, DW_AT_artificial, 1);
+ if (TREE_PROTECTED (decl))
+ add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
+ else if (TREE_PRIVATE (decl))
+ add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
}
#if 0
&& TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't')
nested = 1;
- if (! type_die || nested)
- scope_die = scope_die_for (type, context_die);
+ scope_die = scope_die_for (type, context_die);
if (! type_die || (nested && scope_die == comp_unit_die))
/* First occurrence of type or toplevel definition of nested class. */
else
remove_AT (type_die, DW_AT_declaration);
+ /* If we're not in the right context to be defining this type, defer to
+ avoid tricky recursion. */
+ if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
+ {
+ add_AT_flag (type_die, DW_AT_declaration, 1);
+ pend_type (type);
+ }
/* If this type has been completed, then give it a byte_size attribute and
then give a list of members. */
- if (TYPE_SIZE (type)
- /* If we're getting a reference to one nested class from another
- nested class, don't recurse. */
- && ! (nested && scope_die != context_die
- && scope_die == lookup_type_die (TYPE_CONTEXT (type))))
+ else if (TYPE_SIZE (type))
{
/* Prevent infinite recursion in cases where the type of some member of
this type is expressed in terms of this type itself. */
push_decl_scope (type);
gen_member_die (type, type_die);
pop_decl_scope ();
+ /* GNU extension: Record what type our vtable lives in. */
+ if (TYPE_VFIELD (type))
+ {
+ tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
+ gen_type_die (vtype, context_die);
+ add_AT_die_ref (type_die, DW_AT_containing_type,
+ lookup_type_die (vtype));
+ }
}
else
add_AT_flag (type_die, DW_AT_declaration, 1);
equate_type_number_to_die (type, subr_die);
add_prototyped_attribute (subr_die, type);
add_type_attribute (subr_die, return_type, 0, 0, context_die);
- gen_formal_types_die (type, context_die);
+ gen_formal_types_die (type, subr_die);
}
/* Generate a DIE for a type definition */
register tree decl;
register dw_die_ref context_die;
{
- register tree origin = decl_ultimate_origin (decl);
register dw_die_ref type_die;
+ register tree origin;
+
+ if (TREE_ASM_WRITTEN (decl))
+ return;
+ TREE_ASM_WRITTEN (decl) = 1;
+
type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
+ origin = decl_ultimate_origin (decl);
if (origin != NULL)
- {
- add_abstract_origin_attribute (type_die, origin);
- }
+ add_abstract_origin_attribute (type_die, origin);
else
{
+ register tree type;
add_name_and_src_coords_attributes (type_die, decl);
- add_type_attribute (type_die, TREE_TYPE (decl),
- TREE_READONLY (decl),
- TREE_THIS_VOLATILE (decl),
- context_die);
+ if (DECL_ORIGINAL_TYPE (decl))
+ {
+ type = DECL_ORIGINAL_TYPE (decl);
+ equate_type_number_to_die (TREE_TYPE (decl), type_die);
+ }
+ else
+ type = TREE_TYPE (decl);
+ add_type_attribute (type_die, type, TREE_READONLY (decl),
+ TREE_THIS_VOLATILE (decl), context_die);
}
if (DECL_ABSTRACT (decl))
- {
- equate_decl_number_to_die (decl, type_die);
- }
+ equate_decl_number_to_die (decl, type_die);
}
/* Generate a type description DIE. */
return;
}
+ if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
+ && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
+ {
+ TREE_ASM_WRITTEN (type) = 1;
+ gen_decl_die (TYPE_NAME (type), context_die);
+ return;
+ }
+
switch (TREE_CODE (type))
{
case ERROR_MARK:
if (TYPE_CONTEXT (type)
&& TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
&& ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
- gen_type_die (TYPE_CONTEXT (type), context_die);
- else if (TREE_CODE (type) == ENUMERAL_TYPE)
+ {
+ gen_type_die (TYPE_CONTEXT (type), context_die);
+
+ if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
+ return;
+
+ /* If that failed, attach ourselves to the stub. */
+ push_decl_scope (TYPE_CONTEXT (type));
+ context_die = lookup_type_die (TYPE_CONTEXT (type));
+ }
+
+ if (TREE_CODE (type) == ENUMERAL_TYPE)
gen_enumeration_type_die (type, context_die);
else
gen_struct_or_union_type_die (type, context_die);
+ if (TYPE_CONTEXT (type)
+ && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
+ && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
+ pop_decl_scope ();
+
/* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
it up if it is ever completed. gen_*_type_die will set it for us
when appropriate. */
for (decl = BLOCK_VARS (stmt);
decl != NULL; decl = TREE_CHAIN (decl))
{
+ register dw_die_ref die;
+
if (TREE_CODE (decl) == FUNCTION_DECL)
- {
- register dw_die_ref die = lookup_decl_die (decl);
- add_child_die (context_die, die);
- }
+ die = lookup_decl_die (decl);
else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
+ die = lookup_type_die (TREE_TYPE (decl));
+ else
+ die = NULL;
+
+ if (die && die->die_parent == NULL)
{
- register dw_die_ref die = lookup_type_die (TREE_TYPE (decl));
- if (die)
- add_child_die (context_die, die);
- else
- gen_decl_die (decl, context_die);
+ add_child_die (context_die, die);
+ --limbo_die_count;
}
else
gen_decl_die (decl, context_die);
}
}
+/* Is this a typedef we can avoid emitting? */
+inline int
+is_redundant_typedef (decl)
+ register tree decl;
+{
+ if (TYPE_DECL_IS_STUB (decl))
+ return 1;
+ if (DECL_ARTIFICIAL (decl)
+ && DECL_CONTEXT (decl)
+ && is_tagged_type (DECL_CONTEXT (decl))
+ && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
+ && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
+ /* Also ignore the artificial member typedef for the class name. */
+ return 1;
+ return 0;
+}
+
/* Generate Dwarf debug information for a decl described by DECL. */
static void
gen_decl_die (decl, context_die)
break;
}
- /* Before we describe the FUNCTION_DECL itself, make sure that we have
- described its return type. */
if (debug_info_level > DINFO_LEVEL_TERSE)
- gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
+ {
+ /* Before we describe the FUNCTION_DECL itself, make sure that we
+ have described its return type. */
+ gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
+
+ /* And its containing type. */
+ origin = decl_class_context (decl);
+ if (origin)
+ gen_type_die (origin, context_die);
+
+ /* And its virtual context. */
+ if (DECL_VINDEX (decl))
+ gen_type_die (DECL_CONTEXT (decl), context_die);
+ }
/* Now output a DIE to represent the function itself. */
gen_subprogram_die (decl, context_die);
gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
break;
}
- gen_type_die (TREE_TYPE (decl), context_die);
- if (! TYPE_DECL_IS_STUB (decl))
+ if (is_redundant_typedef (decl))
+ gen_type_die (TREE_TYPE (decl), context_die);
+ else
{
/* Output a DIE to represent the typedef itself. */
gen_typedef_die (decl, context_die);
object. */
gen_type_die (TREE_TYPE (decl), context_die);
+ /* And its containing type. */
+ origin = decl_class_context (decl);
+ if (origin)
+ gen_type_die (origin, context_die);
+
/* Now output the DIE to represent the data object itself. This gets
complicated because of the possibility that the VAR_DECL really
represents an inlined instance of a formal parameter for an inline
break;
case FIELD_DECL:
- /* Ignore the nameless fields that are used to skip bits. */
- if (DECL_NAME (decl) != 0)
+ /* Ignore the nameless fields that are used to skip bits, but
+ handle C++ anonymous unions. */
+ if (DECL_NAME (decl) != 0 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
{
gen_type_die (member_declared_type (decl), context_die);
gen_field_die (decl, context_die);
/* Don't bother trying to generate any DIEs to represent any of the
normal built-in types for the language we are compiling. */
if (DECL_SOURCE_LINE (decl) == 0)
- return;
+ {
+ /* OK, we need to generate one for `bool' so GDB knows what type
+ comparisons have. */
+ if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
+ == DW_LANG_C_plus_plus)
+ && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
+ modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
+ return;
+ }
/* If we are in terse mode, don't generate any DIEs for types. */
if (debug_info_level <= DINFO_LEVEL_TERSE)
}
gen_decl_die (decl, context_die);
+ output_pending_types_for_scope (comp_unit_die);
if (TREE_CODE (decl) == FUNCTION_DECL
&& DECL_INITIAL (decl) != NULL)
/* Add the new FDE at the end of the fde_table. */
fde = &fde_table[fde_table_in_use++];
fde->dw_fde_begin = xstrdup (label);
- fde->dw_fde_end_prolog = NULL;
- fde->dw_fde_begin_epilogue = NULL;
+ fde->dw_fde_current_label = NULL;
fde->dw_fde_end = NULL;
fde->dw_fde_cfi = NULL;
}
void
dwarf2out_begin_function ()
{
+#ifdef MIPS_DEBUGGING_INFO
char label[MAX_ARTIFICIAL_LABEL_BYTES];
register long int offset;
register dw_fde_ref fde;
register dw_cfi_ref cfi;
+ register int regno, fp_inc;
function_section (current_function_decl);
ASM_GENERATE_INTERNAL_LABEL (label, BODY_BEGIN_LABEL,
current_funcdef_number);
ASM_OUTPUT_LABEL (asm_out_file, label);
- /* Record the end-of-prolog location in the FDE. */
- fde = &fde_table[fde_table_in_use - 1];
- fde->dw_fde_end_prolog = xstrdup (label);
-
-#ifdef MIPS_DEBUGGING_INFO
-
- /* Set the location counter to the end of the function prolog. */
- cfi = new_cfi ();
- cfi->dw_cfi_opc = DW_CFA_advance_loc4;
- cfi->dw_cfi_oprnd1.dw_cfi_addr = xstrdup (label);
- add_cfi (&fde->dw_fde_cfi, cfi);
-
/* Define the CFA as an offset from either the frame pointer
or the stack pointer. */
- cfi = new_cfi ();
- cfi->dw_cfi_opc = DW_CFA_def_cfa;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (frame_pointer_needed ? FRAME_POINTER_REGNUM
- : STACK_POINTER_REGNUM);
- offset = current_frame_info.total_size;
- cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
- add_cfi (&fde->dw_fde_cfi, cfi);
-
- /* record the frame size for later definition of the DW_AT_frame_base
- attribute. */
- current_funcdef_frame_size = offset;
-
- /* Define the rule for restoring the stack pointer. */
- if (frame_pointer_needed)
- {
- /* Restore the stack register from the frame pointer. */
- cfi = new_cfi ();
- cfi->dw_cfi_opc = DW_CFA_register;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
- cfi->dw_cfi_oprnd2.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (FRAME_POINTER_REGNUM);
- add_cfi (&fde->dw_fde_cfi, cfi);
- }
-
- /* If RA is saved on the stack, define it here. */
- if (regs_ever_live[31])
- {
- offset = current_frame_info.gp_save_offset / DWARF_CIE_DATA_ALIGNMENT;
- assert (offset >= 0);
- cfi = new_cfi ();
- cfi->dw_cfi_opc = DW_CFA_offset_extended;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_RETURN_COLUMN;
- cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
- add_cfi (&fde->dw_fde_cfi, cfi);
- }
+ dwarf2out_def_cfa
+ (label, gen_rtx (PLUS, VOIDmode,
+ gen_rtx (REG, VOIDmode,
+ (frame_pointer_needed ? FRAME_POINTER_REGNUM
+ : STACK_POINTER_REGNUM)),
+ GEN_INT (current_frame_info.total_size)));
+
+ /* Record the locations of the return address and any callee-saved regs. */
+ offset = current_frame_info.gp_save_offset / DWARF_CIE_DATA_ALIGNMENT;
+ for (regno = GP_REG_LAST; regno >= GP_REG_FIRST; --regno)
+ if (current_frame_info.mask & (1<<regno))
+ {
+ assert (offset >= 0);
- /* If FP is saved on the stack, define it here. */
- if (current_frame_info.mask & (1 << 30))
- {
- offset = (current_frame_info.gp_save_offset
- - (((current_frame_info.mask >> 31) & 1) * UNITS_PER_WORD))
- / DWARF_CIE_DATA_ALIGNMENT;
- assert (offset >= 0);
- cfi = new_cfi ();
- cfi->dw_cfi_opc = DW_CFA_offset;
- cfi->dw_cfi_oprnd1.dw_cfi_reg_num
- = DWARF_FRAME_REGNUM (FRAME_POINTER_REGNUM);
- cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
- add_cfi (&fde->dw_fde_cfi, cfi);
- }
+ if (regno == 31)
+ dwarf2out_return_save (label, GEN_INT (offset));
+ else
+ dwarf2out_reg_save (label, regno, GEN_INT (offset));
+ offset -= UNITS_PER_WORD / DWARF_CIE_DATA_ALIGNMENT;
+ }
+ fp_inc = (TARGET_FLOAT64 || TARGET_SINGLE_FLOAT) ? 1 : 2;
+ offset = current_frame_info.fp_save_offset / DWARF_CIE_DATA_ALIGNMENT;
+ for (regno = FP_REG_LAST - 1; regno >= FP_REG_FIRST; regno -= fp_inc)
+ if (current_frame_info.fmask & (1 << (regno - FP_REG_FIRST)))
+ {
+ assert (offset >= 0);
+ dwarf2out_reg_save (label, regno, GEN_INT (offset));
+ offset -= (fp_inc * UNITS_PER_FPREG) / DWARF_CIE_DATA_ALIGNMENT;
+ }
#endif
-
-}
-
-/* Output a marker (i.e. a label) for the point in the generated code where
- the real body of the function ends (just before the epilogue code). */
-void
-dwarf2out_end_function ()
-{
- dw_fde_ref fde;
- char label[MAX_ARTIFICIAL_LABEL_BYTES];
- function_section (current_function_decl);
- ASM_GENERATE_INTERNAL_LABEL (label, BODY_END_LABEL, current_funcdef_number);
- ASM_OUTPUT_LABEL (asm_out_file, label);
- /* Record the ending code location in the FDE. */
- fde = &fde_table[fde_table_in_use - 1];
- fde->dw_fde_begin_epilogue = xstrdup(label);
}
/* Output a marker (i.e. a label) for the absolute end of the generated code
/* skip the first entry - file numbers begin at 1 */
file_table_in_use = 1;
- /* Allocate the initial hunk of the type_die_table. */
- type_die_table
- = (dw_die_ref *) xmalloc (TYPE_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
- bzero (type_die_table, TYPE_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
- type_die_table_allocated = TYPE_DIE_TABLE_INCREMENT;
- type_die_table_in_use = 0;
-
/* Allocate the initial hunk of the decl_die_table. */
decl_die_table
= (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
gen_compile_unit_die (main_input_filename);
ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
+
+ /* Generate the CFA instructions common to all FDE's. Do it now for the
+ sake of lookup_cfa. */
+#ifdef MIPS_DEBUGGING_INFO
+ /* On entry, the Call Frame Address is in the stack pointer register. */
+ dwarf2out_def_cfa (NULL, gen_rtx (REG, VOIDmode, STACK_POINTER_REGNUM));
+
+ /* Set the RA on entry to be the contents of r31. */
+ dwarf2out_return_save (NULL, gen_rtx (REG, VOIDmode, GP_REG_FIRST + 31));
+#endif
}
/* Output stuff that dwarf requires at the end of every file,
next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
calc_die_sizes (comp_unit_die);
- /* Initialize the beginning FDE offset - and calculate sizes/offsets. */
- next_fde_offset = DWARF_CIE_SIZE;
+ /* calculate sizes/offsets for FDEs. */
calc_fde_sizes ();
/* Output debugging information. */
if (fde_table_in_use)
{
+#ifdef MIPS_DEBUGGING_INFO /* Not currently useful otherwise. */
/* Output call frame information. */
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
output_call_frame_info ();
+#endif
/* Output the address range information. */
fputc ('\n', asm_out_file);
ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
output_aranges ();
}
+
+ /* The only DIE we should have with a parent of NULL is comp_unit_die. */
+ assert (limbo_die_count == 1);
}
#endif /* DWARF2_DEBUGGING_INFO */
#define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0)
+/* Define a macro which returns non-zero for a TYPE_DECL which was
+ implicitly generated for a tagged type.
+
+ Note that unlike the gcc front end (which generates a NULL named
+ TYPE_DECL node for each complete tagged type, each array type, and
+ each function type node created) the g++ front end generates a
+ _named_ TYPE_DECL node for each tagged type node created.
+ These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
+ generate a DW_TAG_typedef DIE for them. */
+#define TYPE_DECL_IS_STUB(decl) \
+ (DECL_NAME (decl) == NULL \
+ || (DECL_ARTIFICIAL (decl) \
+ && is_tagged_type (TREE_TYPE (decl)) \
+ && decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
+
extern int flag_traditional;
extern char *version_string;
extern char *language_string;
static tree dwarf_last_decl;
+/* A flag indicating that we are emitting the member declarations of a
+ class, so member functions and variables should not be entirely emitted.
+ This is a kludge to avoid passing a second argument to output_*_die. */
+
+static int in_class;
+
/* Forward declarations for functions defined in this file. */
static char *dwarf_tag_name PROTO((unsigned));
}
}
+/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
+ of a virtual function may refer to a base class, so we check the 'this'
+ parameter. */
+
+static tree
+decl_class_context (decl)
+ tree decl;
+{
+ tree context = NULL_TREE;
+ if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
+ context = DECL_CONTEXT (decl);
+ else
+ context = TYPE_MAIN_VARIANT
+ (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
+
+ if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
+ context = NULL_TREE;
+
+ return context;
+}
+
static void
output_unsigned_leb128 (value)
register unsigned long value;
/* The g++ front end makes the TYPE_NAME of *each* tagged type point to
a TYPE_DECL node, regardless of whether or not a `typedef' was
involved. */
- else
- if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
+ && ! DECL_IGNORED_P (TYPE_NAME (type)))
t = DECL_NAME (TYPE_NAME (type));
/* Now get the name as a string, or invent one. */
equate_decl_number_to_die_number (decl);
else
{
- if (! DECL_EXTERNAL (decl))
+ if (! DECL_EXTERNAL (decl) && ! in_class
+ && decl == current_function_decl)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
low_pc_attribute (function_start_label (decl));
sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
high_pc_attribute (label);
- sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
- body_begin_attribute (label);
- sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
- body_end_attribute (label);
+ if (use_gnu_debug_info_extensions)
+ {
+ sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
+ body_begin_attribute (label);
+ sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
+ body_end_attribute (label);
+ }
}
}
}
equate_decl_number_to_die_number (decl);
else
{
- if (!DECL_EXTERNAL (decl))
+ if (! DECL_EXTERNAL (decl) && ! in_class
+ && current_function_decl == decl_function_context (decl))
location_or_const_value_attribute (decl);
}
}
comp_dir_attribute (wd);
}
- if (debug_info_level >= DINFO_LEVEL_NORMAL)
+ if (debug_info_level >= DINFO_LEVEL_NORMAL && use_gnu_debug_info_extensions)
{
sf_names_attribute (SFNAMES_BEGIN_LABEL);
src_info_attribute (SRCINFO_BEGIN_LABEL);
low_pc_attribute (function_start_label (decl));
sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
high_pc_attribute (label);
- sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
- body_begin_attribute (label);
- sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
- body_end_attribute (label);
+ if (use_gnu_debug_info_extensions)
+ {
+ sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
+ body_begin_attribute (label);
+ sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
+ body_end_attribute (label);
+ }
}
}
}
(for C and C++ anyway) will be array types and function types. */
return is_tagged_type (type)
- ? (TYPE_CONTEXT (type) == scope)
+ ? (TYPE_CONTEXT (type) == scope
+ || (scope == NULL_TREE && is_tagged_type (TYPE_CONTEXT (type))
+ && TREE_ASM_WRITTEN (TYPE_CONTEXT (type))))
: (scope == NULL_TREE || ! is_tagged_type (scope));
}
if (TREE_ASM_WRITTEN (type))
return;
+ /* If this is a nested type whose containing class hasn't been
+ written out yet, writing it out will cover this one, too. */
+
+ if (TYPE_CONTEXT (type)
+ && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
+ && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
+ {
+ output_type (TYPE_CONTEXT (type), containing_scope);
+ return;
+ }
+
/* Don't generate any DIEs for this type now unless it is OK to do so
(based upon what `type_ok_for_scope' tells us). */
time, we will certainly know as much about each file-scope tagged
type as we are ever going to know, so at that point in time, we
can safely generate correct Dwarf descriptions for these file-
- scope tagged types.
-
- This loses for C++ nested types that are defined after their
- containing class, but I don't see a good way to fix it. I doubt
- many people will be using DWARF 1 for C++ in any case. */
+ scope tagged types. */
- if (TYPE_SIZE (type) == 0 && TYPE_CONTEXT (type) == NULL && !finalizing)
+ if (TYPE_SIZE (type) == 0 && !finalizing)
return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */
/* Prevent infinite recursion in cases where the type of some
output_die (output_inheritance_die, TREE_VEC_ELT (bases, i));
}
+ ++in_class;
+
{
register tree normal_member;
output_decl (func_member, type);
}
+ --in_class;
+
/* RECORD_TYPEs, UNION_TYPEs, and QUAL_UNION_TYPEs are themselves
scopes (at least in C++) so we must now output any nested
pending types which are local just to this type. */
}
}
+/* Is this a typedef we can avoid emitting? */
+
+inline int
+is_redundant_typedef (decl)
+ register tree decl;
+{
+ if (TYPE_DECL_IS_STUB (decl))
+ return 1;
+ if (DECL_ARTIFICIAL (decl)
+ && DECL_CONTEXT (decl)
+ && is_tagged_type (DECL_CONTEXT (decl))
+ && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
+ && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
+ /* Also ignore the artificial member typedef for the class name. */
+ return 1;
+ return 0;
+}
+
/* Output Dwarf .debug information for a decl described by DECL. */
static void
output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope);
+ {
+ /* And its containing type. */
+ register tree origin = decl_class_context (decl);
+ if (origin)
+ output_type (origin, containing_scope);
+ }
+
/* If the following DIE will represent a function definition for a
function with "extern" linkage, output a special "pubnames" DIE
label just ahead of the actual DIE. A reference to this label
we need to do here (and all we *can* do here) is to describe
the *types* of its formal parameters. */
- if (DECL_INITIAL (decl) == NULL_TREE)
+ if (decl != current_function_decl || in_class)
output_formal_types (TREE_TYPE (decl));
else
{
output_die (output_unspecified_parameters_die, decl);
}
}
- }
- /* Output Dwarf info for all of the stuff within the body of the
- function (if it has one - it may be just a declaration). */
+ /* Output Dwarf info for all of the stuff within the body of the
+ function (if it has one - it may be just a declaration). */
- {
- register tree outer_scope = DECL_INITIAL (decl);
-
- 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 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. */
-
- output_decls_for_scope (outer_scope, 0);
-
- /* Finally, force out any pending types which are local to the
- outermost block of this function definition. These will
- all have a TYPE_CONTEXT which points to the FUNCTION_DECL
- node itself. */
-
- output_pending_types_for_scope (decl);
+ register tree outer_scope = DECL_INITIAL (decl);
+
+ 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 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. */
+
+ output_decls_for_scope (outer_scope, 0);
+
+ /* Finally, force out any pending types which are local to the
+ outermost block of this function definition. These will
+ all have a TYPE_CONTEXT which points to the FUNCTION_DECL
+ node itself. */
+
+ output_pending_types_for_scope (decl);
+ }
}
- }
+ }
/* Generate a terminator for the list of stuff `owned' by this
function. */
a return type or a formal parameter type of some function. */
if (debug_info_level <= DINFO_LEVEL_TERSE)
- if (DECL_NAME (decl) != NULL
- || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
+ if (! TYPE_DECL_IS_STUB (decl)
+ || (! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)) && ! in_class))
return;
- /* In the special case of a null-named TYPE_DECL node (representing
- the declaration of some type tag), if the given TYPE_DECL is
+ /* In the special case of a TYPE_DECL node representing
+ the declaration of some type tag, if the given TYPE_DECL is
marked as having been instantiated from some other (original)
TYPE_DECL node (e.g. one which was generated within the original
definition of an inline function) we have to generate a special
(abbreviated) TAG_structure_type, TAG_union_type, or
TAG_enumeration-type DIE here. */
- if (! DECL_NAME (decl) && DECL_ABSTRACT_ORIGIN (decl))
+ if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl))
{
output_tagged_type_instantiation (TREE_TYPE (decl));
return;
output_type (TREE_TYPE (decl), containing_scope);
- /* Note that unlike the gcc front end (which generates a NULL named
- TYPE_DECL node for each complete tagged type, each array type,
- and each function type node created) the g++ front end generates
- a *named* TYPE_DECL node for each tagged type node created.
- These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
- generate a DW_TAG_typedef DIE for them. */
- if (DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
+ if (! is_redundant_typedef (decl))
/* Output a DIE to represent the typedef itself. */
output_die (output_typedef_die, decl);
break;
output_type (TREE_TYPE (decl), containing_scope);
+ {
+ /* And its containing type. */
+ register tree origin = decl_class_context (decl);
+ if (origin)
+ output_type (origin, containing_scope);
+ }
+
/* If the following DIE will represent a data object definition for a
data object with "extern" linkage, output a special "pubnames" DIE
label just ahead of the actual DIE. A reference to this label
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
+ if (! use_gnu_debug_info_extensions)
+ return;
function_section (current_function_decl);
sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
ASM_OUTPUT_LABEL (asm_out_file, label);
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
+ if (! use_gnu_debug_info_extensions)
+ return;
function_section (current_function_decl);
sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
ASM_OUTPUT_LABEL (asm_out_file, label);
char label[MAX_ARTIFICIAL_LABEL_BYTES];
static unsigned last_line_entry_num = 0;
static unsigned prev_file_entry_num = (unsigned) -1;
- register unsigned this_file_entry_num = lookup_filename (filename);
+ register unsigned this_file_entry_num;
function_section (current_function_decl);
sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
+ if (use_gnu_debug_info_extensions)
+ this_file_entry_num = lookup_filename (filename);
+ else
+ this_file_entry_num = (unsigned) -1;
+
if (this_file_entry_num != prev_file_entry_num)
{
char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES];
register char *type_and_offset;
register char *string;
{
+ if (! use_gnu_debug_info_extensions)
+ return;
+
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
fprintf (asm_out_file, "\t%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
if (debug_info_level >= DINFO_LEVEL_NORMAL)
{
- /* Output a starting label and an initial (compilation directory)
- entry for the .debug_sfnames section. The starting label will be
- referenced by the initial entry in the .debug_srcinfo section. */
+ if (use_gnu_debug_info_extensions)
+ {
+ /* Output a starting label and an initial (compilation directory)
+ entry for the .debug_sfnames section. The starting label will be
+ referenced by the initial entry in the .debug_srcinfo section. */
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
- {
- register char *pwd;
- register unsigned len;
- register char *dirname;
-
- pwd = getpwd ();
- if (!pwd)
- pfatal_with_name ("getpwd");
- len = strlen (pwd);
- dirname = (char *) xmalloc (len + 2);
+ fputc ('\n', asm_out_file);
+ ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
+ ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
+ {
+ register char *pwd;
+ register unsigned len;
+ register char *dirname;
+
+ pwd = getpwd ();
+ if (!pwd)
+ pfatal_with_name ("getpwd");
+ len = strlen (pwd);
+ dirname = (char *) xmalloc (len + 2);
- strcpy (dirname, pwd);
- strcpy (dirname + len, "/");
- ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
- free (dirname);
- }
- ASM_OUTPUT_POP_SECTION (asm_out_file);
+ strcpy (dirname, pwd);
+ strcpy (dirname + len, "/");
+ ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
+ free (dirname);
+ }
+ ASM_OUTPUT_POP_SECTION (asm_out_file);
+ }
- if (debug_info_level >= DINFO_LEVEL_VERBOSE)
+ if (debug_info_level >= DINFO_LEVEL_VERBOSE
+ && use_gnu_debug_info_extensions)
{
/* Output a starting label for the .debug_macinfo section. This
label will be referenced by the AT_mac_info attribute in the
ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
ASM_OUTPUT_POP_SECTION (asm_out_file);
- /* Generate the initial entry for the .debug_srcinfo section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
- ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
+ if (use_gnu_debug_info_extensions)
+ {
+ /* Generate the initial entry for the .debug_srcinfo section. */
+
+ fputc ('\n', asm_out_file);
+ ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
+ ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
#ifdef DWARF_TIMESTAMPS
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL));
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL));
#else
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
#endif
- ASM_OUTPUT_POP_SECTION (asm_out_file);
+ ASM_OUTPUT_POP_SECTION (asm_out_file);
+ }
/* Generate the initial entry for the .debug_pubnames section. */
ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL);
ASM_OUTPUT_POP_SECTION (asm_out_file);
- /* Output a terminating entry for the .debug_srcinfo section. */
-
- fputc ('\n', asm_out_file);
- ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
- ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
- LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL);
- ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
- ASM_OUTPUT_POP_SECTION (asm_out_file);
+ if (use_gnu_debug_info_extensions)
+ {
+ /* Output a terminating entry for the .debug_srcinfo section. */
+
+ fputc ('\n', asm_out_file);
+ ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
+ ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
+ LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL);
+ ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
+ ASM_OUTPUT_POP_SECTION (asm_out_file);
+ }
if (debug_info_level >= DINFO_LEVEL_VERBOSE)
{
OSDN Git Service
