X-Git-Url: https://oss.titaniummirror.com/gitweb?p=msp430-binutils.git;a=blobdiff_plain;f=gas%2Fdwarf2dbg.c;fp=gas%2Fdwarf2dbg.c;h=2896b212a222eeb8062f3135a91d616f81bba7ca;hp=93b5f480b06a340497aca34d23b16bac70d1b179;hb=88750007d7869f178f0ba528f41efd3b74c424cf;hpb=6df9443a374e2b81278c61b8afc0a1eef7db280b diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c index 93b5f48..2896b21 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 + Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by David Mosberger-Tang @@ -25,7 +25,8 @@ .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 "as.h" @@ -57,8 +58,8 @@ do \ { \ if (offset > 1 \ - && string[0] != 0 \ - && string[1] == ':') \ + && string[0] != 0 \ + && string[1] == ':') \ string [offset] = '\\'; \ else \ string [offset] = '/'; \ @@ -69,16 +70,28 @@ #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 @@ -173,7 +186,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. */ @@ -182,36 +195,15 @@ 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 void out_sleb128 (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 out_fixed_inc_line_addr (int, symbolS *, symbolS *); -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); - + #ifndef TC_DWARF2_EMIT_OFFSET #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset @@ -341,12 +333,13 @@ dwarf2_where (struct dwarf2_line_info *line) 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 @@ -365,30 +358,31 @@ 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 @@ -405,22 +399,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, @@ -463,7 +450,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') @@ -478,7 +467,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; @@ -554,6 +543,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); @@ -570,6 +563,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 (); @@ -587,6 +585,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) current.filenum = filenum; current.line = line; + current.discriminator = 0; #ifndef NO_LISTING if (listing) @@ -655,7 +654,7 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) } else if (strcmp (p, "isa") == 0) { - *input_line_pointer = c; + *input_line_pointer = c; value = get_absolute_expression (); if (value >= 0) current.isa = value; @@ -665,10 +664,22 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) 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; + *input_line_pointer = c; return; } @@ -676,7 +687,8 @@ dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) } demand_empty_rest_of_line (); - loc_directive_seen = TRUE; + dwarf2_loc_directive_seen = TRUE; + debug_type = DEBUG_NONE; } void @@ -756,7 +768,7 @@ out_uleb128 (addressT value) /* Emit a signed "little-endian base 128" number. */ static void -out_sleb128 (addressT value) +out_leb128 (addressT value) { output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); } @@ -901,7 +913,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); @@ -982,7 +994,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. */ @@ -996,41 +1008,103 @@ out_inc_line_addr (int line_delta, addressT addr_delta) /* 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 helps support linker relaxation that - changes the code offsets. */ + 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 void -out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) +static int +size_fixed_inc_line_addr (int line_delta, addressT addr_delta) { - expressionS expr; + 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 *exp; + 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) { - out_opcode (DW_LNS_fixed_advance_pc); - expr.X_op = O_subtract; + *p++ = DW_LNS_advance_line; + p += output_leb128 (p, line_delta, 1); + } + + exp = 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 expr; + + gas_assert (exp->X_op = O_subtract); + to_sym = exp->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_op_symbol = from_sym; expr.X_add_number = 0; - emit_expr (&expr, 2); - - out_opcode (DW_LNS_extended_op); - out_byte (1); - out_opcode (DW_LNE_end_sequence); - return; + subseg_change (line_seg, 0); + emit_expr_fix (&expr, 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); + p += 2; } - out_opcode (DW_LNS_advance_line); - out_sleb128 (line_delta); - - out_opcode (DW_LNS_fixed_advance_pc); - expr.X_op = O_subtract; - expr.X_add_symbol = to_sym; - expr.X_op_symbol = from_sym; - expr.X_add_number = 0; - emit_expr (&expr, 2); + if (line_delta == INT_MAX) + { + *p++ = DW_LNS_extended_op; + *p++ = 1; + *p++ = DW_LNE_end_sequence; + } + else + *p++ = DW_LNS_copy; - out_opcode (DW_LNS_copy); + gas_assert (p == end); } /* Generate a variant frag that we can use to relax address/line @@ -1049,7 +1123,11 @@ relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) /* 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); @@ -1066,7 +1144,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; @@ -1102,10 +1183,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; @@ -1147,6 +1233,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; @@ -1183,9 +1277,7 @@ process_entries (segT seg, struct line_entry *e) out_set_addr (lab); out_inc_line_addr (line_delta, 0); } - else if (DWARF2_USE_FIXED_ADVANCE_PC) - out_fixed_inc_line_addr (line_delta, lab, last_lab); - 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); @@ -1204,12 +1296,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 (DWARF2_USE_FIXED_ADVANCE_PC) - { - lab = symbol_temp_new (seg, frag_ofs, frag); - out_fixed_inc_line_addr (INT_MAX, lab, last_lab); - } - else 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 { @@ -1241,6 +1328,8 @@ out_file_list (void) for (i = 1; i < files_in_use; ++i) { + const char *fullfilename; + if (files[i].filename == NULL) { as_bad (_("unassigned file number %ld"), (long) i); @@ -1249,75 +1338,87 @@ 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 *expr) +{ + 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. */ + expr->X_op = O_subtract; + expr->X_add_symbol = end_sym; + expr->X_op_symbol = start_sym; + + switch (DWARF2_FORMAT (sec)) + { + case dwarf2_format_32bit: + expr->X_add_number = -4; + emit_expr (expr, 4); + return 4; + + case dwarf2_format_64bit: + expr->X_add_number = -12; + out_four (-1); + emit_expr (expr, 8); + return 8; + + case dwarf2_format_64bit_irix: + expr->X_add_number = -8; + emit_expr (expr, 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; 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, &expr); + line_end = expr.X_add_symbol; /* Version. */ out_two (2); /* Length of the prologue following this length. */ - expr.X_op = O_subtract; + prologue_end = symbol_temp_make (); expr.X_add_symbol = prologue_end; - expr.X_op_symbol = line_start; expr.X_add_number = - (4 + 2 + 4); emit_expr (&expr, sizeof_offset); @@ -1364,9 +1465,9 @@ out_debug_ranges (segT ranges_seg) subseg_set (ranges_seg, 0); /* Base Address Entry. */ - for (i = 0; i < addr_size; i++) + for (i = 0; i < addr_size; i++) out_byte (0xff); - for (i = 0; i < addr_size; i++) + for (i = 0; i < addr_size; i++) out_byte (0); /* Range List Entry. */ @@ -1395,9 +1496,9 @@ out_debug_ranges (segT ranges_seg) } /* End of Range Entry. */ - for (i = 0; i < addr_size; i++) + for (i = 0; i < addr_size; i++) out_byte (0); - for (i = 0; i < addr_size; i++) + for (i = 0; i < addr_size; i++) out_byte (0); } @@ -1407,34 +1508,20 @@ static void out_debug_aranges (segT aranges_seg, segT info_seg) { unsigned int addr_size = sizeof_address; - addressT size, skip; struct line_seg *s; expressionS expr; + symbolS *aranges_end; char *p; + int sizeof_offset; - size = 4 + 2 + 4 + 1 + 1; - - skip = 2 * addr_size - (size & (2 * addr_size - 1)); - if (skip == 2 * addr_size) - skip = 0; - size += skip; - - for (s = all_segs; s; s = s->next) - size += 2 * addr_size; - - size += 2 * addr_size; - - subseg_set (aranges_seg, 0); - - /* Length of the compilation unit. */ - out_four (size - 4); + sizeof_offset = out_header (aranges_seg, &expr); + aranges_end = expr.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); @@ -1443,8 +1530,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) { @@ -1474,20 +1560,27 @@ out_debug_aranges (segT aranges_seg, segT info_seg) 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); @@ -1495,7 +1588,7 @@ out_debug_abbrev (segT abbrev_seg) } else { - if (DWARF2_FORMAT () == dwarf2_format_32bit) + 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); @@ -1519,47 +1612,13 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) const char *comp_dir; const char *dirname; expressionS expr; - symbolS *info_start; 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, &expr); + info_end = expr.X_add_symbol; /* DWARF version. */ out_two (2); @@ -1574,8 +1633,9 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_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 are emitted if all of the code is contiguous. */ if (all_segs->next == NULL) @@ -1603,15 +1663,21 @@ out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) 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) { 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, dirname, len); INSERT_DIR_SEPARATOR (p, len); +#endif } len = strlen (files[1].filename) + 1; p = frag_more (len); @@ -1691,8 +1757,8 @@ dwarf2_finish (void) segT aranges_seg; segT ranges_seg; - assert (all_segs); - + gas_assert (all_segs); + info_seg = subseg_new (".debug_info", 0); abbrev_seg = subseg_new (".debug_abbrev", 0); aranges_seg = subseg_new (".debug_aranges", 0); @@ -1711,14 +1777,14 @@ dwarf2_finish (void) else { ranges_seg = subseg_new (".debug_ranges", 0); - bfd_set_section_flags (stdoutput, ranges_seg, + 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_abbrev (abbrev_seg, info_seg, line_seg); out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg); } }