#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 "dwarf2.h"
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
+# define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
#endif
/* First special line opcde - leave room for the standard opcodes.
/* 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;
0
};
+/* Lines that are at the same location as CURRENT, and which are waiting
+ for a label. */
+static struct line_entry *pending_lines, **pending_lines_tail = &pending_lines;
+
/* The size of an address on the target. */
static unsigned int sizeof_address;
\f
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
static subsegT last_subseg;
static struct line_subseg *last_line_subseg;
- struct line_seg **ps, *s;
- struct line_subseg **pss, *ss;
+ struct line_seg *s;
+ struct line_subseg **pss, *lss;
if (seg == last_seg && subseg == last_subseg)
return last_line_subseg;
- for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next)
- if (s->seg == seg)
- goto found_seg;
-
- s = (struct line_seg *) xmalloc (sizeof (*s));
- s->next = NULL;
- s->seg = seg;
- s->head = NULL;
- *ps = s;
+ s = (struct line_seg *) hash_find (all_segs_hash, seg->name);
+ if (s == NULL)
+ {
+ s = (struct line_seg *) xmalloc (sizeof (*s));
+ s->next = NULL;
+ s->seg = seg;
+ s->head = NULL;
+ *last_seg_ptr = s;
+ last_seg_ptr = &s->next;
+ hash_insert (all_segs_hash, seg->name, s);
+ }
+ gas_assert (seg == s->seg);
- found_seg:
- for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
+ for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
{
- if (ss->subseg == subseg)
+ if (lss->subseg == subseg)
goto found_subseg;
- if (ss->subseg > subseg)
+ if (lss->subseg > subseg)
break;
}
- ss = (struct line_subseg *) xmalloc (sizeof (*ss));
- ss->next = *pss;
- ss->subseg = subseg;
- ss->head = NULL;
- ss->ptail = &ss->head;
- *pss = ss;
+ lss = (struct line_subseg *) xmalloc (sizeof (*lss));
+ lss->next = *pss;
+ lss->subseg = subseg;
+ lss->head = NULL;
+ lss->ptail = &lss->head;
+ *pss = lss;
found_subseg:
last_seg = seg;
last_subseg = subseg;
- last_line_subseg = ss;
+ last_line_subseg = lss;
- return ss;
+ return lss;
}
-/* Record an entry for LOC occurring at LABEL. */
+/* Push LOC onto the pending lines list. */
static void
-dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
+dwarf2_push_line (struct dwarf2_line_info *loc)
{
- struct line_subseg *ss;
struct line_entry *e;
e = (struct line_entry *) xmalloc (sizeof (*e));
e->next = NULL;
- e->label = label;
+ e->label = NULL;
e->loc = *loc;
- ss = get_line_subseg (now_seg, now_subseg);
- *ss->ptail = e;
- ss->ptail = &e->next;
+ *pending_lines_tail = e;
+ pending_lines_tail = &(*pending_lines_tail)->next;
+}
+
+/* Emit all pending line information. LABEL is the label with which the
+ lines should be associated, or null if they should be associated with
+ the current position. */
+
+static void
+dwarf2_flush_pending_lines (symbolS *label)
+{
+ if (pending_lines)
+ {
+ struct line_subseg *lss;
+ struct line_entry *e;
+
+ if (!label)
+ label = symbol_temp_new_now ();
+
+ for (e = pending_lines; e; e = e->next)
+ e->label = label;
+
+ lss = get_line_subseg (now_seg, now_subseg);
+ *lss->ptail = pending_lines;
+ lss->ptail = pending_lines_tail;
+
+ pending_lines = NULL;
+ pending_lines_tail = &pending_lines;
+ }
}
/* Record an entry for LOC occurring at OFS within the current fragment. */
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;
line = loc->line;
filenum = loc->filenum;
- sym = symbol_temp_new (now_seg, ofs, frag_now);
- dwarf2_gen_line_info_1 (sym, loc);
+ dwarf2_push_line (loc);
+ 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);
+ dwarf2_flush_pending_lines (symbol_new (name, now_seg, ofs, frag_now));
+ }
+ else
+ dwarf2_flush_pending_lines (symbol_temp_new (now_seg, ofs, frag_now));
}
/* Returns the current source information. If .file directives have
void
dwarf2_consume_line_info (void)
{
+ /* If the consumer has stashed the current location away for later use,
+ assume that any earlier location information should be associated
+ with ".". */
+ dwarf2_flush_pending_lines (NULL);
+
/* Unless we generate DWARF2 debugging information for each
assembler line, we only emit one line symbol for one LOC. */
dwarf2_loc_directive_seen = FALSE;
loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
- dwarf2_gen_line_info_1 (label, &loc);
+ dwarf2_push_line (&loc);
+ dwarf2_flush_pending_lines (label);
dwarf2_consume_line_info ();
}
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;
}
--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;
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;
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;
/* If we see two .loc directives in a row, force the first one to be
output now. */
if (dwarf2_loc_directive_seen)
- dwarf2_emit_insn (0);
+ dwarf2_push_line (¤t);
filenum = get_absolute_expression ();
SKIP_WHITESPACE ();
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.
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)
if (line_delta != INT_MAX)
len = 1 + sizeof_leb128 (line_delta, 1);
- if (addr_delta > 50000)
+ if (addr_delta > ADDR_DELTA_LIMIT)
{
/* DW_LNS_extended_op */
len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
char *p, int len)
{
- expressionS *exp;
+ expressionS *pexp;
segT line_seg;
char *end = p + len;
p += output_leb128 (p, line_delta, 1);
}
- exp = symbol_get_value_expression (frag->fr_symbol);
+ pexp = symbol_get_value_expression (frag->fr_symbol);
line_seg = subseg_get (".debug_line", 0);
/* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
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)
+ if (addr_delta > ADDR_DELTA_LIMIT)
{
symbolS *to_sym;
- expressionS expr;
+ expressionS exp;
- gas_assert (exp->X_op = O_subtract);
- to_sym = exp->X_add_symbol;
+ gas_assert (pexp->X_op == O_subtract);
+ to_sym = pexp->X_add_symbol;
*p++ = DW_LNS_extended_op;
p += output_leb128 (p, sizeof_address + 1, 0);
*p++ = DW_LNE_set_address;
- expr.X_op = O_symbol;
- expr.X_add_symbol = to_sym;
- expr.X_add_number = 0;
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = to_sym;
+ exp.X_add_number = 0;
subseg_change (line_seg, 0);
- emit_expr_fix (&expr, sizeof_address, frag, p);
+ emit_expr_fix (&exp, sizeof_address, frag, p);
p += sizeof_address;
}
else
{
*p++ = DW_LNS_fixed_advance_pc;
subseg_change (line_seg, 0);
- emit_expr_fix (exp, 2, frag, p);
+ emit_expr_fix (pexp, 2, frag, p);
p += 2;
}
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);
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
{
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
to the end of the section. */
static int
-out_header (asection *sec, expressionS *expr)
+out_header (asection *sec, expressionS *exp)
{
symbolS *start_sym;
symbolS *end_sym;
end_sym = symbol_temp_make ();
/* Total length of the information. */
- expr->X_op = O_subtract;
- expr->X_add_symbol = end_sym;
- expr->X_op_symbol = start_sym;
+ exp->X_op = O_subtract;
+ exp->X_add_symbol = end_sym;
+ exp->X_op_symbol = start_sym;
switch (DWARF2_FORMAT (sec))
{
case dwarf2_format_32bit:
- expr->X_add_number = -4;
- emit_expr (expr, 4);
+ exp->X_add_number = -4;
+ emit_expr (exp, 4);
return 4;
case dwarf2_format_64bit:
- expr->X_add_number = -12;
+ exp->X_add_number = -12;
out_four (-1);
- emit_expr (expr, 8);
+ emit_expr (exp, 8);
return 8;
case dwarf2_format_64bit_irix:
- expr->X_add_number = -8;
- emit_expr (expr, 8);
+ exp->X_add_number = -8;
+ emit_expr (exp, 8);
return 8;
}
static void
out_debug_line (segT line_seg)
{
- expressionS expr;
+ expressionS exp;
symbolS *prologue_end;
symbolS *line_end;
struct line_seg *s;
int sizeof_offset;
- sizeof_offset = out_header (line_seg, &expr);
- line_end = expr.X_add_symbol;
+ sizeof_offset = out_header (line_seg, &exp);
+ line_end = exp.X_add_symbol;
/* Version. */
- out_two (2);
+ out_two (DWARF2_LINE_VERSION);
/* Length of the prologue following this length. */
prologue_end = symbol_temp_make ();
- expr.X_add_symbol = prologue_end;
- expr.X_add_number = - (4 + 2 + 4);
- emit_expr (&expr, sizeof_offset);
+ exp.X_add_symbol = prologue_end;
+ exp.X_add_number = - (4 + 2 + 4);
+ emit_expr (&exp, sizeof_offset);
/* Parameters of the state machine. */
out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
/* For each section, emit a statement program. */
for (s = all_segs; s; s = s->next)
- process_entries (s->seg, s->head->head);
+ if (SEG_NORMAL (s->seg))
+ process_entries (s->seg, s->head->head);
+ else
+ as_warn ("dwarf line number information for %s ignored",
+ segment_name (s->seg));
symbol_set_value_now (line_end);
}
{
unsigned int addr_size = sizeof_address;
struct line_seg *s;
- expressionS expr;
+ expressionS exp;
unsigned int i;
subseg_set (ranges_seg, 0);
end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
s->text_end = end;
- expr.X_op = O_symbol;
- expr.X_add_symbol = beg;
- expr.X_add_number = 0;
- emit_expr (&expr, addr_size);
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = beg;
+ exp.X_add_number = 0;
+ emit_expr (&exp, addr_size);
- expr.X_op = O_symbol;
- expr.X_add_symbol = end;
- expr.X_add_number = 0;
- emit_expr (&expr, addr_size);
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = end;
+ exp.X_add_number = 0;
+ emit_expr (&exp, addr_size);
}
/* End of Range Entry. */
{
unsigned int addr_size = sizeof_address;
struct line_seg *s;
- expressionS expr;
+ expressionS exp;
symbolS *aranges_end;
char *p;
int sizeof_offset;
- sizeof_offset = out_header (aranges_seg, &expr);
- aranges_end = expr.X_add_symbol;
+ sizeof_offset = out_header (aranges_seg, &exp);
+ aranges_end = exp.X_add_symbol;
/* Version. */
- out_two (2);
+ out_two (DWARF2_ARANGES_VERSION);
/* Offset to .debug_info. */
TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
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);
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
{
char producer[128];
const char *comp_dir;
const char *dirname;
- expressionS expr;
+ expressionS exp;
symbolS *info_end;
char *p;
int len;
int sizeof_offset;
- sizeof_offset = out_header (info_seg, &expr);
- info_end = expr.X_add_symbol;
+ sizeof_offset = out_header (info_seg, &exp);
+ info_end = exp.X_add_symbol;
/* DWARF version. */
- out_two (2);
+ out_two (DWARF2_VERSION);
/* .debug_abbrev offset */
TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
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
{
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)
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. */
/* 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;
}
}
projects / binutils.git / blobdiff