X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fdwarf2dbg.c;h=85c1f30e89898c8d70f9752523c15825058abed4;hb=704897fbeff6f2247f87578efb9054e246fd0cd0;hp=281177e4aa69b0937baf100d01fb12d36c902c8d;hpb=7be1c4891a2036c31e706908d43f33f7f59ae5a9;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c index 281177e4aa..85c1f30e89 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 + Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by David Mosberger-Tang @@ -7,7 +7,7 @@ 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, @@ -21,15 +21,16 @@ 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] + .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \ + [epilogue_begin] [is_stmt VALUE] [isa VALUE] \ + [discriminator VALUE] +*/ - FILENO is the filenumber. */ - -#include "ansidecl.h" #include "as.h" +#include "safe-ctype.h" #ifdef HAVE_LIMITS_H #include @@ -45,17 +46,52 @@ #include "dwarf2dbg.h" #include +#ifdef HAVE_DOS_BASED_FILE_SYSTEM +/* We need to decide which character to use as a directory separator. + Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not + necessarily mean that the backslash character is the one to use. + Some environments, eg Cygwin, can support both naming conventions. + So we use the heuristic that we only need to use the backslash if + the path is an absolute path starting with a DOS style drive + selector. eg C: or D: */ +# define INSERT_DIR_SEPARATOR(string, offset) \ + do \ + { \ + if (offset > 1 \ + && string[0] != 0 \ + && string[1] == ':') \ + string [offset] = '\\'; \ + else \ + string [offset] = '/'; \ + } \ + while (0) +#else +# define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/' +#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 + #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 @@ -65,11 +101,18 @@ #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 0 +#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 - 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 @@ -88,10 +131,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. */ @@ -107,8 +147,7 @@ struct line_entry { struct line_entry *next; - fragS *frag; - addressT frag_ofs; + symbolS *label; struct dwarf2_line_info loc; }; @@ -129,6 +168,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; @@ -147,53 +190,38 @@ 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. */ +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, + 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 *); -static void out_set_addr (segT, fragS *, addressT); -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 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 @@ -207,43 +235,63 @@ get_line_subseg (segT seg, subsegT subseg) static struct line_subseg *last_line_subseg; struct line_seg *s; - struct line_subseg **pss, *ss; + struct line_subseg **pss, *lss; if (seg == last_seg && subseg == last_subseg) return last_line_subseg; - for (s = all_segs; s; s = s->next) - if (s->seg == seg) - goto found_seg; - - s = (struct line_seg *) xmalloc (sizeof (*s)); - s->next = all_segs; - s->seg = seg; - s->head = NULL; - all_segs = 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. */ + +static void +dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) +{ + struct line_subseg *lss; + struct line_entry *e; + + e = (struct line_entry *) xmalloc (sizeof (*e)); + e->next = NULL; + e->label = label; + e->loc = *loc; + + lss = get_line_subseg (now_seg, now_subseg); + *lss->ptail = e; + lss->ptail = &e->next; } /* Record an entry for LOC occurring at OFS within the current fragment. */ @@ -251,11 +299,11 @@ get_line_subseg (segT seg, subsegT subseg) 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; @@ -271,17 +319,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) { @@ -291,12 +337,23 @@ 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; + line->discriminator = current.discriminator; } 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 @@ -307,26 +364,56 @@ 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 (); +} + +/* 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 + 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 (files_in_use == 0 && debug_type != DEBUG_DWARF2) + return; + + dwarf2_where (&loc); + + 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, @@ -369,7 +456,9 @@ 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 && dirs[dir][dir_len] == '\0') @@ -384,7 +473,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; @@ -419,7 +508,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; @@ -449,6 +539,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) @@ -457,6 +549,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); @@ -471,14 +567,16 @@ dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) void dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { - offsetT filenum, line, column; + 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 (); - SKIP_WHITESPACE (); - column = get_absolute_expression (); - demand_empty_rest_of_line (); if (filenum < 1) { @@ -493,10 +591,7 @@ 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; + current.discriminator = 0; #ifndef NO_LISTING if (listing) @@ -508,7 +603,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) char *cp = (char *) alloca (dir_len + 1 + file_len + 1); memcpy (cp, dirs[files[filenum].dir], dir_len); - cp[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); @@ -518,32 +613,122 @@ 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 if (strcmp (p, "discriminator") == 0) + { + *input_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; + return; + } + + SKIP_WHITESPACE (); + } + + demand_empty_rest_of_line (); + dwarf2_loc_directive_seen = TRUE; + debug_type = DEBUG_NONE; +} + +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 * first_frag_for_seg (segT seg) { - frchainS *f, *first = NULL; - - for (f = frchain_root; f; f = f->frch_next) - if (f->frch_seg == seg - && (! first || first->frch_subseg > f->frch_subseg)) - first = f; - - return first ? first->frch_root : NULL; + return seg_info (seg)->frchainP->frch_root; } static struct frag * last_frag_for_seg (segT seg) { - frchainS *f, *last = NULL; + frchainS *f = seg_info (seg)->frchainP; - for (f = frchain_root; f; f = f->frch_next) - if (f->frch_seg == seg - && (! last || last->frch_subseg < f->frch_subseg)) - last= f; + while (f->frch_next != NULL) + f = f->frch_next; - return last ? last->frch_last : NULL; + return f->frch_last; } /* Emit a single byte into the current segment. */ @@ -586,6 +771,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 @@ -598,7 +791,7 @@ out_abbrev (int name, int form) /* Get the size of a fragment. */ static offsetT -get_frag_fix (fragS *frag) +get_frag_fix (fragS *frag, segT seg) { frchainS *fr; @@ -608,7 +801,7 @@ get_frag_fix (fragS *frag) /* If a fragment is the last in the chain, special measures must be taken to find its size before relaxation, since it may be pending on some subsegment chain. */ - for (fr = frchain_root; fr; fr = fr->frch_next) + for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next) if (fr->frch_last == frag) return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal; @@ -618,21 +811,18 @@ 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); + 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 @@ -727,6 +917,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. */ + gas_assert ((offsetT) addr_delta >= 0); + /* Scale the address delta by the minimum instruction length. */ scale_addr_delta (&addr_delta); @@ -759,19 +953,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; @@ -806,7 +1000,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. */ @@ -818,32 +1012,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. */ + +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 > 50000) + { + /* 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; + segT line_seg; + 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); + + /* 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); + line_seg = subseg_get (".debug_line", 0); + + /* 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 > 50000) + { + 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; + subseg_change (line_seg, 0); + 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 (pexp, 2, frag, p); + 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, 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; + expressionS exp; 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; - 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 @@ -857,7 +1150,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; @@ -893,10 +1189,15 @@ dwarf2dbg_convert_frag (fragS *frag) /* 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; @@ -913,23 +1214,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) @@ -937,64 +1237,78 @@ 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 (e->loc.discriminator != 0) { - flags = e->loc.flags; - out_opcode (DW_LNS_negate_stmt); - changed = 1; + 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; + 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 && ! 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); + + 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); - if (frag == last_frag) - out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs); + frag = last_frag_for_seg (seg); + frag_ofs = get_frag_fix (frag, seg); + if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) + 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. */ @@ -1003,21 +1317,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); @@ -1026,77 +1344,89 @@ 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); } +/* 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. */ + +static int +out_header (asection *sec, expressionS *exp) +{ + symbolS *start_sym; + symbolS *end_sym; + + subseg_set (sec, 0); + start_sym = symbol_temp_new_now ();; + end_sym = symbol_temp_make (); + + /* 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)) + { + 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 expr; - symbolS *line_start; + expressionS exp; 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 (); - - /* 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; - - 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 (line_seg, &exp); + line_end = exp.X_add_symbol; /* Version. */ out_two (2); /* 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_end = symbol_temp_make (); + 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); @@ -1115,6 +1445,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 (); @@ -1127,40 +1460,74 @@ out_debug_line (segT line_seg) 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; - size += 2 * addr_size; + 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); - subseg_set (aranges_seg, 0); + exp.X_op = O_symbol; + exp.X_add_symbol = end; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + } + + /* 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; + 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; /* Version. */ out_two (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 of an address (offset portion). */ out_byte (addr_size); @@ -1169,8 +1536,7 @@ out_debug_aranges (segT aranges_seg, segT info_seg) out_byte (0); /* Align the header. */ - if (skip) - frag_align (ffs (2 * addr_size) - 1, 0, 0); + frag_align (ffs (2 * addr_size) - 1, 0, 0); for (s = all_segs; s; s = s->next) { @@ -1182,43 +1548,57 @@ out_debug_aranges (segT aranges_seg, segT info_seg) s->text_start = beg; frag = last_frag_for_seg (s->seg); - end = symbol_temp_new (s->seg, get_frag_fix (frag), frag); + 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); } + 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); out_abbrev (DW_AT_producer, DW_FORM_string); @@ -1232,52 +1612,19 @@ 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); @@ -1292,45 +1639,58 @@ 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); + exp.X_op = O_symbol; + 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); - p[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); @@ -1348,13 +1708,22 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_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) @@ -1363,13 +1732,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. */ @@ -1382,13 +1762,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; } } @@ -1401,9 +1781,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); @@ -1417,8 +1798,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); } }