diff options
Diffstat (limited to 'contrib/binutils/gas/dwarf2dbg.c')
-rw-r--r-- | contrib/binutils/gas/dwarf2dbg.c | 462 |
1 files changed, 286 insertions, 176 deletions
diff --git a/contrib/binutils/gas/dwarf2dbg.c b/contrib/binutils/gas/dwarf2dbg.c index 3336453..16666fa 100644 --- a/contrib/binutils/gas/dwarf2dbg.c +++ b/contrib/binutils/gas/dwarf2dbg.c @@ -1,5 +1,6 @@ /* dwarf2dbg.c - DWARF2 debug support - Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. Contributed by David Mosberger-Tang <davidm@hpl.hp.com> This file is part of GAS, the GNU Assembler. @@ -16,19 +17,20 @@ You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free - Software Foundation, 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ /* Logical line numbers can be controlled by the compiler via the - following two directives: + following directives: .file FILENO "file.c" - .loc FILENO LINENO [COLUMN] - - FILENO is the filenumber. */ + .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \ + [epilogue_begin] [is_stmt VALUE] [isa VALUE] +*/ #include "ansidecl.h" #include "as.h" +#include "safe-ctype.h" #ifdef HAVE_LIMITS_H #include <limits.h> @@ -52,8 +54,6 @@ # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) #endif -#ifdef BFD_ASSEMBLER - #include "subsegs.h" #include "elf/dwarf2.h" @@ -69,8 +69,8 @@ /* First special line opcde - leave room for the standard opcodes. Note: If you want to change this, you'll have to update the "standard_opcode_lengths" table that is emitted below in - dwarf2_finish(). */ -#define DWARF2_LINE_OPCODE_BASE 10 + out_debug_line(). */ +#define DWARF2_LINE_OPCODE_BASE 13 #ifndef DWARF2_LINE_BASE /* Minimum line offset in a special line info. opcode. This value @@ -89,10 +89,7 @@ # define DWARF2_LINE_MIN_INSN_LENGTH 1 #endif -/* Flag that indicates the initial value of the is_stmt_start flag. - In the present implementation, we do not mark any lines as - the beginning of a source statement, because that information - is not made available by the GCC front-end. */ +/* Flag that indicates the initial value of the is_stmt_start flag. */ #define DWARF2_LINE_DEFAULT_IS_STMT 1 /* Given a special op, return the line skip amount. */ @@ -108,8 +105,7 @@ struct line_entry { struct line_entry *next; - fragS *frag; - addressT frag_ofs; + symbolS *label; struct dwarf2_line_info loc; }; @@ -150,8 +146,15 @@ static unsigned int dirs_allocated; doing work when there's nothing to do. */ static bfd_boolean loc_directive_seen; +/* TRUE when we're supposed to set the basic block mark whenever a + label is seen. */ +bfd_boolean dwarf2_loc_mark_labels; + /* Current location as indicated by the most recent .loc directive. */ -static struct dwarf2_line_info current; +static struct dwarf2_line_info current = { + 1, 1, 0, 0, + DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0 +}; /* The size of an address on the target. */ static unsigned int sizeof_address; @@ -167,12 +170,11 @@ static void out_four (int); static void out_abbrev (int, int); static void out_uleb128 (addressT); static offsetT get_frag_fix (fragS *); -static void out_set_addr (segT, fragS *, addressT); +static void out_set_addr (symbolS *); static int size_inc_line_addr (int, addressT); static void emit_inc_line_addr (int, addressT, char *, int); static void out_inc_line_addr (int, addressT); -static void relax_inc_line_addr (int, segT, fragS *, addressT, - fragS *, addressT); +static void relax_inc_line_addr (int, symbolS *, symbolS *); static void process_entries (segT, struct line_entry *); static void out_file_list (void); static void out_debug_line (segT); @@ -207,21 +209,21 @@ get_line_subseg (segT seg, subsegT subseg) static subsegT last_subseg; static struct line_subseg *last_line_subseg; - struct line_seg *s; + struct line_seg **ps, *s; struct line_subseg **pss, *ss; if (seg == last_seg && subseg == last_subseg) return last_line_subseg; - for (s = all_segs; s; s = s->next) + for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next) if (s->seg == seg) goto found_seg; s = (struct line_seg *) xmalloc (sizeof (*s)); - s->next = all_segs; + s->next = NULL; s->seg = seg; s->head = NULL; - all_segs = s; + *ps = s; found_seg: for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next) @@ -247,16 +249,34 @@ get_line_subseg (segT seg, subsegT subseg) return ss; } +/* Record an entry for LOC occurring at LABEL. */ + +static void +dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) +{ + struct line_subseg *ss; + struct line_entry *e; + + e = (struct line_entry *) xmalloc (sizeof (*e)); + e->next = NULL; + e->label = label; + e->loc = *loc; + + ss = get_line_subseg (now_seg, now_subseg); + *ss->ptail = e; + ss->ptail = &e->next; +} + /* Record an entry for LOC occurring at OFS within the current fragment. */ void dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) { - struct line_subseg *ss; - struct line_entry *e; static unsigned int line = -1; static unsigned int filenum = -1; + symbolS *sym; + /* Early out for as-yet incomplete location information. */ if (loc->filenum == 0 || loc->line == 0) return; @@ -272,17 +292,15 @@ dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) line = loc->line; filenum = loc->filenum; - e = (struct line_entry *) xmalloc (sizeof (*e)); - e->next = NULL; - e->frag = frag_now; - e->frag_ofs = ofs; - e->loc = *loc; - - ss = get_line_subseg (now_seg, now_subseg); - *ss->ptail = e; - ss->ptail = &e->next; + sym = symbol_temp_new (now_seg, ofs, frag_now); + dwarf2_gen_line_info_1 (sym, loc); } +/* Returns the current source information. If .file directives have + been encountered, the info for the corresponding source file is + returned. Otherwise, the info for the assembly source file is + returned. */ + void dwarf2_where (struct dwarf2_line_info *line) { @@ -292,12 +310,22 @@ dwarf2_where (struct dwarf2_line_info *line) as_where (&filename, &line->line); line->filenum = get_filenum (filename, 0); line->column = 0; - line->flags = DWARF2_FLAG_BEGIN_STMT; + line->flags = DWARF2_FLAG_IS_STMT; + line->isa = current.isa; } else *line = current; } +/* A hook to allow the target backend to inform the line number state + machine of isa changes when assembler debug info is enabled. */ + +void +dwarf2_set_isa (unsigned int isa) +{ + current.isa = isa; +} + /* Called for each machine instruction, or relatively atomic group of machine instructions (ie built-in macro). The instruction or group is SIZE bytes in length. If dwarf2 line number generation is called @@ -325,9 +353,45 @@ dwarf2_emit_insn (int size) else if (debug_type != DEBUG_DWARF2) return; else - dwarf2_where (& loc); + dwarf2_where (&loc); dwarf2_gen_line_info (frag_now_fix () - size, &loc); + + current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK + | DWARF2_FLAG_PROLOGUE_END + | DWARF2_FLAG_EPILOGUE_BEGIN); +} + +/* Called for each (preferably code) label. If dwarf2_loc_mark_labels + is enabled, emit a basic block marker. */ + +void +dwarf2_emit_label (symbolS *label) +{ + struct dwarf2_line_info loc; + + if (!dwarf2_loc_mark_labels) + return; + if (S_GET_SEGMENT (label) != now_seg) + return; + if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)) + return; + + if (debug_type == DEBUG_DWARF2) + dwarf2_where (&loc); + else + { + loc = current; + loc_directive_seen = FALSE; + } + + loc.flags |= DWARF2_FLAG_BASIC_BLOCK; + + current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK + | DWARF2_FLAG_PROLOGUE_END + | DWARF2_FLAG_EPILOGUE_BEGIN); + + dwarf2_gen_line_info_1 (label, &loc); } /* Get a .debug_line file number for FILENAME. If NUM is nonzero, @@ -420,7 +484,8 @@ get_filenum (const char *filename, unsigned int num) files[i].filename = num ? file : xstrdup (file); files[i].dir = dir; - files_in_use = i + 1; + if (files_in_use < i + 1) + files_in_use = i + 1; last_used = i; last_used_dir_len = dir_len; @@ -450,6 +515,8 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) num = get_absolute_expression (); filename = demand_copy_C_string (&filename_len); + if (filename == NULL) + return NULL; demand_empty_rest_of_line (); if (num < 1) @@ -472,14 +539,11 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) void dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { - offsetT filenum, line, column; + offsetT filenum, line; filenum = get_absolute_expression (); SKIP_WHITESPACE (); line = get_absolute_expression (); - SKIP_WHITESPACE (); - column = get_absolute_expression (); - demand_empty_rest_of_line (); if (filenum < 1) { @@ -494,10 +558,6 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) current.filenum = filenum; current.line = line; - current.column = column; - current.flags = DWARF2_FLAG_BEGIN_STMT; - - loc_directive_seen = TRUE; #ifndef NO_LISTING if (listing) @@ -519,6 +579,92 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) listing_source_line (line); } #endif + + SKIP_WHITESPACE (); + if (ISDIGIT (*input_line_pointer)) + { + current.column = get_absolute_expression (); + SKIP_WHITESPACE (); + } + + while (ISALPHA (*input_line_pointer)) + { + char *p, c; + offsetT value; + + p = input_line_pointer; + c = get_symbol_end (); + + if (strcmp (p, "basic_block") == 0) + { + current.flags |= DWARF2_FLAG_BASIC_BLOCK; + *input_line_pointer = c; + } + else if (strcmp (p, "prologue_end") == 0) + { + current.flags |= DWARF2_FLAG_PROLOGUE_END; + *input_line_pointer = c; + } + else if (strcmp (p, "epilogue_begin") == 0) + { + current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN; + *input_line_pointer = c; + } + else if (strcmp (p, "is_stmt") == 0) + { + *input_line_pointer = c; + value = get_absolute_expression (); + if (value == 0) + current.flags &= ~DWARF2_FLAG_IS_STMT; + else if (value == 1) + current.flags |= DWARF2_FLAG_IS_STMT; + else + { + as_bad (_("is_stmt value not 0 or 1")); + return; + } + } + else if (strcmp (p, "isa") == 0) + { + *input_line_pointer = c; + value = get_absolute_expression (); + if (value >= 0) + current.isa = value; + else + { + as_bad (_("isa number less than zero")); + return; + } + } + else + { + as_bad (_("unknown .loc sub-directive `%s'"), p); + *input_line_pointer = c; + return; + } + + SKIP_WHITESPACE (); + } + + demand_empty_rest_of_line (); + loc_directive_seen = TRUE; +} + +void +dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED) +{ + offsetT value = get_absolute_expression (); + + if (value != 0 && value != 1) + { + as_bad (_("expected 0 or 1")); + ignore_rest_of_line (); + } + else + { + dwarf2_loc_mark_labels = value != 0; + demand_empty_rest_of_line (); + } } static struct frag * @@ -619,12 +765,9 @@ get_frag_fix (fragS *frag) /* Set an absolute address (may result in a relocation entry). */ static void -out_set_addr (segT seg, fragS *frag, addressT ofs) +out_set_addr (symbolS *sym) { expressionS expr; - symbolS *sym; - - sym = symbol_temp_new (seg, ofs, frag); out_opcode (DW_LNS_extended_op); out_uleb128 (sizeof_address + 1); @@ -728,6 +871,10 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) int need_copy = 0; char *end = p + len; + /* Line number sequences cannot go backward in addresses. This means + we've incorrectly ordered the statements in the sequence. */ + assert ((offsetT) addr_delta >= 0); + /* Scale the address delta by the minimum instruction length. */ scale_addr_delta (&addr_delta); @@ -760,19 +907,19 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) *p++ = DW_LNS_advance_line; p += output_leb128 (p, line_delta, 1); - /* Prettier, I think, to use DW_LNS_copy instead of a - "line +0, addr +0" special opcode. */ - if (addr_delta == 0) - { - *p++ = DW_LNS_copy; - goto done; - } - line_delta = 0; tmp = 0 - DWARF2_LINE_BASE; need_copy = 1; } + /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0" + special opcode. */ + if (line_delta == 0 && addr_delta == 0) + { + *p++ = DW_LNS_copy; + goto done; + } + /* Bias the opcode by the special opcode base. */ tmp += DWARF2_LINE_OPCODE_BASE; @@ -823,17 +970,11 @@ out_inc_line_addr (int line_delta, addressT addr_delta) increments between fragments of the target segment. */ static void -relax_inc_line_addr (int line_delta, segT seg, - fragS *to_frag, addressT to_ofs, - fragS *from_frag, addressT from_ofs) +relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) { - symbolS *to_sym, *from_sym; expressionS expr; int max_chars; - to_sym = symbol_temp_new (seg, to_ofs, to_frag); - from_sym = symbol_temp_new (seg, from_ofs, from_frag); - expr.X_op = O_subtract; expr.X_add_symbol = to_sym; expr.X_op_symbol = from_sym; @@ -914,23 +1055,22 @@ process_entries (segT seg, struct line_entry *e) unsigned filenum = 1; unsigned line = 1; unsigned column = 0; - unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0; - fragS *frag = NULL; - fragS *last_frag; - addressT frag_ofs = 0; - addressT last_frag_ofs; + unsigned isa = 0; + unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; + fragS *last_frag = NULL, *frag; + addressT last_frag_ofs = 0, frag_ofs; + symbolS *last_lab = NULL, *lab; struct line_entry *next; - while (e) + do { - int changed = 0; + int line_delta; if (filenum != e->loc.filenum) { filenum = e->loc.filenum; out_opcode (DW_LNS_set_file); out_uleb128 (filenum); - changed = 1; } if (column != e->loc.column) @@ -938,64 +1078,70 @@ process_entries (segT seg, struct line_entry *e) column = e->loc.column; out_opcode (DW_LNS_set_column); out_uleb128 (column); - changed = 1; } - if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT) + if (isa != e->loc.isa) { - flags = e->loc.flags; - out_opcode (DW_LNS_negate_stmt); - changed = 1; + isa = e->loc.isa; + out_opcode (DW_LNS_set_isa); + out_uleb128 (isa); } - if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK) + if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT) { - out_opcode (DW_LNS_set_basic_block); - changed = 1; + flags = e->loc.flags; + out_opcode (DW_LNS_negate_stmt); } + if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK) + out_opcode (DW_LNS_set_basic_block); + + if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END) + out_opcode (DW_LNS_set_prologue_end); + + if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN) + out_opcode (DW_LNS_set_epilogue_begin); + /* Don't try to optimize away redundant entries; gdb wants two entries for a function where the code starts on the same line as the {, and there's no way to identify that case here. Trust gcc to optimize appropriately. */ - if (1 /* line != e->loc.line || changed */) - { - int line_delta = e->loc.line - line; - if (frag == NULL) - { - out_set_addr (seg, e->frag, e->frag_ofs); - out_inc_line_addr (line_delta, 0); - } - else if (frag == e->frag) - out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs); - else - relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs, - frag, frag_ofs); + line_delta = e->loc.line - line; + lab = e->label; + frag = symbol_get_frag (lab); + frag_ofs = S_GET_VALUE (lab); - frag = e->frag; - frag_ofs = e->frag_ofs; - line = e->loc.line; - } - else if (frag == NULL) + if (last_frag == NULL) { - out_set_addr (seg, e->frag, e->frag_ofs); - frag = e->frag; - frag_ofs = e->frag_ofs; + out_set_addr (lab); + out_inc_line_addr (line_delta, 0); } + else if (frag == last_frag) + out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); + else + relax_inc_line_addr (line_delta, lab, last_lab); + + line = e->loc.line; + last_lab = lab; + last_frag = frag; + last_frag_ofs = frag_ofs; next = e->next; free (e); e = next; } + while (e); /* Emit a DW_LNE_end_sequence for the end of the section. */ - last_frag = last_frag_for_seg (seg); - last_frag_ofs = get_frag_fix (last_frag); + frag = last_frag_for_seg (seg); + frag_ofs = get_frag_fix (frag); if (frag == last_frag) - out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs); + out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); else - relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs, - frag, frag_ofs); + { + lab = symbol_temp_new (seg, frag_ofs, frag); + relax_inc_line_addr (INT_MAX, lab, last_lab); + } } /* Emit the directory and file tables for .debug_line. */ @@ -1116,6 +1262,9 @@ out_debug_line (segT line_seg) out_byte (0); /* DW_LNS_set_basic_block */ out_byte (0); /* DW_LNS_const_add_pc */ out_byte (1); /* DW_LNS_fixed_advance_pc */ + out_byte (0); /* DW_LNS_set_prologue_end */ + out_byte (0); /* DW_LNS_set_epilogue_begin */ + out_byte (1); /* DW_LNS_set_isa */ out_file_list (); @@ -1349,21 +1498,28 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg) symbol_set_value_now (info_end); } +/* Finish the dwarf2 debug sections. We emit .debug.line if there + were any .file/.loc directives, or --gdwarf2 was given, or if the + file has a non-empty .debug_info section. If we emit .debug_line, + and the .debug_info section is empty, we also emit .debug_info, + .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if + there were any .file/.loc directives, or --gdwarf2 was given and + there were any located instructions emitted. */ + void dwarf2_finish (void) { segT line_seg; struct line_seg *s; + segT info_seg; + int emit_other_sections = 0; - /* We don't need to do anything unless: - - Some debug information was recorded via .file/.loc - - or, we are generating DWARF2 information ourself (--gdwarf2) - - or, there is a user-provided .debug_info section which could - reference the file table in the .debug_line section we generate - below. */ - if (all_segs == NULL - && debug_type != DEBUG_DWARF2 - && bfd_get_section_by_name (stdoutput, ".debug_info") == NULL) + info_seg = bfd_get_section_by_name (stdoutput, ".debug_info"); + emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg); + + if (!all_segs && emit_other_sections) + /* There is no line information and no non-empty .debug_info + section. */ return; /* Calculate the size of an address for the target machine. */ @@ -1371,7 +1527,7 @@ dwarf2_finish (void) /* Create and switch to the line number section. */ line_seg = subseg_new (".debug_line", 0); - bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY); + bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING); /* For each subsection, chain the debug entries together. */ for (s = all_segs; s; s = s->next) @@ -1388,21 +1544,26 @@ dwarf2_finish (void) out_debug_line (line_seg); - /* If this is assembler generated line info, we need .debug_info - and .debug_abbrev sections as well. */ - if (all_segs != NULL && debug_type == DEBUG_DWARF2) + /* If this is assembler generated line info, and there is no + debug_info already, we need .debug_info and .debug_abbrev + sections as well. */ + if (emit_other_sections) { segT abbrev_seg; - segT info_seg; segT aranges_seg; + assert (all_segs); + info_seg = subseg_new (".debug_info", 0); abbrev_seg = subseg_new (".debug_abbrev", 0); aranges_seg = subseg_new (".debug_aranges", 0); - bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY); - bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY); - bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY); + bfd_set_section_flags (stdoutput, info_seg, + SEC_READONLY | SEC_DEBUGGING); + bfd_set_section_flags (stdoutput, abbrev_seg, + SEC_READONLY | SEC_DEBUGGING); + bfd_set_section_flags (stdoutput, aranges_seg, + SEC_READONLY | SEC_DEBUGGING); record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); @@ -1411,54 +1572,3 @@ dwarf2_finish (void) out_debug_info (info_seg, abbrev_seg, line_seg); } } - -#else -void -dwarf2_finish () -{ -} - -int -dwarf2dbg_estimate_size_before_relax (frag) - fragS *frag ATTRIBUTE_UNUSED; -{ - as_fatal (_("dwarf2 is not supported for this object file format")); - return 0; -} - -int -dwarf2dbg_relax_frag (frag) - fragS *frag ATTRIBUTE_UNUSED; -{ - as_fatal (_("dwarf2 is not supported for this object file format")); - return 0; -} - -void -dwarf2dbg_convert_frag (frag) - fragS *frag ATTRIBUTE_UNUSED; -{ - as_fatal (_("dwarf2 is not supported for this object file format")); -} - -void -dwarf2_emit_insn (size) - int size ATTRIBUTE_UNUSED; -{ -} - -char * -dwarf2_directive_file (dummy) - int dummy ATTRIBUTE_UNUSED; -{ - s_app_file (0); - return NULL; -} - -void -dwarf2_directive_loc (dummy) - int dummy ATTRIBUTE_UNUSED; -{ - as_fatal (_("dwarf2 is not supported for this object file format")); -} -#endif /* BFD_ASSEMBLER */ |