X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fdwarf2dbg.c;h=76f5e84f53fa903547e08504fab5682a8fa3450c;hb=9e8da49c0182de1ca0d5feb14241daefc920c92b;hp=de56095981bb20929e1fc47e5ddae06d62eec8c7;hpb=fa8f86ff3b8e5b29e3b217abeaa33a747052c43e;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c index de56095981..76f5e84f53 100644 --- a/gas/dwarf2dbg.c +++ b/gas/dwarf2dbg.c @@ -1,5 +1,5 @@ /* dwarf2dbg.c - DWARF2 debug support - Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 + Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by David Mosberger-Tang @@ -89,6 +89,10 @@ #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0 #endif +#ifndef DWARF2_VERSION +#define DWARF2_VERSION 2 +#endif + #include "subsegs.h" #include "dwarf2.h" @@ -168,6 +172,10 @@ struct line_seg { /* Collects data for all line table entries during assembly. */ static struct line_seg *all_segs; +/* Hash used to quickly lookup a segment by name, avoiding the need to search + through the all_segs list. */ +static struct hash_control *all_segs_hash; +static struct line_seg **last_seg_ptr; struct file_entry { const char *filename; @@ -199,6 +207,10 @@ static struct dwarf2_line_info current = { 0 }; +/* Lines that are at the same location as CURRENT, and which are waiting + for a label. */ +static struct line_entry *pending_lines, **pending_lines_tail = &pending_lines; + /* The size of an address on the target. */ static unsigned int sizeof_address; @@ -212,12 +224,12 @@ static unsigned int get_filenum (const char *, unsigned int); static void generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size) { - expressionS expr; + expressionS exp; - expr.X_op = O_symbol; - expr.X_add_symbol = symbol; - expr.X_add_number = 0; - emit_expr (&expr, size); + exp.X_op = O_symbol; + exp.X_add_symbol = symbol; + exp.X_add_number = 0; + emit_expr (&exp, size); } #endif @@ -230,62 +242,89 @@ get_line_subseg (segT seg, subsegT subseg) static subsegT last_subseg; static struct line_subseg *last_line_subseg; - struct line_seg **ps, *s; - struct line_subseg **pss, *ss; + struct line_seg *s; + struct line_subseg **pss, *lss; if (seg == last_seg && subseg == last_subseg) return last_line_subseg; - 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 = NULL; - s->seg = seg; - s->head = NULL; - *ps = s; + s = (struct line_seg *) hash_find (all_segs_hash, seg->name); + if (s == NULL) + { + s = (struct line_seg *) xmalloc (sizeof (*s)); + s->next = NULL; + s->seg = seg; + s->head = NULL; + *last_seg_ptr = s; + last_seg_ptr = &s->next; + hash_insert (all_segs_hash, seg->name, s); + } + gas_assert (seg == s->seg); - found_seg: - for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next) + for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next) { - if (ss->subseg == subseg) + if (lss->subseg == subseg) goto found_subseg; - if (ss->subseg > subseg) + if (lss->subseg > subseg) break; } - ss = (struct line_subseg *) xmalloc (sizeof (*ss)); - ss->next = *pss; - ss->subseg = subseg; - ss->head = NULL; - ss->ptail = &ss->head; - *pss = ss; + lss = (struct line_subseg *) xmalloc (sizeof (*lss)); + lss->next = *pss; + lss->subseg = subseg; + lss->head = NULL; + lss->ptail = &lss->head; + *pss = lss; found_subseg: last_seg = seg; last_subseg = subseg; - last_line_subseg = ss; + last_line_subseg = lss; - return ss; + return lss; } -/* Record an entry for LOC occurring at LABEL. */ +/* Push LOC onto the pending lines list. */ static void -dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) +dwarf2_push_line (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->label = NULL; e->loc = *loc; - ss = get_line_subseg (now_seg, now_subseg); - *ss->ptail = e; - ss->ptail = &e->next; + *pending_lines_tail = e; + pending_lines_tail = &(*pending_lines_tail)->next; +} + +/* Emit all pending line information. LABEL is the label with which the + lines should be associated, or null if they should be associated with + the current position. */ + +static void +dwarf2_flush_pending_lines (symbolS *label) +{ + if (pending_lines) + { + struct line_subseg *lss; + struct line_entry *e; + + if (!label) + label = symbol_temp_new_now (); + + for (e = pending_lines; e; e = e->next) + e->label = label; + + lss = get_line_subseg (now_seg, now_subseg); + *lss->ptail = pending_lines; + lss->ptail = pending_lines_tail; + + pending_lines = NULL; + pending_lines_tail = &pending_lines; + } } /* Record an entry for LOC occurring at OFS within the current fragment. */ @@ -296,8 +335,6 @@ dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) 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; @@ -313,8 +350,8 @@ dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) line = loc->line; filenum = loc->filenum; - sym = symbol_temp_new (now_seg, ofs, frag_now); - dwarf2_gen_line_info_1 (sym, loc); + dwarf2_push_line (loc); + dwarf2_flush_pending_lines (symbol_temp_new (now_seg, ofs, frag_now)); } /* Returns the current source information. If .file directives have @@ -375,6 +412,11 @@ dwarf2_emit_insn (int size) void dwarf2_consume_line_info (void) { + /* If the consumer has stashed the current location away for later use, + assume that any earlier location information should be associated + with ".". */ + dwarf2_flush_pending_lines (NULL); + /* Unless we generate DWARF2 debugging information for each assembler line, we only emit one line symbol for one LOC. */ dwarf2_loc_directive_seen = FALSE; @@ -406,7 +448,8 @@ dwarf2_emit_label (symbolS *label) loc.flags |= DWARF2_FLAG_BASIC_BLOCK; - dwarf2_gen_line_info_1 (label, &loc); + dwarf2_push_line (&loc); + dwarf2_flush_pending_lines (label); dwarf2_consume_line_info (); } @@ -425,14 +468,14 @@ get_filenum (const char *filename, unsigned int num) if (num == 0 && last_used) { if (! files[last_used].dir - && strcmp (filename, files[last_used].filename) == 0) + && filename_cmp (filename, files[last_used].filename) == 0) return last_used; if (files[last_used].dir - && strncmp (filename, dirs[files[last_used].dir], - last_used_dir_len) == 0 + && filename_ncmp (filename, dirs[files[last_used].dir], + last_used_dir_len) == 0 && IS_DIR_SEPARATOR (filename [last_used_dir_len]) - && strcmp (filename + last_used_dir_len + 1, - files[last_used].filename) == 0) + && filename_cmp (filename + last_used_dir_len + 1, + files[last_used].filename) == 0) return last_used; } @@ -454,7 +497,7 @@ get_filenum (const char *filename, unsigned int num) --dir_len; #endif for (dir = 1; dir < dirs_in_use; ++dir) - if (strncmp (filename, dirs[dir], dir_len) == 0 + if (filename_ncmp (filename, dirs[dir], dir_len) == 0 && dirs[dir][dir_len] == '\0') break; @@ -467,7 +510,7 @@ get_filenum (const char *filename, unsigned int num) xrealloc (dirs, (dir + 32) * sizeof (const char *)); } - dirs[dir] = xmalloc (dir_len + 1); + dirs[dir] = (char *) xmalloc (dir_len + 1); memcpy (dirs[dir], filename, dir_len); dirs[dir][dir_len] = '\0'; dirs_in_use = dir + 1; @@ -479,7 +522,7 @@ get_filenum (const char *filename, unsigned int num) for (i = 1; i < files_in_use; ++i) if (files[i].dir == dir && files[i].filename - && strcmp (file, files[i].filename) == 0) + && filename_cmp (file, files[i].filename) == 0) { last_used = i; last_used_dir_len = dir_len; @@ -566,7 +609,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) /* If we see two .loc directives in a row, force the first one to be output now. */ if (dwarf2_loc_directive_seen) - dwarf2_emit_insn (0); + dwarf2_push_line (¤t); filenum = get_absolute_expression (); SKIP_WHITESPACE (); @@ -807,16 +850,16 @@ get_frag_fix (fragS *frag, segT seg) static void out_set_addr (symbolS *sym) { - expressionS expr; + expressionS exp; out_opcode (DW_LNS_extended_op); out_uleb128 (sizeof_address + 1); out_opcode (DW_LNE_set_address); - expr.X_op = O_symbol; - expr.X_add_symbol = sym; - expr.X_add_number = 0; - emit_expr (&expr, sizeof_address); + exp.X_op = O_symbol; + exp.X_add_symbol = sym; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); } #if DWARF2_LINE_MIN_INSN_LENGTH > 1 @@ -1046,7 +1089,7 @@ static void emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, char *p, int len) { - expressionS *exp; + expressionS *pexp; segT line_seg; char *end = p + len; @@ -1061,7 +1104,7 @@ emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, p += output_leb128 (p, line_delta, 1); } - exp = symbol_get_value_expression (frag->fr_symbol); + pexp = symbol_get_value_expression (frag->fr_symbol); line_seg = subseg_get (".debug_line", 0); /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can @@ -1072,26 +1115,26 @@ emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, if (addr_delta > 50000) { symbolS *to_sym; - expressionS expr; + expressionS exp; - gas_assert (exp->X_op = O_subtract); - to_sym = exp->X_add_symbol; + gas_assert (pexp->X_op == O_subtract); + to_sym = pexp->X_add_symbol; *p++ = DW_LNS_extended_op; p += output_leb128 (p, sizeof_address + 1, 0); *p++ = DW_LNE_set_address; - expr.X_op = O_symbol; - expr.X_add_symbol = to_sym; - expr.X_add_number = 0; + exp.X_op = O_symbol; + exp.X_add_symbol = to_sym; + exp.X_add_number = 0; subseg_change (line_seg, 0); - emit_expr_fix (&expr, sizeof_address, frag, p); + emit_expr_fix (&exp, sizeof_address, frag, p); p += sizeof_address; } else { *p++ = DW_LNS_fixed_advance_pc; subseg_change (line_seg, 0); - emit_expr_fix (exp, 2, frag, p); + emit_expr_fix (pexp, 2, frag, p); p += 2; } @@ -1113,13 +1156,13 @@ emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, static void relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) { - expressionS expr; + expressionS exp; int max_chars; - expr.X_op = O_subtract; - expr.X_add_symbol = to_sym; - expr.X_op_symbol = from_sym; - expr.X_add_number = 0; + exp.X_op = O_subtract; + exp.X_add_symbol = to_sym; + exp.X_op_symbol = from_sym; + exp.X_add_number = 0; /* The maximum size of the frag is the line delta with a maximum sized address delta. */ @@ -1130,7 +1173,7 @@ relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH); frag_var (rs_dwarf2dbg, max_chars, max_chars, 1, - make_expr_symbol (&expr), line_delta, NULL); + make_expr_symbol (&exp), line_delta, NULL); } /* The function estimates the size of a rs_dwarf2dbg variant frag @@ -1362,7 +1405,7 @@ out_file_list (void) to the end of the section. */ static int -out_header (asection *sec, expressionS *expr) +out_header (asection *sec, expressionS *exp) { symbolS *start_sym; symbolS *end_sym; @@ -1372,26 +1415,26 @@ out_header (asection *sec, expressionS *expr) end_sym = symbol_temp_make (); /* Total length of the information. */ - expr->X_op = O_subtract; - expr->X_add_symbol = end_sym; - expr->X_op_symbol = start_sym; + exp->X_op = O_subtract; + exp->X_add_symbol = end_sym; + exp->X_op_symbol = start_sym; switch (DWARF2_FORMAT (sec)) { case dwarf2_format_32bit: - expr->X_add_number = -4; - emit_expr (expr, 4); + exp->X_add_number = -4; + emit_expr (exp, 4); return 4; case dwarf2_format_64bit: - expr->X_add_number = -12; + exp->X_add_number = -12; out_four (-1); - emit_expr (expr, 8); + emit_expr (exp, 8); return 8; case dwarf2_format_64bit_irix: - expr->X_add_number = -8; - emit_expr (expr, 8); + exp->X_add_number = -8; + emit_expr (exp, 8); return 8; } @@ -1404,23 +1447,23 @@ out_header (asection *sec, expressionS *expr) static void out_debug_line (segT line_seg) { - expressionS expr; + expressionS exp; symbolS *prologue_end; symbolS *line_end; struct line_seg *s; int sizeof_offset; - sizeof_offset = out_header (line_seg, &expr); - line_end = expr.X_add_symbol; + sizeof_offset = out_header (line_seg, &exp); + line_end = exp.X_add_symbol; /* Version. */ - out_two (2); + out_two (DWARF2_VERSION); /* Length of the prologue following this length. */ prologue_end = symbol_temp_make (); - expr.X_add_symbol = prologue_end; - expr.X_add_number = - (4 + 2 + 4); - emit_expr (&expr, sizeof_offset); + exp.X_add_symbol = prologue_end; + exp.X_add_number = - (4 + 2 + 4); + emit_expr (&exp, sizeof_offset); /* Parameters of the state machine. */ out_byte (DWARF2_LINE_MIN_INSN_LENGTH); @@ -1449,7 +1492,11 @@ out_debug_line (segT line_seg) /* For each section, emit a statement program. */ for (s = all_segs; s; s = s->next) - process_entries (s->seg, s->head->head); + if (SEG_NORMAL (s->seg)) + process_entries (s->seg, s->head->head); + else + as_warn ("dwarf line number information for %s ignored", + segment_name (s->seg)); symbol_set_value_now (line_end); } @@ -1459,7 +1506,7 @@ out_debug_ranges (segT ranges_seg) { unsigned int addr_size = sizeof_address; struct line_seg *s; - expressionS expr; + expressionS exp; unsigned int i; subseg_set (ranges_seg, 0); @@ -1484,15 +1531,15 @@ out_debug_ranges (segT ranges_seg) end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); s->text_end = end; - expr.X_op = O_symbol; - expr.X_add_symbol = beg; - expr.X_add_number = 0; - emit_expr (&expr, addr_size); + exp.X_op = O_symbol; + exp.X_add_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); - expr.X_op = O_symbol; - expr.X_add_symbol = end; - expr.X_add_number = 0; - emit_expr (&expr, addr_size); + exp.X_op = O_symbol; + exp.X_add_symbol = end; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); } /* End of Range Entry. */ @@ -1509,16 +1556,16 @@ out_debug_aranges (segT aranges_seg, segT info_seg) { unsigned int addr_size = sizeof_address; struct line_seg *s; - expressionS expr; + expressionS exp; symbolS *aranges_end; char *p; int sizeof_offset; - sizeof_offset = out_header (aranges_seg, &expr); - aranges_end = expr.X_add_symbol; + sizeof_offset = out_header (aranges_seg, &exp); + aranges_end = exp.X_add_symbol; /* Version. */ - out_two (2); + out_two (DWARF2_VERSION); /* Offset to .debug_info. */ TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset); @@ -1545,16 +1592,16 @@ out_debug_aranges (segT aranges_seg, segT info_seg) end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); s->text_end = end; - expr.X_op = O_symbol; - expr.X_add_symbol = beg; - expr.X_add_number = 0; - emit_expr (&expr, addr_size); + exp.X_op = O_symbol; + exp.X_add_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); - expr.X_op = O_subtract; - expr.X_add_symbol = end; - expr.X_op_symbol = beg; - expr.X_add_number = 0; - emit_expr (&expr, addr_size); + exp.X_op = O_subtract; + exp.X_add_symbol = end; + exp.X_op_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); } p = frag_more (2 * addr_size); @@ -1611,17 +1658,17 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) char producer[128]; const char *comp_dir; const char *dirname; - expressionS expr; + expressionS exp; symbolS *info_end; char *p; int len; int sizeof_offset; - sizeof_offset = out_header (info_seg, &expr); - info_end = expr.X_add_symbol; + sizeof_offset = out_header (info_seg, &exp); + info_end = exp.X_add_symbol; /* DWARF version. */ - out_two (2); + out_two (DWARF2_VERSION); /* .debug_abbrev offset */ TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset); @@ -1641,16 +1688,16 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) if (all_segs->next == NULL) { /* DW_AT_low_pc */ - expr.X_op = O_symbol; - expr.X_add_symbol = all_segs->text_start; - expr.X_add_number = 0; - emit_expr (&expr, sizeof_address); + exp.X_op = O_symbol; + exp.X_add_symbol = all_segs->text_start; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); /* DW_AT_high_pc */ - expr.X_op = O_symbol; - expr.X_add_symbol = all_segs->text_end; - expr.X_add_number = 0; - emit_expr (&expr, sizeof_address); + exp.X_op = O_symbol; + exp.X_add_symbol = all_segs->text_end; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); } else { @@ -1702,13 +1749,22 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) symbol_set_value_now (info_end); } +void +dwarf2_init (void) +{ + all_segs_hash = hash_new (); + last_seg_ptr = &all_segs; +} + + /* 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. */ + file has a non-empty .debug_info section and an empty .debug_line + 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) @@ -1717,13 +1773,24 @@ dwarf2_finish (void) struct line_seg *s; segT info_seg; int emit_other_sections = 0; + int empty_debug_line = 0; 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. */ + line_seg = bfd_get_section_by_name (stdoutput, ".debug_line"); + empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg); + + /* We can't construct a new debug_line section if we already have one. + Give an error. */ + if (all_segs && !empty_debug_line) + as_fatal ("duplicate .debug_line sections"); + + if ((!all_segs && emit_other_sections) + || (!emit_other_sections && !empty_debug_line)) + /* If there is no line information and no non-empty .debug_info + section, or if there is both a non-empty .debug_info and a non-empty + .debug_line, then we do nothing. */ return; /* Calculate the size of an address for the target machine. */ @@ -1736,13 +1803,13 @@ dwarf2_finish (void) /* For each subsection, chain the debug entries together. */ for (s = all_segs; s; s = s->next) { - struct line_subseg *ss = s->head; - struct line_entry **ptail = ss->ptail; + struct line_subseg *lss = s->head; + struct line_entry **ptail = lss->ptail; - while ((ss = ss->next) != NULL) + while ((lss = lss->next) != NULL) { - *ptail = ss->head; - ptail = ss->ptail; + *ptail = lss->head; + ptail = lss->ptail; } }