gas/ 2006-10-13 Sterling Augstine * dwarf2dbg.c (out_debug_info): Use TC_DWARF2_EMIT_OFFSET to emit a disjoint DW_AT range. 2006-08-08 Bob Wilson * dwarf2dbg.c (DWARF2_USE_FIXED_ADVANCE_PC): New. (out_sleb128): New. (out_fixed_inc_line_addr): New. (process_entries): Use out_fixed_inc_line_addr when DWARF2_USE_FIXED_ADVANCE_PC is set. * config/tc-xtensa.h (DWARF2_USE_FIXED_ADVANCE_PC): Define. 2006-08-08 Sterling Augustine * dwarf2dbg.c (out_debug_info): Add new parameter ranges_seg and emit DW_AT_ranges when code in compilation unit is not contiguous. (out_debug_abbrev): Emit DW_AT_ranges abbreviation if code in is not contiguous. (dwarf2_finish): Create and pass ranges_seg to out_debug_info. (out_debug_ranges): New function to emit .debug_ranges section when code is not contiguous. gas/testsuite/ 2006-08-08 Bob Wilson * gas/lns/lns-common-1-alt.d: New file. * gas/lns/lns.exp: Use lns-common-1-alt.d for xtensa targets. --- gas/dwarf2dbg.c 2006-07-15 14:23:50.000000000 -0400 +++ gas/dwarf2dbg.c 2006-10-20 14:50:58.000000000 -0400 @@ -88,6 +88,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 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 @@ -191,22 +198,22 @@ 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); -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_*. */ @@ -746,6 +753,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_sleb128 (addressT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); +} + /* Emit a tuple for .debug_abbrev. */ static inline void @@ -979,6 +994,45 @@ out_inc_line_addr (int line_delta, addre 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 helps support linker relaxation that + changes the code offsets. */ + +static void +out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) +{ + expressionS expr; + + /* 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; + 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; + } + + 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); + + out_opcode (DW_LNS_copy); +} + /* Generate a variant frag that we can use to relax address/line increments between fragments of the target segment. */ @@ -1129,6 +1183,8 @@ process_entries (segT seg, struct line_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) out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); else @@ -1148,7 +1204,12 @@ process_entries (segT seg, struct line_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 (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) out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); else { @@ -1290,6 +1351,54 @@ out_debug_line (segT line_seg) symbol_set_value_now (line_end); } +static void +out_debug_ranges (segT ranges_seg) +{ + unsigned int addr_size = sizeof_address; + struct line_seg *s; + expressionS expr; + unsigned int i; + + subseg_set (ranges_seg, 0); + + /* 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) + { + 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; + + expr.X_op = O_symbol; + expr.X_add_symbol = beg; + expr.X_add_number = 0; + emit_expr (&expr, addr_size); + + expr.X_op = O_symbol; + expr.X_add_symbol = end; + expr.X_add_number = 0; + emit_expr (&expr, 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); +} + /* Emit data for .debug_aranges. */ static void @@ -1382,6 +1491,13 @@ out_debug_abbrev (segT abbrev_seg) out_abbrev (DW_AT_low_pc, DW_FORM_addr); out_abbrev (DW_AT_high_pc, DW_FORM_addr); } + else + { + if (DWARF2_FORMAT () == 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); @@ -1395,7 +1511,7 @@ 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; @@ -1458,8 +1574,7 @@ out_debug_info (segT info_seg, segT abbr /* ??? sizeof_offset */ TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4); - /* 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 */ @@ -1474,6 +1589,12 @@ out_debug_info (segT info_seg, segT abbr expr.X_add_number = 0; emit_expr (&expr, 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. @@ -1564,6 +1685,7 @@ dwarf2_finish (void) { segT abbrev_seg; segT aranges_seg; + segT ranges_seg; assert (all_segs); @@ -1580,8 +1702,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_info (info_seg, abbrev_seg, line_seg, ranges_seg); } } --- gas/testsuite/gas/lns/lns-common-1-alt.d 1969-12-31 19:00:00.000000000 -0500 +++ gas/testsuite/gas/lns/lns-common-1-alt.d 2006-09-24 11:19:58.000000000 -0400 @@ -0,0 +1,39 @@ +#source: lns-common-1.s +#readelf: -wl +#name: lns-common-1 +Dump of debug contents of section \.debug_line: +#... + Initial value of 'is_stmt': 1 +#... + Line Number Statements: + Extended opcode 2: set Address to .* + Copy + Set column to 3 + Advance Line by 1 to 2 + Advance PC by fixed size amount .* to .* + Copy + Set prologue_end to true + Advance Line by 1 to 3 + Advance PC by fixed size amount .* to .* + Copy + Set column to 0 + Set epilogue_begin to true + Advance Line by 1 to 4 + Advance PC by fixed size amount .* to .* + Copy + Set ISA to 1 + Set basic block + Advance Line by 1 to 5 + Advance PC by fixed size amount .* to .* + Copy + Set is_stmt to 0 + Advance Line by 1 to 6 + Advance PC by fixed size amount .* to .* + Copy + Set is_stmt to 1 + Advance Line by 1 to 7 + Advance PC by fixed size amount .* to .* + Copy + Advance PC by fixed size amount .* to .* + Extended opcode 1: End of Sequence +#... --- gas/testsuite/gas/lns/lns.exp 2005-11-13 12:16:35.000000000 -0500 +++ gas/testsuite/gas/lns/lns.exp 2006-09-24 11:19:58.000000000 -0400 @@ -23,5 +23,10 @@ run_list_test "lns-diag-1" "" # defined a macro... if { ![istarget ia64*-*-*] && ![istarget i370-*-*] && ![istarget i960-*-*] && ![istarget or32-*-*] && ![istarget s390*-*-*] } { - run_dump_test "lns-common-1" + # Use alternate file for targets using DW_LNS_fixed_advance_pc opcodes. + if { [istarget xtensa-*-*] } { + run_dump_test "lns-common-1-alt" + } else { + run_dump_test "lns-common-1" + } }