rtx note, n;
bool handled_one = false;
- if (insn == NULL_RTX)
- {
- size_t i;
-
- /* Flush any queued register saves. */
- dwarf2out_flush_queued_reg_saves ();
-
- /* Set up state for generating call frame debug info. */
- lookup_cfa (&cfa);
- gcc_assert (cfa.reg
- == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
-
- cfa.reg = STACK_POINTER_REGNUM;
- cfa_store = cfa;
- cfa_temp.reg = -1;
- cfa_temp.offset = 0;
-
- for (i = 0; i < num_regs_saved_in_regs; i++)
- {
- regs_saved_in_regs[i].orig_reg = NULL_RTX;
- regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
- }
- num_regs_saved_in_regs = 0;
-
- if (barrier_args_size)
- {
- XDELETEVEC (barrier_args_size);
- barrier_args_size = NULL;
- }
- return;
- }
-
if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
dwarf2out_flush_queued_reg_saves ();
dwarf2out_flush_queued_reg_saves ();
}
+/* Called once at the start of final to initialize some data for the
+ current function. */
+void
+dwarf2out_frame_debug_init (void)
+{
+ size_t i;
+
+ /* Flush any queued register saves. */
+ dwarf2out_flush_queued_reg_saves ();
+
+ /* Set up state for generating call frame debug info. */
+ lookup_cfa (&cfa);
+ gcc_assert (cfa.reg
+ == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
+
+ cfa.reg = STACK_POINTER_REGNUM;
+ cfa_store = cfa;
+ cfa_temp.reg = -1;
+ cfa_temp.offset = 0;
+
+ for (i = 0; i < num_regs_saved_in_regs; i++)
+ {
+ regs_saved_in_regs[i].orig_reg = NULL_RTX;
+ regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
+ }
+ num_regs_saved_in_regs = 0;
+
+ if (barrier_args_size)
+ {
+ XDELETEVEC (barrier_args_size);
+ barrier_args_size = NULL;
+ }
+}
+
/* Determine if we need to save and restore CFI information around this
epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
we do need to save/restore, then emit the save now, and insert a
}
static void var_location_switch_text_section (void);
+static void set_cur_line_info_table (section *);
void
dwarf2out_switch_text_section (void)
cfi = cfi->dw_cfi_next;
fde->dw_fde_switch_cfi = cfi;
var_location_switch_text_section ();
+
+ set_cur_line_info_table (sect);
}
\f
/* And now, the subset of the debugging information support code necessary
typedef struct dw_attr_struct *dw_attr_ref;
typedef struct dw_line_info_struct *dw_line_info_ref;
-typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
typedef struct pubname_struct *pubname_ref;
typedef struct dw_ranges_struct *dw_ranges_ref;
typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
typedef struct comdat_type_struct *comdat_type_node_ref;
-/* Each entry in the line_info_table maintains the file and
- line number associated with the label generated for that
- entry. The label gives the PC value associated with
- the line number entry. */
+/* The entries in the line_info table more-or-less mirror the opcodes
+ that are used in the real dwarf line table. Arrays of these entries
+ are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
+ supported. */
+
+enum dw_line_info_opcode {
+ /* Emit DW_LNE_set_address; the operand is the label index. */
+ LI_set_address,
+
+ /* Emit a row to the matrix with the given line. This may be done
+ via any combination of DW_LNS_copy, DW_LNS_advance_line, and
+ special opcodes. */
+ LI_set_line,
+
+ /* Emit a DW_LNS_set_file. */
+ LI_set_file,
+
+ /* Emit a DW_LNS_set_column. */
+ LI_set_column,
+
+ /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
+ LI_negate_stmt,
+
+ /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
+ LI_set_prologue_end,
+ LI_set_epilogue_begin,
+
+ /* Emit a DW_LNE_set_discriminator. */
+ LI_set_discriminator
+};
typedef struct GTY(()) dw_line_info_struct {
- unsigned long dw_file_num;
- unsigned long dw_line_num;
-}
-dw_line_info_entry;
+ enum dw_line_info_opcode opcode;
+ unsigned int val;
+} dw_line_info_entry;
-/* Line information for functions in separate sections; each one gets its
- own sequence. */
-typedef struct GTY(()) dw_separate_line_info_struct {
- unsigned long dw_file_num;
- unsigned long dw_line_num;
- unsigned long function;
-}
-dw_separate_line_info_entry;
+DEF_VEC_O(dw_line_info_entry);
+DEF_VEC_ALLOC_O(dw_line_info_entry, gc);
+
+typedef struct GTY(()) dw_line_info_table_struct {
+ /* The label that marks the end of this section. */
+ const char *end_label;
+
+ /* The values for the last row of the matrix, as collected in the table.
+ These are used to minimize the changes to the next row. */
+ unsigned int file_num;
+ unsigned int line_num;
+ unsigned int column_num;
+ int discrim_num;
+ bool is_stmt;
+ bool in_use;
+
+ VEC(dw_line_info_entry, gc) *entries;
+} dw_line_info_table;
+
+typedef dw_line_info_table *dw_line_info_table_p;
+
+DEF_VEC_P(dw_line_info_table_p);
+DEF_VEC_ALLOC_P(dw_line_info_table_p, gc);
/* Each DIE attribute has a field specifying the attribute kind,
a link to the next attribute in the chain, and an attribute value.
#define DWARF_LINE_BASE -10
/* First special line opcode - leave room for the standard opcodes. */
-#define DWARF_LINE_OPCODE_BASE 10
+#define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
/* Range of line offsets in a special line info. opcode. */
#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
abbrev_die_table. */
#define ABBREV_DIE_TABLE_INCREMENT 256
-/* A pointer to the base of a table that contains line information
- for each source code line in .text in the compilation unit. */
-static GTY((length ("line_info_table_allocated")))
- dw_line_info_ref line_info_table;
-
-/* Number of elements currently allocated for line_info_table. */
-static GTY(()) unsigned line_info_table_allocated;
-
-/* Number of elements in line_info_table currently in use. */
-static GTY(()) unsigned line_info_table_in_use;
+/* A global counter for generating labels for line number data. */
+static unsigned int line_info_label_num;
-/* A pointer to the base of a table that contains line information
- for each source code line outside of .text in the compilation unit. */
-static GTY ((length ("separate_line_info_table_allocated")))
- dw_separate_line_info_ref separate_line_info_table;
+/* The current table to which we should emit line number information
+ for the current function. This will be set up at the beginning of
+ assembly for the function. */
+static dw_line_info_table *cur_line_info_table;
-/* Number of elements currently allocated for separate_line_info_table. */
-static GTY(()) unsigned separate_line_info_table_allocated;
+/* The two default tables of line number info. */
+static GTY(()) dw_line_info_table *text_section_line_info;
+static GTY(()) dw_line_info_table *cold_text_section_line_info;
-/* Number of elements in separate_line_info_table currently in use. */
-static GTY(()) unsigned separate_line_info_table_in_use;
-
-/* Size (in elements) of increments by which we may expand the
- line_info_table. */
-#define LINE_INFO_TABLE_INCREMENT 1024
+/* The set of all non-default tables of line number info. */
+static GTY(()) VEC (dw_line_info_table_p, gc) *separate_line_info;
/* A flag to tell pubnames/types export if there is an info section to
refer to. */
static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
static void print_spaces (FILE *);
static void print_die (dw_die_ref, FILE *);
-static void print_dwarf_line_table (FILE *);
static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
static dw_die_ref pop_compile_unit (dw_die_ref);
static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
bool *);
static void output_ranges (void);
+static dw_line_info_table *new_line_info_table (void);
static void output_line_info (void);
static void output_file_names (void);
static dw_die_ref base_type_die (tree);
static bool tree_add_const_value_attribute (dw_die_ref, tree);
static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
static void add_name_attribute (dw_die_ref, const char *);
+static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
static void add_comp_dir_attribute (dw_die_ref);
static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
static void add_subscript_info (dw_die_ref, tree, bool);
#ifndef LINE_CODE_LABEL
#define LINE_CODE_LABEL "LM"
#endif
-#ifndef SEPARATE_LINE_CODE_LABEL
-#define SEPARATE_LINE_CODE_LABEL "LSM"
-#endif
\f
/* Return the root of the DIE's built for the current compilation unit. */
return "DW_AT_body_begin";
case DW_AT_body_end:
return "DW_AT_body_end";
+
case DW_AT_GNU_vector:
return "DW_AT_GNU_vector";
case DW_AT_GNU_guarded_by:
case DW_AT_GNU_all_source_call_sites:
return "DW_AT_GNU_all_source_call_sites";
+ case DW_AT_GNAT_descriptive_type:
+ return "DW_AT_GNAT_descriptive_type";
+
case DW_AT_VMS_rtnbeg_pd_address:
return "DW_AT_VMS_rtnbeg_pd_address";
fprintf (outfile, "\n");
}
-/* Print the contents of the source code line number correspondence table.
- This routine is a debugging aid only. */
-
-static void
-print_dwarf_line_table (FILE *outfile)
-{
- unsigned i;
- dw_line_info_ref line_info;
-
- fprintf (outfile, "\n\nDWARF source line information\n");
- for (i = 1; i < line_info_table_in_use; i++)
- {
- line_info = &line_info_table[i];
- fprintf (outfile, "%5d: %4ld %6ld\n", i,
- line_info->dw_file_num,
- line_info->dw_line_num);
- }
-
- fprintf (outfile, "\n\n");
-}
-
/* Print the information collected for a given DIE. */
DEBUG_FUNCTION void
{
print_indent = 0;
print_die (comp_unit_die (), stderr);
- if (! DWARF2_ASM_LINE_DEBUG_INFO)
- print_dwarf_line_table (stderr);
}
\f
/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
}
+/* Output one line number table into the .debug_line section. */
+
+static void
+output_one_line_info_table (dw_line_info_table *table)
+{
+ char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
+ unsigned int current_line = 1;
+ bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
+ dw_line_info_entry *ent;
+ size_t i;
+
+ FOR_EACH_VEC_ELT (dw_line_info_entry, table->entries, i, ent)
+ {
+ switch (ent->opcode)
+ {
+ case LI_set_address:
+ /* ??? Unfortunately, we have little choice here currently, and
+ must always use the most general form. GCC does not know the
+ address delta itself, so we can't use DW_LNS_advance_pc. Many
+ ports do have length attributes which will give an upper bound
+ on the address range. We could perhaps use length attributes
+ to determine when it is safe to use DW_LNS_fixed_advance_pc. */
+ ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
+
+ /* This can handle any delta. This takes
+ 4+DWARF2_ADDR_SIZE bytes. */
+ dw2_asm_output_data (1, 0, "set address %s", line_label);
+ dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
+ dw2_asm_output_data (1, DW_LNE_set_address, NULL);
+ dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
+ break;
+
+ case LI_set_line:
+ if (ent->val == current_line)
+ {
+ /* We still need to start a new row, so output a copy insn. */
+ dw2_asm_output_data (1, DW_LNS_copy,
+ "copy line %u", current_line);
+ }
+ else
+ {
+ int line_offset = ent->val - current_line;
+ int line_delta = line_offset - DWARF_LINE_BASE;
+
+ current_line = ent->val;
+ if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
+ {
+ /* This can handle deltas from -10 to 234, using the current
+ definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
+ This takes 1 byte. */
+ dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
+ "line %u", current_line);
+ }
+ else
+ {
+ /* This can handle any delta. This takes at least 4 bytes,
+ depending on the value being encoded. */
+ dw2_asm_output_data (1, DW_LNS_advance_line,
+ "advance to line %u", current_line);
+ dw2_asm_output_data_sleb128 (line_offset, NULL);
+ dw2_asm_output_data (1, DW_LNS_copy, NULL);
+ }
+ }
+ break;
+
+ case LI_set_file:
+ dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
+ dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
+ break;
+
+ case LI_set_column:
+ dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
+ dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
+ break;
+
+ case LI_negate_stmt:
+ current_is_stmt = !current_is_stmt;
+ dw2_asm_output_data (1, DW_LNS_negate_stmt,
+ "is_stmt %d", current_is_stmt);
+ break;
+
+ case LI_set_prologue_end:
+ dw2_asm_output_data (1, DW_LNS_set_prologue_end,
+ "set prologue end");
+ break;
+
+ case LI_set_epilogue_begin:
+ dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
+ "set epilogue begin");
+ break;
+
+ case LI_set_discriminator:
+ dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
+ dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
+ dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
+ dw2_asm_output_data_uleb128 (ent->val, NULL);
+ break;
+ }
+ }
+
+ /* Emit debug info for the address of the end of the table. */
+ dw2_asm_output_data (1, 0, "set address %s", table->end_label);
+ dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
+ dw2_asm_output_data (1, DW_LNE_set_address, NULL);
+ dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
+
+ dw2_asm_output_data (1, 0, "end sequence");
+ dw2_asm_output_data_uleb128 (1, NULL);
+ dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
+}
+
/* Output the source line number correspondence information. This
information goes into the .debug_line section. */
output_line_info (void)
{
char l1[20], l2[20], p1[20], p2[20];
- char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
- char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
- unsigned opc;
- unsigned n_op_args;
- unsigned long lt_index;
- unsigned long current_line;
- long line_offset;
- long line_delta;
- unsigned long current_file;
- unsigned long function;
int ver = dwarf_version;
+ int opc;
ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
ASM_OUTPUT_LABEL (asm_out_file, p1);
- /* Define the architecture-dependent minimum instruction length (in
- bytes). In this implementation of DWARF, this field is used for
- information purposes only. Since GCC generates assembly language,
- we have no a priori knowledge of how many instruction bytes are
- generated for each source line, and therefore can use only the
- DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
- commands. Accordingly, we fix this as `1', which is "correct
- enough" for all architectures, and don't let the target override. */
- dw2_asm_output_data (1, 1,
- "Minimum Instruction Length");
+ /* Define the architecture-dependent minimum instruction length (in bytes).
+ In this implementation of DWARF, this field is used for information
+ purposes only. Since GCC generates assembly language, we have no
+ a priori knowledge of how many instruction bytes are generated for each
+ source line, and therefore can use only the DW_LNE_set_address and
+ DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
+ this as '1', which is "correct enough" for all architectures,
+ and don't let the target override. */
+ dw2_asm_output_data (1, 1, "Minimum Instruction Length");
if (ver >= 4)
dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
{
+ int n_op_args;
switch (opc)
{
case DW_LNS_advance_pc:
case DW_LNS_set_file:
case DW_LNS_set_column:
case DW_LNS_fixed_advance_pc:
+ case DW_LNS_set_isa:
n_op_args = 1;
break;
default:
output_file_names ();
ASM_OUTPUT_LABEL (asm_out_file, p2);
- /* We used to set the address register to the first location in the text
- section here, but that didn't accomplish anything since we already
- have a line note for the opening brace of the first function. */
-
- /* Generate the line number to PC correspondence table, encoded as
- a series of state machine operations. */
- current_file = 1;
- current_line = 1;
-
- if (cfun && in_cold_section_p)
- strcpy (prev_line_label, crtl->subsections.cold_section_label);
- else
- strcpy (prev_line_label, text_section_label);
- for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
- {
- dw_line_info_ref line_info = &line_info_table[lt_index];
-
-#if 0
- /* Disable this optimization for now; GDB wants to see two line notes
- at the beginning of a function so it can find the end of the
- prologue. */
-
- /* Don't emit anything for redundant notes. Just updating the
- address doesn't accomplish anything, because we already assume
- that anything after the last address is this line. */
- if (line_info->dw_line_num == current_line
- && line_info->dw_file_num == current_file)
- continue;
-#endif
-
- /* Emit debug info for the address of the current line.
-
- Unfortunately, we have little choice here currently, and must always
- use the most general form. GCC does not know the address delta
- itself, so we can't use DW_LNS_advance_pc. Many ports do have length
- attributes which will give an upper bound on the address range. We
- could perhaps use length attributes to determine when it is safe to
- use DW_LNS_fixed_advance_pc. */
-
- ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
- if (0)
- {
- /* This can handle deltas up to 0xffff. This takes 3 bytes. */
- dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
- "DW_LNS_fixed_advance_pc");
- dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
- }
- else
- {
- /* This can handle any delta. This takes
- 4+DWARF2_ADDR_SIZE bytes. */
- dw2_asm_output_data (1, 0, "DW_LNE_set_address");
- dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
- dw2_asm_output_data (1, DW_LNE_set_address, NULL);
- dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
- }
-
- strcpy (prev_line_label, line_label);
-
- /* Emit debug info for the source file of the current line, if
- different from the previous line. */
- if (line_info->dw_file_num != current_file)
- {
- current_file = line_info->dw_file_num;
- dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
- dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
- }
-
- /* Emit debug info for the current line number, choosing the encoding
- that uses the least amount of space. */
- 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))
- /* This can handle deltas from -10 to 234, using the current
- definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
- takes 1 byte. */
- dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
- "line %lu", current_line);
- else
- {
- /* This can handle any delta. This takes at least 4 bytes,
- depending on the value being encoded. */
- dw2_asm_output_data (1, DW_LNS_advance_line,
- "advance to line %lu", current_line);
- dw2_asm_output_data_sleb128 (line_offset, NULL);
- dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
- }
- }
- else
- /* We still need to start a new row, so output a copy insn. */
- dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
- }
-
- /* Emit debug info for the address of the end of the function. */
- if (0)
- {
- dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
- "DW_LNS_fixed_advance_pc");
- dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
- }
- else
- {
- dw2_asm_output_data (1, 0, "DW_LNE_set_address");
- dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
- dw2_asm_output_data (1, DW_LNE_set_address, NULL);
- dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
- }
-
- dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
- dw2_asm_output_data_uleb128 (1, NULL);
- dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
+ if (text_section_line_info && text_section_line_info->in_use)
+ output_one_line_info_table (text_section_line_info);
+ if (cold_text_section_line_info && cold_text_section_line_info->in_use)
+ output_one_line_info_table (cold_text_section_line_info);
- function = 0;
- current_file = 1;
- current_line = 1;
- for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
+ if (separate_line_info)
{
- dw_separate_line_info_ref line_info
- = &separate_line_info_table[lt_index];
-
-#if 0
- /* Don't emit anything for redundant notes. */
- if (line_info->dw_line_num == current_line
- && line_info->dw_file_num == current_file
- && line_info->function == function)
- goto cont;
-#endif
-
- /* Emit debug info for the address of the current line. If this is
- a new function, or the first line of a function, then we need
- to handle it differently. */
- ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
- lt_index);
- if (function != line_info->function)
- {
- function = line_info->function;
-
- /* Set the address register to the first line in the function. */
- dw2_asm_output_data (1, 0, "DW_LNE_set_address");
- dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
- dw2_asm_output_data (1, DW_LNE_set_address, NULL);
- dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
- }
- else
- {
- /* ??? See the DW_LNS_advance_pc comment above. */
- if (0)
- {
- dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
- "DW_LNS_fixed_advance_pc");
- dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
- }
- else
- {
- dw2_asm_output_data (1, 0, "DW_LNE_set_address");
- dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
- dw2_asm_output_data (1, DW_LNE_set_address, NULL);
- dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
- }
- }
-
- strcpy (prev_line_label, line_label);
-
- /* Emit debug info for the source file of the current line, if
- different from the previous line. */
- if (line_info->dw_file_num != current_file)
- {
- current_file = line_info->dw_file_num;
- dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
- dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
- }
-
- /* Emit debug info for the current line number, choosing the encoding
- that uses the least amount of space. */
- 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))
- dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
- "line %lu", current_line);
- else
- {
- dw2_asm_output_data (1, DW_LNS_advance_line,
- "advance to line %lu", current_line);
- dw2_asm_output_data_sleb128 (line_offset, NULL);
- dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
- }
- }
- else
- dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
-
-#if 0
- cont:
-#endif
-
- lt_index++;
-
- /* If we're done with a function, end its sequence. */
- if (lt_index == separate_line_info_table_in_use
- || separate_line_info_table[lt_index].function != function)
- {
- current_file = 1;
- current_line = 1;
-
- /* Emit debug info for the address of the end of the function. */
- ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
- if (0)
- {
- dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
- "DW_LNS_fixed_advance_pc");
- dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
- }
- else
- {
- dw2_asm_output_data (1, 0, "DW_LNE_set_address");
- dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
- dw2_asm_output_data (1, DW_LNE_set_address, NULL);
- dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
- }
+ dw_line_info_table *table;
+ size_t i;
- /* Output the marker for the end of this sequence. */
- dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
- dw2_asm_output_data_uleb128 (1, NULL);
- dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
- }
+ FOR_EACH_VEC_ELT (dw_line_info_table_p, separate_line_info, i, table)
+ if (table->in_use)
+ output_one_line_info_table (table);
}
/* Output the marker for the end of the line number info. */
useful source coordinates anyway. */
name = DECL_NAME (name);
add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
+ add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
}
/* This probably indicates a bug. */
else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
break;
case LO_SUM:
- rtl = XEXP (rtl, 1);
-
- /* ... fall through ... */
+ return mem_loc_descriptor (XEXP (rtl, 1), mode, initialized);
case LABEL_REF:
/* Some ports can transform a symbol ref into a label ref, because
}
}
+/* Retrieve the descriptive type of TYPE, if any, make sure it has a
+ DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
+ of TYPE accordingly.
+
+ ??? This is a temporary measure until after we're able to generate
+ regular DWARF for the complex Ada type system. */
+
+static void
+add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
+ dw_die_ref context_die)
+{
+ tree dtype;
+ dw_die_ref dtype_die;
+
+ if (!lang_hooks.types.descriptive_type)
+ return;
+
+ dtype = lang_hooks.types.descriptive_type (type);
+ if (!dtype)
+ return;
+
+ dtype_die = lookup_type_die (dtype);
+ if (!dtype_die)
+ {
+ gen_type_die (dtype, context_die);
+ dtype_die = lookup_type_die (dtype);
+ gcc_assert (dtype_die);
+ }
+
+ add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
+}
+
/* Generate a DW_AT_comp_dir attribute for DIE. */
static void
array_die = new_die (DW_TAG_array_type, scope_die, type);
add_name_attribute (array_die, type_tag (type));
+ add_gnat_descriptive_type_attribute (array_die, type, context_die);
equate_type_number_to_die (type, array_die);
if (TREE_CODE (type) == VECTOR_TYPE)
scope_die_for (type, context_die), type);
equate_type_number_to_die (type, type_die);
add_name_attribute (type_die, type_tag (type));
+ add_gnat_descriptive_type_attribute (type_die, type, context_die);
if (dwarf_version >= 4 || !dwarf_strict)
{
if (ENUM_IS_SCOPED (type))
if (old_die)
add_AT_specification (type_die, old_die);
else
- add_name_attribute (type_die, type_tag (type));
+ {
+ add_name_attribute (type_die, type_tag (type));
+ add_gnat_descriptive_type_attribute (type_die, type, context_die);
+ }
}
else
remove_AT (type_die, DW_AT_declaration);
htab_traverse (decl_loc_table, var_location_switch_text_section_1, NULL);
}
+/* Create a new line number table. */
+
+static dw_line_info_table *
+new_line_info_table (void)
+{
+ dw_line_info_table *table;
+
+ table = ggc_alloc_cleared_dw_line_info_table_struct ();
+ table->file_num = 1;
+ table->line_num = 1;
+ table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
+
+ return table;
+}
+
+/* Lookup the "current" table into which we emit line info, so
+ that we don't have to do it for every source line. */
+
+static void
+set_cur_line_info_table (section *sec)
+{
+ dw_line_info_table *table;
+
+ if (sec == text_section)
+ {
+ table = text_section_line_info;
+ if (!table)
+ {
+ text_section_line_info = table = new_line_info_table ();
+ table->end_label = text_end_label;
+ }
+ }
+ else if (sec == cold_text_section)
+ {
+ table = cold_text_section_line_info;
+ if (!table)
+ {
+ cold_text_section_line_info = table = new_line_info_table ();
+ table->end_label = cold_end_label;
+ }
+ }
+ else
+ {
+ const char *end_label;
+
+ if (flag_reorder_blocks_and_partition)
+ {
+ if (in_cold_section_p)
+ end_label = crtl->subsections.cold_section_end_label;
+ else
+ end_label = crtl->subsections.hot_section_end_label;
+ }
+ else
+ {
+ char label[MAX_ARTIFICIAL_LABEL_BYTES];
+ ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
+ current_function_funcdef_no);
+ end_label = ggc_strdup (label);
+ }
+
+ table = new_line_info_table ();
+ table->end_label = end_label;
+
+ VEC_safe_push (dw_line_info_table_p, gc, separate_line_info, table);
+ }
+
+ cur_line_info_table = table;
+}
+
+
/* We need to reset the locations at the beginning of each
function. We can't do this in the end_function hook, because the
declarations that use the locations won't have been output when
static void
dwarf2out_begin_function (tree fun)
{
- if (function_section (fun) != text_section)
+ section *sec = function_section (fun);
+
+ if (sec != text_section)
have_multiple_function_sections = true;
+
if (flag_reorder_blocks_and_partition && !cold_text_section)
{
gcc_assert (current_function_decl == fun);
cold_text_section = unlikely_text_section ();
switch_to_section (cold_text_section);
ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
- switch_to_section (current_function_section ());
+ switch_to_section (sec);
}
dwarf2out_note_section_used ();
call_site_count = 0;
tail_call_site_count = 0;
+
+ set_cur_line_info_table (sec);
+}
+
+/* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
+
+static void
+push_dw_line_info_entry (dw_line_info_table *table,
+ enum dw_line_info_opcode opcode, unsigned int val)
+{
+ dw_line_info_entry e;
+ e.opcode = opcode;
+ e.val = val;
+ VEC_safe_push (dw_line_info_entry, gc, table->entries, &e);
}
/* Output a label to mark the beginning of a source code line entry
and record information relating to this source line, in
'line_info_table' for later output of the .debug_line section. */
+/* ??? The discriminator parameter ought to be unsigned. */
static void
dwarf2out_source_line (unsigned int line, const char *filename,
int discriminator, bool is_stmt)
{
- static bool last_is_stmt = true;
-
- if (debug_info_level >= DINFO_LEVEL_NORMAL
- && line != 0)
- {
- int file_num = maybe_emit_file (lookup_filename (filename));
+ unsigned int file_num;
+ dw_line_info_table *table;
- switch_to_section (current_function_section ());
-
- /* If requested, emit something human-readable. */
- if (flag_debug_asm)
- fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
- filename, line);
+ if (debug_info_level < DINFO_LEVEL_NORMAL || line == 0)
+ return;
- if (DWARF2_ASM_LINE_DEBUG_INFO)
- {
- /* Emit the .loc directive understood by GNU as. */
- fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
- if (is_stmt != last_is_stmt)
- {
- fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
- last_is_stmt = is_stmt;
- }
- if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
- fprintf (asm_out_file, " discriminator %d", discriminator);
- fputc ('\n', asm_out_file);
+ /* The discriminator column was added in dwarf4. Simplify the below
+ by simply removing it if we're not supposed to output it. */
+ if (dwarf_version < 4 && dwarf_strict)
+ discriminator = 0;
+
+ table = cur_line_info_table;
+ file_num = maybe_emit_file (lookup_filename (filename));
+
+ /* ??? TODO: Elide duplicate line number entries. Traditionally,
+ the debugger has used the second (possibly duplicate) line number
+ at the beginning of the function to mark the end of the prologue.
+ We could eliminate any other duplicates within the function. For
+ Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
+ that second line number entry. */
+ /* Recall that this end-of-prologue indication is *not* the same thing
+ as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
+ to which the hook corresponds, follows the last insn that was
+ emitted by gen_prologue. What we need is to preceed the first insn
+ that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
+ insn that corresponds to something the user wrote. These may be
+ very different locations once scheduling is enabled. */
+
+ if (0 && file_num == table->file_num
+ && line == table->line_num
+ && discriminator == table->discrim_num
+ && is_stmt == table->is_stmt)
+ return;
- /* Indicate that line number info exists. */
- line_info_table_in_use++;
- }
- else if (function_section (current_function_decl) != text_section)
- {
- dw_separate_line_info_ref line_info;
- targetm.asm_out.internal_label (asm_out_file,
- SEPARATE_LINE_CODE_LABEL,
- separate_line_info_table_in_use);
-
- /* Expand the line info table if necessary. */
- if (separate_line_info_table_in_use
- == separate_line_info_table_allocated)
- {
- separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
- separate_line_info_table
- = GGC_RESIZEVEC (dw_separate_line_info_entry,
- separate_line_info_table,
- separate_line_info_table_allocated);
- memset (separate_line_info_table
- + separate_line_info_table_in_use,
- 0,
- (LINE_INFO_TABLE_INCREMENT
- * sizeof (dw_separate_line_info_entry)));
- }
+ switch_to_section (current_function_section ());
- /* Add the new entry at the end of the line_info_table. */
- line_info
- = &separate_line_info_table[separate_line_info_table_in_use++];
- line_info->dw_file_num = file_num;
- line_info->dw_line_num = line;
- line_info->function = current_function_funcdef_no;
- }
- else
- {
- dw_line_info_ref line_info;
+ /* If requested, emit something human-readable. */
+ if (flag_debug_asm)
+ fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
- targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
- line_info_table_in_use);
+ if (DWARF2_ASM_LINE_DEBUG_INFO)
+ {
+ /* Emit the .loc directive understood by GNU as. */
+ fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
+ if (is_stmt != table->is_stmt)
+ fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
+ if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
+ fprintf (asm_out_file, " discriminator %d", discriminator);
+ fputc ('\n', asm_out_file);
+ }
+ else
+ {
+ unsigned int label_num = ++line_info_label_num;
- /* Expand the line info table if necessary. */
- if (line_info_table_in_use == line_info_table_allocated)
- {
- line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
- line_info_table
- = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
- line_info_table_allocated);
- memset (line_info_table + line_info_table_in_use, 0,
- LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
- }
+ targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
- /* Add the new entry at the end of the line_info_table. */
- line_info = &line_info_table[line_info_table_in_use++];
- line_info->dw_file_num = file_num;
- line_info->dw_line_num = line;
- }
+ push_dw_line_info_entry (table, LI_set_address, label_num);
+ if (file_num != table->file_num)
+ push_dw_line_info_entry (table, LI_set_file, file_num);
+ if (discriminator != table->discrim_num)
+ push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
+ if (is_stmt != table->is_stmt)
+ push_dw_line_info_entry (table, LI_negate_stmt, 0);
+ push_dw_line_info_entry (table, LI_set_line, line);
}
+
+ table->file_num = file_num;
+ table->line_num = line;
+ table->discrim_num = discriminator;
+ table->is_stmt = is_stmt;
+ table->in_use = true;
}
/* Record the beginning of a new source file. */
/* Zero-th entry is allocated, but unused. */
abbrev_die_table_in_use = 1;
- /* Allocate the initial hunk of the line_info_table. */
- line_info_table = ggc_alloc_cleared_vec_dw_line_info_entry
- (LINE_INFO_TABLE_INCREMENT);
- line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
-
- /* Zero-th entry is allocated, but unused. */
- line_info_table_in_use = 1;
-
/* Allocate the pubtypes and pubnames vectors. */
pubname_table = VEC_alloc (pubname_entry, gc, 32);
pubtype_table = VEC_alloc (pubname_entry, gc, 32);
{
tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
dw_die_ref tdie = lookup_decl_die (tdecl);
- if (tdie == NULL && DECL_EXTERNAL (tdecl))
+ if (tdie == NULL
+ && DECL_EXTERNAL (tdecl)
+ && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE)
{
force_decl_die (tdecl);
tdie = lookup_decl_die (tdecl);
if (!have_multiple_function_sections
|| (dwarf_version < 3 && dwarf_strict))
{
- add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc, text_section_label);
- add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc, text_end_label);
+ /* Don't add if the CU has no associated code. */
+ if (text_section_used)
+ {
+ add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc, text_section_label);
+ add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc, text_end_label);
+ }
}
-
else
{
unsigned fde_idx = 0;
bool range_list_added = false;
- /* We need to give .debug_loc and .debug_ranges an appropriate
- "base address". Use zero so that these addresses become
- absolute. Historically, we've emitted the unexpected
- DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
- Emit both to give time for other tools to adapt. */
- add_AT_addr (comp_unit_die (), DW_AT_low_pc, const0_rtx);
- add_AT_addr (comp_unit_die (), DW_AT_entry_pc, const0_rtx);
-
if (text_section_used)
add_ranges_by_labels (comp_unit_die (), text_section_label,
text_end_label, &range_list_added);
}
if (range_list_added)
- add_ranges (NULL);
+ {
+ /* We need to give .debug_loc and .debug_ranges an appropriate
+ "base address". Use zero so that these addresses become
+ absolute. Historically, we've emitted the unexpected
+ DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
+ Emit both to give time for other tools to adapt. */
+ add_AT_addr (comp_unit_die (), DW_AT_low_pc, const0_rtx);
+ if (! dwarf_strict && dwarf_version < 4)
+ add_AT_addr (comp_unit_die (), DW_AT_entry_pc, const0_rtx);
+
+ add_ranges (NULL);
+ }
}
if (debug_info_level >= DINFO_LEVEL_NORMAL)