X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fdwarf2dbg.c;h=61268a8cd1e3f43982b3ff212f47ec396713d388;hb=2e492780e8c4736b456448369ccdf4460f6e2675;hp=65a0a266963cf72035deeb6eb63c35f466725bf6;hpb=56487c5507bb8501767f5f63963107dfef1308fa;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c index 65a0a26696..61268a8cd1 100644 --- a/gas/dwarf2dbg.c +++ b/gas/dwarf2dbg.c @@ -1,13 +1,12 @@ /* dwarf2dbg.c - DWARF2 debug support - Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. + Copyright (C) 1999-2016 Free Software Foundation, Inc. Contributed by David Mosberger-Tang This file is part of GAS, the GNU Assembler. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, @@ -25,10 +24,10 @@ .file FILENO "file.c" .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \ - [epilogue_begin] [is_stmt VALUE] [isa VALUE] + [epilogue_begin] [is_stmt VALUE] [isa VALUE] \ + [discriminator VALUE] */ -#include "ansidecl.h" #include "as.h" #include "safe-ctype.h" @@ -58,8 +57,8 @@ do \ { \ if (offset > 1 \ - && string[0] != 0 \ - && string[1] == ':') \ + && string[0] != 0 \ + && string[1] == ':') \ string [offset] = '\\'; \ else \ string [offset] = '/'; \ @@ -70,16 +69,42 @@ #endif #ifndef DWARF2_FORMAT -# define DWARF2_FORMAT() dwarf2_format_32bit +# define DWARF2_FORMAT(SEC) dwarf2_format_32bit #endif #ifndef DWARF2_ADDR_SIZE # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) #endif +#ifndef DWARF2_FILE_NAME +#define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME +#endif + +#ifndef DWARF2_FILE_TIME_NAME +#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0 +#endif + +#ifndef DWARF2_FILE_SIZE_NAME +#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0 +#endif + +#ifndef DWARF2_VERSION +#define DWARF2_VERSION 2 +#endif + +/* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */ +#ifndef DWARF2_ARANGES_VERSION +#define DWARF2_ARANGES_VERSION 2 +#endif + +/* This implementation output version 2 .debug_line information. */ +#ifndef DWARF2_LINE_VERSION +#define DWARF2_LINE_VERSION 2 +#endif + #include "subsegs.h" -#include "elf/dwarf2.h" +#include "dwarf2.h" /* Since we can't generate the prolog until the body is complete, we use three different subsegments for .debug_line: one holding the @@ -89,6 +114,13 @@ #define DL_FILES 1 #define DL_BODY 2 +/* If linker relaxation might change offsets in the code, the DWARF special + opcodes and variable-length operands cannot be used. If this macro is + nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */ +#ifndef DWARF2_USE_FIXED_ADVANCE_PC +# define DWARF2_USE_FIXED_ADVANCE_PC linkrelax +#endif + /* 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 @@ -126,6 +158,10 @@ /* The maximum address skip amount that can be encoded with a special op. */ #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255) +#ifndef TC_PARSE_CONS_RETURN_NONE +#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE +#endif + struct line_entry { struct line_entry *next; symbolS *label; @@ -137,6 +173,7 @@ struct line_subseg { subsegT subseg; struct line_entry *head; struct line_entry **ptail; + struct line_entry **pmove_tail; }; struct line_seg { @@ -149,6 +186,7 @@ struct line_seg { /* Collects data for all line table entries during assembly. */ static struct line_seg *all_segs; +static struct line_seg **last_seg_ptr; struct file_entry { const char *filename; @@ -167,7 +205,7 @@ static unsigned int dirs_allocated; /* TRUE when we've seen a .loc directive recently. Used to avoid doing work when there's nothing to do. */ -static bfd_boolean loc_directive_seen; +bfd_boolean dwarf2_loc_directive_seen; /* TRUE when we're supposed to set the basic block mark whenever a label is seen. */ @@ -176,100 +214,73 @@ bfd_boolean dwarf2_loc_mark_labels; /* Current location as indicated by the most recent .loc directive. */ static struct dwarf2_line_info current = { 1, 1, 0, 0, - DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0 + DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0, + 0 }; /* The size of an address on the target. */ static unsigned int sizeof_address; -static struct line_subseg *get_line_subseg (segT, subsegT); static unsigned int get_filenum (const char *, unsigned int); -static struct frag *first_frag_for_seg (segT); -static struct frag *last_frag_for_seg (segT); -static void out_byte (int); -static void out_opcode (int); -static void out_two (int); -static void out_four (int); -static void out_abbrev (int, int); -static void out_uleb128 (addressT); -static offsetT get_frag_fix (fragS *, segT); -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, symbolS *, symbolS *); -static void process_entries (segT, struct line_entry *); -static void out_file_list (void); -static void out_debug_line (segT); -static void out_debug_aranges (segT, segT); -static void out_debug_abbrev (segT); -static void out_debug_info (segT, segT, segT); - + #ifndef TC_DWARF2_EMIT_OFFSET -# define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset -static void generic_dwarf2_emit_offset (symbolS *, unsigned int); +#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset /* Create an offset to .dwarf2_*. */ 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 -/* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */ +/* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */ static struct line_subseg * -get_line_subseg (segT seg, subsegT subseg) +get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p) { - static segT last_seg; - static subsegT last_subseg; - static struct line_subseg *last_line_subseg; - - struct line_seg **ps, *s; - struct line_subseg **pss, *ss; - - if (seg == last_seg && subseg == last_subseg) - return last_line_subseg; + struct line_seg *s = seg_info (seg)->dwarf2_line_seg; + struct line_subseg **pss, *lss; - 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; + if (s == NULL) + { + if (!create_p) + return NULL; + + s = XNEW (struct line_seg); + s->next = NULL; + s->seg = seg; + s->head = NULL; + *last_seg_ptr = s; + last_seg_ptr = &s->next; + seg_info (seg)->dwarf2_line_seg = 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 = XNEW (struct line_subseg); + lss->next = *pss; + lss->subseg = subseg; + lss->head = NULL; + lss->ptail = &lss->head; + lss->pmove_tail = &lss->head; + *pss = lss; found_subseg: - last_seg = seg; - last_subseg = subseg; - last_line_subseg = ss; - - return ss; + return lss; } /* Record an entry for LOC occurring at LABEL. */ @@ -277,17 +288,17 @@ get_line_subseg (segT seg, subsegT subseg) static void dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) { - struct line_subseg *ss; + struct line_subseg *lss; struct line_entry *e; - e = (struct line_entry *) xmalloc (sizeof (*e)); + e = XNEW (struct line_entry); e->next = NULL; e->label = label; e->loc = *loc; - ss = get_line_subseg (now_seg, now_subseg); - *ss->ptail = e; - ss->ptail = &e->next; + lss = get_line_subseg (now_seg, now_subseg, TRUE); + *lss->ptail = e; + lss->ptail = &e->next; } /* Record an entry for LOC occurring at OFS within the current fragment. */ @@ -315,7 +326,17 @@ 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); + if (linkrelax) + { + char name[120]; + + /* Use a non-fake name for the line number location, + so that it can be referred to by relocations. */ + sprintf (name, ".Loc.%u.%u", line, filenum); + sym = symbol_new (name, now_seg, ofs, frag_now); + } + else + sym = symbol_temp_new (now_seg, ofs, frag_now); dwarf2_gen_line_info_1 (sym, loc); } @@ -329,18 +350,18 @@ dwarf2_where (struct dwarf2_line_info *line) { if (debug_type == DEBUG_DWARF2) { - char *filename; - as_where (&filename, &line->line); + const char *filename = as_where (&line->line); line->filenum = get_filenum (filename, 0); line->column = 0; line->flags = DWARF2_FLAG_IS_STMT; line->isa = current.isa; + line->discriminator = current.discriminator; } else *line = current; } -/* A hook to allow the target backend to inform the line number state +/* A hook to allow the target backend to inform the line number state machine of isa changes when assembler debug info is enabled. */ void @@ -359,30 +380,58 @@ dwarf2_emit_insn (int size) { struct dwarf2_line_info loc; - if (loc_directive_seen) - { - /* Use the last location established by a .loc directive, not - the value returned by dwarf2_where(). That calls as_where() - which will return either the logical input file name (foo.c) - or the physical input file name (foo.s) and not the file name - specified in the most recent .loc directive (eg foo.h). */ - loc = current; - - /* Unless we generate DWARF2 debugging information for each - assembler line, we only emit one line symbol for one LOC. */ - if (debug_type != DEBUG_DWARF2) - loc_directive_seen = FALSE; - } - else if (debug_type != DEBUG_DWARF2) + if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2) return; - else - dwarf2_where (&loc); + + dwarf2_where (&loc); dwarf2_gen_line_info (frag_now_fix () - size, &loc); + dwarf2_consume_line_info (); +} + +/* Move all previously-emitted line entries for the current position by + DELTA bytes. This function cannot be used to move the same entries + twice. */ + +void +dwarf2_move_insn (int delta) +{ + struct line_subseg *lss; + struct line_entry *e; + valueT now; + + if (delta == 0) + return; + + lss = get_line_subseg (now_seg, now_subseg, FALSE); + if (!lss) + return; + + now = frag_now_fix (); + while ((e = *lss->pmove_tail)) + { + if (S_GET_VALUE (e->label) == now) + S_SET_VALUE (e->label, now + delta); + lss->pmove_tail = &e->next; + } +} + +/* Called after the current line information has been either used with + dwarf2_gen_line_info or saved with a machine instruction for later use. + This resets the state of the line number information to reflect that + it has been used. */ + +void +dwarf2_consume_line_info (void) +{ + /* Unless we generate DWARF2 debugging information for each + assembler line, we only emit one line symbol for one LOC. */ + dwarf2_loc_directive_seen = FALSE; current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK | DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_EPILOGUE_BEGIN); + current.discriminator = 0; } /* Called for each (preferably code) label. If dwarf2_loc_mark_labels @@ -399,22 +448,15 @@ dwarf2_emit_label (symbolS *label) 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; - } + if (files_in_use == 0 && debug_type != DEBUG_DWARF2) + return; - loc.flags |= DWARF2_FLAG_BASIC_BLOCK; + dwarf2_where (&loc); - current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK - | DWARF2_FLAG_PROLOGUE_END - | DWARF2_FLAG_EPILOGUE_BEGIN); + loc.flags |= DWARF2_FLAG_BASIC_BLOCK; dwarf2_gen_line_info_1 (label, &loc); + dwarf2_consume_line_info (); } /* Get a .debug_line file number for FILENAME. If NUM is nonzero, @@ -432,14 +474,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; } @@ -457,9 +499,11 @@ get_filenum (const char *filename, unsigned int num) dir = 0; if (dir_len) { +#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR --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; @@ -468,13 +512,10 @@ get_filenum (const char *filename, unsigned int num) if (dir >= dirs_allocated) { dirs_allocated = dir + 32; - dirs = (char **) - xrealloc (dirs, (dir + 32) * sizeof (const char *)); + dirs = XRESIZEVEC (char *, dirs, dirs_allocated); } - dirs[dir] = xmalloc (dir_len + 1); - memcpy (dirs[dir], filename, dir_len); - dirs[dir][dir_len] = '\0'; + dirs[dir] = xmemdup0 (filename, dir_len); dirs_in_use = dir + 1; } } @@ -484,7 +525,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; @@ -499,8 +540,7 @@ get_filenum (const char *filename, unsigned int num) unsigned int old = files_allocated; files_allocated = i + 32; - files = (struct file_entry *) - xrealloc (files, (i + 32) * sizeof (struct file_entry)); + files = XRESIZEVEC (struct file_entry, files, files_allocated); memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry)); } @@ -548,6 +588,10 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) return NULL; } + /* A .file directive implies compiler generated debug information is + being supplied. Turn off gas generated debug info. */ + debug_type = DEBUG_NONE; + if (num < (int) files_in_use && files[num].filename != 0) { as_bad (_("file number %ld already allocated"), (long) num); @@ -564,6 +608,11 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { offsetT filenum, line; + /* 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); + filenum = get_absolute_expression (); SKIP_WHITESPACE (); line = get_absolute_expression (); @@ -581,6 +630,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) current.filenum = filenum; current.line = line; + current.discriminator = 0; #ifndef NO_LISTING if (listing) @@ -589,13 +639,14 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { size_t dir_len = strlen (dirs[files[filenum].dir]); size_t file_len = strlen (files[filenum].filename); - char *cp = (char *) alloca (dir_len + 1 + file_len + 1); + char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1); memcpy (cp, dirs[files[filenum].dir], dir_len); INSERT_DIR_SEPARATOR (cp, dir_len); memcpy (cp + dir_len + 1, files[filenum].filename, file_len); cp[dir_len + file_len + 1] = '\0'; listing_source_file (cp); + free (cp); } else listing_source_file (files[filenum].filename); @@ -615,8 +666,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) char *p, c; offsetT value; - p = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (& p); if (strcmp (p, "basic_block") == 0) { @@ -635,7 +685,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) } else if (strcmp (p, "is_stmt") == 0) { - *input_line_pointer = c; + (void) restore_line_pointer (c); value = get_absolute_expression (); if (value == 0) current.flags &= ~DWARF2_FLAG_IS_STMT; @@ -649,7 +699,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) } else if (strcmp (p, "isa") == 0) { - *input_line_pointer = c; + (void) restore_line_pointer (c); value = get_absolute_expression (); if (value >= 0) current.isa = value; @@ -659,18 +709,31 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) return; } } + else if (strcmp (p, "discriminator") == 0) + { + (void) restore_line_pointer (c); + value = get_absolute_expression (); + if (value >= 0) + current.discriminator = value; + else + { + as_bad (_("discriminator less than zero")); + return; + } + } else { as_bad (_("unknown .loc sub-directive `%s'"), p); - *input_line_pointer = c; + (void) restore_line_pointer (c); return; } - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); } demand_empty_rest_of_line (); - loc_directive_seen = TRUE; + dwarf2_loc_directive_seen = TRUE; + debug_type = DEBUG_NONE; } void @@ -747,6 +810,14 @@ out_uleb128 (addressT value) output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); } +/* Emit a signed "little-endian base 128" number. */ + +static void +out_leb128 (addressT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); +} + /* Emit a tuple for .debug_abbrev. */ static inline void @@ -781,36 +852,34 @@ 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 static void scale_addr_delta (addressT *); static void scale_addr_delta (addressT *addr_delta) { static int printed_this = 0; - if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0) + if (DWARF2_LINE_MIN_INSN_LENGTH > 1) { - if (!printed_this) - as_bad("unaligned opcodes detected in executable segment"); - printed_this = 1; + if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this) + { + as_bad("unaligned opcodes detected in executable segment"); + printed_this = 1; + } + *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH; } - *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH; } -#else -#define scale_addr_delta(A) -#endif /* Encode a pair of line and address skips as efficiently as possible. Note that the line skip is signed, whereas the address skip is unsigned. @@ -887,7 +956,7 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int 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); + gas_assert ((offsetT) addr_delta >= 0); /* Scale the address delta by the minimum instruction length. */ scale_addr_delta (&addr_delta); @@ -968,7 +1037,7 @@ emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) *p++ = tmp; done: - assert (p == end); + gas_assert (p == end); } /* Handy routine to combine calls to the above two routines. */ @@ -980,26 +1049,131 @@ out_inc_line_addr (int line_delta, addressT addr_delta) emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len); } +/* Write out an alternative form of line and address skips using + DW_LNS_fixed_advance_pc opcodes. This uses more space than the default + line and address information, but it is required if linker relaxation + could change the code offsets. The following two routines *must* be + kept in sync. */ +#define ADDR_DELTA_LIMIT 50000 + +static int +size_fixed_inc_line_addr (int line_delta, addressT addr_delta) +{ + int len = 0; + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ + if (line_delta != INT_MAX) + len = 1 + sizeof_leb128 (line_delta, 1); + + if (addr_delta > ADDR_DELTA_LIMIT) + { + /* DW_LNS_extended_op */ + len += 1 + sizeof_leb128 (sizeof_address + 1, 0); + /* DW_LNE_set_address */ + len += 1 + sizeof_address; + } + else + /* DW_LNS_fixed_advance_pc */ + len += 3; + + if (line_delta == INT_MAX) + /* DW_LNS_extended_op + DW_LNE_end_sequence */ + len += 3; + else + /* DW_LNS_copy */ + len += 1; + + return len; +} + +static void +emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, + char *p, int len) +{ + expressionS *pexp; + char *end = p + len; + + /* Line number sequences cannot go backward in addresses. This means + we've incorrectly ordered the statements in the sequence. */ + gas_assert ((offsetT) addr_delta >= 0); + + /* Verify that we have kept in sync with size_fixed_inc_line_addr. */ + gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta)); + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ + if (line_delta != INT_MAX) + { + *p++ = DW_LNS_advance_line; + p += output_leb128 (p, line_delta, 1); + } + + pexp = symbol_get_value_expression (frag->fr_symbol); + + /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can + advance the address by at most 64K. Linker relaxation (without + which this function would not be used) could change the operand by + an unknown amount. If the address increment is getting close to + the limit, just reset the address. */ + if (addr_delta > ADDR_DELTA_LIMIT) + { + symbolS *to_sym; + expressionS exp; + + 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; + exp.X_op = O_symbol; + exp.X_add_symbol = to_sym; + exp.X_add_number = 0; + emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE); + p += sizeof_address; + } + else + { + *p++ = DW_LNS_fixed_advance_pc; + emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE); + p += 2; + } + + if (line_delta == INT_MAX) + { + *p++ = DW_LNS_extended_op; + *p++ = 1; + *p++ = DW_LNE_end_sequence; + } + else + *p++ = DW_LNS_copy; + + gas_assert (p == end); +} + /* Generate a variant frag that we can use to relax address/line increments between fragments of the target segment. */ 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. */ - max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH); + if (DWARF2_USE_FIXED_ADVANCE_PC) + max_chars = size_fixed_inc_line_addr (line_delta, + -DWARF2_LINE_MIN_INSN_LENGTH); + else + 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 @@ -1013,7 +1187,10 @@ dwarf2dbg_estimate_size_before_relax (fragS *frag) int size; addr_delta = resolve_symbol_value (frag->fr_symbol); - size = size_inc_line_addr (frag->fr_offset, addr_delta); + if (DWARF2_USE_FIXED_ADVANCE_PC) + size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta); + else + size = size_inc_line_addr (frag->fr_offset, addr_delta); frag->fr_subtype = size; @@ -1044,15 +1221,37 @@ dwarf2dbg_convert_frag (fragS *frag) { offsetT addr_diff; - addr_diff = resolve_symbol_value (frag->fr_symbol); + if (DWARF2_USE_FIXED_ADVANCE_PC) + { + /* If linker relaxation is enabled then the distance bewteen the two + symbols in the frag->fr_symbol expression might change. Hence we + cannot rely upon the value computed by resolve_symbol_value. + Instead we leave the expression unfinalized and allow + emit_fixed_inc_line_addr to create a fixup (which later becomes a + relocation) that will allow the linker to correctly compute the + actual address difference. We have to use a fixed line advance for + this as we cannot (easily) relocate leb128 encoded values. */ + int saved_finalize_syms = finalize_syms; + + finalize_syms = 0; + addr_diff = resolve_symbol_value (frag->fr_symbol); + finalize_syms = saved_finalize_syms; + } + else + addr_diff = resolve_symbol_value (frag->fr_symbol); /* fr_var carries the max_chars that we created the fragment with. fr_subtype carries the current expected length. We must, of course, have allocated enough memory earlier. */ - assert (frag->fr_var >= (int) frag->fr_subtype); + gas_assert (frag->fr_var >= (int) frag->fr_subtype); - emit_inc_line_addr (frag->fr_offset, addr_diff, - frag->fr_literal + frag->fr_fix, frag->fr_subtype); + if (DWARF2_USE_FIXED_ADVANCE_PC) + emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag, + frag->fr_literal + frag->fr_fix, + frag->fr_subtype); + else + emit_inc_line_addr (frag->fr_offset, addr_diff, + frag->fr_literal + frag->fr_fix, frag->fr_subtype); frag->fr_fix += frag->fr_subtype; frag->fr_type = rs_fill; @@ -1076,6 +1275,36 @@ process_entries (segT seg, struct line_entry *e) symbolS *last_lab = NULL, *lab; struct line_entry *next; + if (flag_dwarf_sections) + { + char * name; + const char * sec_name; + + /* Switch to the relevent sub-section before we start to emit + the line number table. + + FIXME: These sub-sections do not have a normal Line Number + Program Header, thus strictly speaking they are not valid + DWARF sections. Unfortunately the DWARF standard assumes + a one-to-one relationship between compilation units and + line number tables. Thus we have to have a .debug_line + section, as well as our sub-sections, and we have to ensure + that all of the sub-sections are merged into a proper + .debug_line section before a debugger sees them. */ + + sec_name = bfd_get_section_name (stdoutput, seg); + if (strcmp (sec_name, ".text") != 0) + { + name = concat (".debug_line", sec_name, (char *) NULL); + subseg_set (subseg_get (name, FALSE), 0); + } + else + /* Don't create a .debug_line.text section - + that is redundant. Instead just switch back to the + normal .debug_line section. */ + subseg_set (subseg_get (".debug_line", FALSE), 0); + } + do { int line_delta; @@ -1094,6 +1323,14 @@ process_entries (segT seg, struct line_entry *e) out_uleb128 (column); } + if (e->loc.discriminator != 0) + { + out_opcode (DW_LNS_extended_op); + out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0)); + out_opcode (DW_LNE_set_discriminator); + out_uleb128 (e->loc.discriminator); + } + if (isa != e->loc.isa) { isa = e->loc.isa; @@ -1130,7 +1367,7 @@ process_entries (segT seg, struct line_entry *e) out_set_addr (lab); out_inc_line_addr (line_delta, 0); } - else if (frag == last_frag) + else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); else relax_inc_line_addr (line_delta, lab, last_lab); @@ -1149,7 +1386,7 @@ process_entries (segT seg, struct line_entry *e) /* Emit a DW_LNE_end_sequence for the end of the section. */ frag = last_frag_for_seg (seg); frag_ofs = get_frag_fix (frag, seg); - if (frag == last_frag) + if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); else { @@ -1164,21 +1401,25 @@ static void out_file_list (void) { size_t size; + const char *dir; char *cp; unsigned int i; /* Emit directory list. */ for (i = 1; i < dirs_in_use; ++i) { - size = strlen (dirs[i]) + 1; + dir = remap_debug_filename (dirs[i]); + size = strlen (dir) + 1; cp = frag_more (size); - memcpy (cp, dirs[i], size); + memcpy (cp, dir, size); } /* Terminate it. */ out_byte ('\0'); for (i = 1; i < files_in_use; ++i) { + const char *fullfilename; + if (files[i].filename == NULL) { as_bad (_("unassigned file number %ld"), (long) i); @@ -1187,77 +1428,107 @@ out_file_list (void) continue; } - size = strlen (files[i].filename) + 1; + fullfilename = DWARF2_FILE_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : ""); + size = strlen (fullfilename) + 1; cp = frag_more (size); - memcpy (cp, files[i].filename, size); + memcpy (cp, fullfilename, size); out_uleb128 (files[i].dir); /* directory number */ - out_uleb128 (0); /* last modification timestamp */ - out_uleb128 (0); /* filesize */ + /* Output the last modification timestamp. */ + out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : "")); + /* Output the filesize. */ + out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : "")); } /* Terminate filename list. */ out_byte (0); } -/* Emit the collected .debug_line data. */ +/* Switch to SEC and output a header length field. Return the size of + offsets used in SEC. The caller must set EXPR->X_add_symbol value + to the end of the section. EXPR->X_add_number will be set to the + negative size of the header. */ -static void -out_debug_line (segT line_seg) +static int +out_header (asection *sec, expressionS *exp) { - expressionS expr; - symbolS *line_start; - symbolS *prologue_end; - symbolS *line_end; - struct line_seg *s; - enum dwarf2_format d2f; - int sizeof_offset; - - subseg_set (line_seg, 0); - - line_start = symbol_temp_new_now (); - prologue_end = symbol_temp_make (); - line_end = symbol_temp_make (); + symbolS *start_sym; + symbolS *end_sym; - /* Total length of the information for this compilation unit. */ - expr.X_op = O_subtract; - expr.X_add_symbol = line_end; - expr.X_op_symbol = line_start; + subseg_set (sec, 0); - d2f = DWARF2_FORMAT (); - if (d2f == dwarf2_format_32bit) - { - expr.X_add_number = -4; - emit_expr (&expr, 4); - sizeof_offset = 4; - } - else if (d2f == dwarf2_format_64bit) + if (flag_dwarf_sections) { - expr.X_add_number = -12; - out_four (-1); - emit_expr (&expr, 8); - sizeof_offset = 8; + /* If we are going to put the start and end symbols in different + sections, then we need real symbols, not just fake, local ones. */ + frag_now_fix (); + start_sym = symbol_make (".Ldebug_line_start"); + end_sym = symbol_make (".Ldebug_line_end"); + symbol_set_value_now (start_sym); } - else if (d2f == dwarf2_format_64bit_irix) + else { - expr.X_add_number = -8; - emit_expr (&expr, 8); - sizeof_offset = 8; + start_sym = symbol_temp_new_now (); + end_sym = symbol_temp_make (); } - else + + /* Total length of the information. */ + exp->X_op = O_subtract; + exp->X_add_symbol = end_sym; + exp->X_op_symbol = start_sym; + + switch (DWARF2_FORMAT (sec)) { - as_fatal (_("internal error: unknown dwarf2 format")); + case dwarf2_format_32bit: + exp->X_add_number = -4; + emit_expr (exp, 4); + return 4; + + case dwarf2_format_64bit: + exp->X_add_number = -12; + out_four (-1); + emit_expr (exp, 8); + return 8; + + case dwarf2_format_64bit_irix: + exp->X_add_number = -8; + emit_expr (exp, 8); + return 8; } + as_fatal (_("internal error: unknown dwarf2 format")); + return 0; +} + +/* Emit the collected .debug_line data. */ + +static void +out_debug_line (segT line_seg) +{ + expressionS exp; + symbolS *prologue_start, *prologue_end; + symbolS *line_end; + struct line_seg *s; + int sizeof_offset; + + sizeof_offset = out_header (line_seg, &exp); + line_end = exp.X_add_symbol; + /* Version. */ - out_two (2); + out_two (DWARF2_LINE_VERSION); /* Length of the prologue following this length. */ - expr.X_op = O_subtract; - expr.X_add_symbol = prologue_end; - expr.X_op_symbol = line_start; - expr.X_add_number = - (4 + 2 + 4); - emit_expr (&expr, sizeof_offset); + prologue_start = symbol_temp_make (); + prologue_end = symbol_temp_make (); + exp.X_op = O_subtract; + exp.X_add_symbol = prologue_end; + exp.X_op_symbol = prologue_start; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_offset); + symbol_set_value_now (prologue_start); /* Parameters of the state machine. */ out_byte (DWARF2_LINE_MIN_INSN_LENGTH); @@ -1286,55 +1557,109 @@ 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)); + + if (flag_dwarf_sections) + /* We have to switch to the special .debug_line_end section + before emitting the end-of-debug_line symbol. The linker + script arranges for this section to be placed after all the + (potentially garbage collected) .debug_line. sections. + This section contains the line_end symbol which is used to + compute the size of the linked .debug_line section, as seen + in the DWARF Line Number header. */ + subseg_set (subseg_get (".debug_line_end", FALSE), 0); symbol_set_value_now (line_end); } -/* Emit data for .debug_aranges. */ - static void -out_debug_aranges (segT aranges_seg, segT info_seg) +out_debug_ranges (segT ranges_seg) { unsigned int addr_size = sizeof_address; - addressT size, skip; struct line_seg *s; - expressionS expr; - char *p; + expressionS exp; + unsigned int i; - size = 4 + 2 + 4 + 1 + 1; + subseg_set (ranges_seg, 0); - skip = 2 * addr_size - (size & (2 * addr_size - 1)); - if (skip == 2 * addr_size) - skip = 0; - size += skip; + /* Base Address Entry. */ + for (i = 0; i < addr_size; i++) + out_byte (0xff); + for (i = 0; i < addr_size; i++) + out_byte (0); + /* Range List Entry. */ for (s = all_segs; s; s = s->next) - size += 2 * addr_size; + { + fragS *frag; + symbolS *beg, *end; + + frag = first_frag_for_seg (s->seg); + beg = symbol_temp_new (s->seg, 0, frag); + s->text_start = beg; + + frag = last_frag_for_seg (s->seg); + end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); + s->text_end = end; + + exp.X_op = O_symbol; + exp.X_add_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); - size += 2 * addr_size; + exp.X_op = O_symbol; + exp.X_add_symbol = end; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + } - subseg_set (aranges_seg, 0); + /* End of Range Entry. */ + for (i = 0; i < addr_size; i++) + out_byte (0); + for (i = 0; i < addr_size; i++) + out_byte (0); +} - /* Length of the compilation unit. */ - out_four (size - 4); +/* Emit data for .debug_aranges. */ + +static void +out_debug_aranges (segT aranges_seg, segT info_seg) +{ + unsigned int addr_size = sizeof_address; + offsetT size; + struct line_seg *s; + expressionS exp; + symbolS *aranges_end; + char *p; + int sizeof_offset; + + sizeof_offset = out_header (aranges_seg, &exp); + aranges_end = exp.X_add_symbol; + size = -exp.X_add_number; /* Version. */ - out_two (2); + out_two (DWARF2_ARANGES_VERSION); + size += 2; /* Offset to .debug_info. */ - /* ??? sizeof_offset */ - TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4); + TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset); + size += sizeof_offset; /* Size of an address (offset portion). */ out_byte (addr_size); + size++; /* Size of a segment descriptor. */ out_byte (0); + size++; /* Align the header. */ - if (skip) - frag_align (ffs (2 * addr_size) - 1, 0, 0); + while ((size++ % (2 * addr_size)) > 0) + out_byte (0); for (s = all_segs; s; s = s->next) { @@ -1349,39 +1674,57 @@ 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); md_number_to_chars (p, 0, addr_size); md_number_to_chars (p + addr_size, 0, addr_size); + + symbol_set_value_now (aranges_end); } /* Emit data for .debug_abbrev. Note that this must be kept in sync with out_debug_info below. */ static void -out_debug_abbrev (segT abbrev_seg) +out_debug_abbrev (segT abbrev_seg, + segT info_seg ATTRIBUTE_UNUSED, + segT line_seg ATTRIBUTE_UNUSED) { subseg_set (abbrev_seg, 0); out_uleb128 (1); out_uleb128 (DW_TAG_compile_unit); out_byte (DW_CHILDREN_no); - out_abbrev (DW_AT_stmt_list, DW_FORM_data4); + if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit) + out_abbrev (DW_AT_stmt_list, DW_FORM_data4); + else + out_abbrev (DW_AT_stmt_list, DW_FORM_data8); if (all_segs->next == NULL) { out_abbrev (DW_AT_low_pc, DW_FORM_addr); - out_abbrev (DW_AT_high_pc, DW_FORM_addr); + if (DWARF2_VERSION < 4) + out_abbrev (DW_AT_high_pc, DW_FORM_addr); + else + out_abbrev (DW_AT_high_pc, (sizeof_address == 4 + ? DW_FORM_data4 : DW_FORM_data8)); + } + else + { + if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit) + out_abbrev (DW_AT_ranges, DW_FORM_data4); + else + out_abbrev (DW_AT_ranges, DW_FORM_data8); } out_abbrev (DW_AT_name, DW_FORM_string); out_abbrev (DW_AT_comp_dir, DW_FORM_string); @@ -1396,55 +1739,22 @@ out_debug_abbrev (segT abbrev_seg) /* Emit a description of this compilation unit for .debug_info. */ static void -out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg) +out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) { char producer[128]; - char *comp_dir; - expressionS expr; - symbolS *info_start; + const char *comp_dir; + const char *dirname; + expressionS exp; symbolS *info_end; char *p; int len; - enum dwarf2_format d2f; int sizeof_offset; - subseg_set (info_seg, 0); - - info_start = symbol_temp_new_now (); - info_end = symbol_temp_make (); - - /* Compilation Unit length. */ - expr.X_op = O_subtract; - expr.X_add_symbol = info_end; - expr.X_op_symbol = info_start; - - d2f = DWARF2_FORMAT (); - if (d2f == dwarf2_format_32bit) - { - expr.X_add_number = -4; - emit_expr (&expr, 4); - sizeof_offset = 4; - } - else if (d2f == dwarf2_format_64bit) - { - expr.X_add_number = -12; - out_four (-1); - emit_expr (&expr, 8); - sizeof_offset = 8; - } - else if (d2f == dwarf2_format_64bit_irix) - { - expr.X_add_number = -8; - emit_expr (&expr, 8); - sizeof_offset = 8; - } - else - { - as_fatal (_("internal error: unknown dwarf2 format")); - } + 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); @@ -1456,45 +1766,64 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg) out_uleb128 (1); /* DW_AT_stmt_list */ - /* ??? sizeof_offset */ - TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4); + TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), + (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit + ? 4 : 8)); - /* These two attributes may only be emitted if all of the code is - contiguous. Multiple sections are not that. */ + /* These two attributes are emitted if all of the code is contiguous. */ 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); + if (DWARF2_VERSION < 4) + exp.X_op = O_symbol; + else + { + exp.X_op = O_subtract; + exp.X_op_symbol = all_segs->text_start; + } + exp.X_add_symbol = all_segs->text_end; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); + } + else + { + /* This attribute is emitted if the code is disjoint. */ + /* DW_AT_ranges. */ + TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset); } /* DW_AT_name. We don't have the actual file name that was present on the command line, so assume files[1] is the main input file. We're not supposed to get called unless at least one line number entry was emitted, so this should always be defined. */ - if (!files || files_in_use < 1) + if (files_in_use == 0) abort (); if (files[1].dir) { - len = strlen (dirs[files[1].dir]); + dirname = remap_debug_filename (dirs[files[1].dir]); + len = strlen (dirname); +#ifdef TE_VMS + /* Already has trailing slash. */ + p = frag_more (len); + memcpy (p, dirname, len); +#else p = frag_more (len + 1); - memcpy (p, dirs[files[1].dir], len); + memcpy (p, dirname, len); INSERT_DIR_SEPARATOR (p, len); +#endif } len = strlen (files[1].filename) + 1; p = frag_more (len); memcpy (p, files[1].filename, len); /* DW_AT_comp_dir */ - comp_dir = getpwd (); + comp_dir = remap_debug_filename (getpwd ()); len = strlen (comp_dir) + 1; p = frag_more (len); memcpy (p, comp_dir, len); @@ -1512,13 +1841,21 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg) symbol_set_value_now (info_end); } +void +dwarf2_init (void) +{ + 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) @@ -1527,13 +1864,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. */ @@ -1546,13 +1894,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; } } @@ -1565,9 +1913,10 @@ dwarf2_finish (void) { segT abbrev_seg; segT aranges_seg; + segT ranges_seg; + + gas_assert (all_segs); - assert (all_segs); - info_seg = subseg_new (".debug_info", 0); abbrev_seg = subseg_new (".debug_abbrev", 0); aranges_seg = subseg_new (".debug_aranges", 0); @@ -1581,8 +1930,19 @@ dwarf2_finish (void) record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); + if (all_segs->next == NULL) + ranges_seg = NULL; + else + { + ranges_seg = subseg_new (".debug_ranges", 0); + bfd_set_section_flags (stdoutput, ranges_seg, + SEC_READONLY | SEC_DEBUGGING); + record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1); + out_debug_ranges (ranges_seg); + } + out_debug_aranges (aranges_seg, info_seg); - out_debug_abbrev (abbrev_seg); - out_debug_info (info_seg, abbrev_seg, line_seg); + out_debug_abbrev (abbrev_seg, info_seg, line_seg); + out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg); } }