/* dwarf2dbg.c - DWARF2 debug support
- Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1999-2019 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
#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 outputs version 3 .debug_line information. */
+#ifndef DWARF2_LINE_VERSION
+#define DWARF2_LINE_VERSION 3
+#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.
+/* First special line opcode - 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
out_debug_line(). */
/* The maximum address skip amount that can be encoded with a special op. */
#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
-struct line_entry {
+#ifndef TC_PARSE_CONS_RETURN_NONE
+#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
+#endif
+
+struct line_entry
+{
struct line_entry *next;
symbolS *label;
struct dwarf2_line_info loc;
};
-struct line_subseg {
+/* Don't change the offset of next in line_entry. set_or_check_view
+ calls in dwarf2_gen_line_info_1 depend on it. */
+static char unused[offsetof(struct line_entry, next) ? -1 : 1]
+ATTRIBUTE_UNUSED;
+
+struct line_subseg
+{
struct line_subseg *next;
subsegT subseg;
struct line_entry *head;
struct line_entry **ptail;
+ struct line_entry **pmove_tail;
};
-struct line_seg {
+struct line_seg
+{
struct line_seg *next;
segT seg;
struct line_subseg *head;
/* Collects data for all line table entries during assembly. */
static struct line_seg *all_segs;
+static struct line_seg **last_seg_ptr;
-struct file_entry {
+struct file_entry
+{
const char *filename;
unsigned int dir;
};
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
+ 0, NULL
};
+/* This symbol is used to recognize view number forced resets in loc
+ lists. */
+static symbolS *force_reset_view;
+
+/* This symbol evaluates to an expression that, if nonzero, indicates
+ some view assert check failed. */
+static symbolS *view_assert_failed;
+
/* 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);
+ memset (&exp, 0, sizeof exp);
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = symbol;
+ exp.X_add_number = 0;
+ emit_expr (&exp, size);
}
#endif
-/* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
+/* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
static struct line_subseg *
-get_line_subseg (segT seg, subsegT subseg)
+get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p)
{
- static segT last_seg;
- static subsegT last_subseg;
- static struct line_subseg *last_line_subseg;
-
- struct line_seg **ps, *s;
- struct line_subseg **pss, *ss;
+ struct line_seg *s = seg_info (seg)->dwarf2_line_seg;
+ 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;
+ if (s == NULL)
+ {
+ if (!create_p)
+ return NULL;
+
+ s = XNEW (struct line_seg);
+ s->next = NULL;
+ s->seg = seg;
+ s->head = NULL;
+ *last_seg_ptr = s;
+ last_seg_ptr = &s->next;
+ seg_info (seg)->dwarf2_line_seg = s;
+ }
+ gas_assert (seg == s->seg);
- found_seg:
- for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
+ for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
{
- if (ss->subseg == subseg)
+ if (lss->subseg == subseg)
goto found_subseg;
- if (ss->subseg > subseg)
+ if (lss->subseg > subseg)
break;
}
- ss = (struct line_subseg *) xmalloc (sizeof (*ss));
- ss->next = *pss;
- ss->subseg = subseg;
- ss->head = NULL;
- ss->ptail = &ss->head;
- *pss = ss;
+ lss = XNEW (struct line_subseg);
+ lss->next = *pss;
+ lss->subseg = subseg;
+ lss->head = NULL;
+ lss->ptail = &lss->head;
+ lss->pmove_tail = &lss->head;
+ *pss = lss;
found_subseg:
- last_seg = seg;
- last_subseg = subseg;
- last_line_subseg = ss;
+ return lss;
+}
+
+/* (Un)reverse the line_entry list starting from H. */
- return ss;
+static struct line_entry *
+reverse_line_entry_list (struct line_entry *h)
+{
+ struct line_entry *p = NULL, *e, *n;
+
+ for (e = h; e; e = n)
+ {
+ n = e->next;
+ e->next = p;
+ p = e;
+ }
+ return p;
+}
+
+/* Compute the view for E based on the previous entry P. If we
+ introduce an (undefined) view symbol for P, and H is given (P must
+ be the tail in this case), introduce view symbols for earlier list
+ entries as well, until one of them is constant. */
+
+static void
+set_or_check_view (struct line_entry *e, struct line_entry *p,
+ struct line_entry *h)
+{
+ expressionS viewx;
+
+ memset (&viewx, 0, sizeof (viewx));
+ viewx.X_unsigned = 1;
+
+ /* First, compute !(E->label > P->label), to tell whether or not
+ we're to reset the view number. If we can't resolve it to a
+ constant, keep it symbolic. */
+ if (!p || (e->loc.view == force_reset_view && force_reset_view))
+ {
+ viewx.X_op = O_constant;
+ viewx.X_add_number = 0;
+ viewx.X_add_symbol = NULL;
+ viewx.X_op_symbol = NULL;
+ }
+ else
+ {
+ viewx.X_op = O_gt;
+ viewx.X_add_number = 0;
+ viewx.X_add_symbol = e->label;
+ viewx.X_op_symbol = p->label;
+ resolve_expression (&viewx);
+ if (viewx.X_op == O_constant)
+ viewx.X_add_number = !viewx.X_add_number;
+ else
+ {
+ viewx.X_add_symbol = make_expr_symbol (&viewx);
+ viewx.X_add_number = 0;
+ viewx.X_op_symbol = NULL;
+ viewx.X_op = O_logical_not;
+ }
+ }
+
+ if (S_IS_DEFINED (e->loc.view) && symbol_constant_p (e->loc.view))
+ {
+ expressionS *value = symbol_get_value_expression (e->loc.view);
+ /* We can't compare the view numbers at this point, because in
+ VIEWX we've only determined whether we're to reset it so
+ far. */
+ if (viewx.X_op == O_constant)
+ {
+ if (!value->X_add_number != !viewx.X_add_number)
+ as_bad (_("view number mismatch"));
+ }
+ /* Record the expression to check it later. It is the result of
+ a logical not, thus 0 or 1. We just add up all such deferred
+ expressions, and resolve it at the end. */
+ else if (!value->X_add_number)
+ {
+ symbolS *deferred = make_expr_symbol (&viewx);
+ if (view_assert_failed)
+ {
+ expressionS chk;
+
+ memset (&chk, 0, sizeof (chk));
+ chk.X_unsigned = 1;
+ chk.X_op = O_add;
+ chk.X_add_number = 0;
+ chk.X_add_symbol = view_assert_failed;
+ chk.X_op_symbol = deferred;
+ deferred = make_expr_symbol (&chk);
+ }
+ view_assert_failed = deferred;
+ }
+ }
+
+ if (viewx.X_op != O_constant || viewx.X_add_number)
+ {
+ expressionS incv;
+
+ if (!p->loc.view)
+ {
+ p->loc.view = symbol_temp_make ();
+ gas_assert (!S_IS_DEFINED (p->loc.view));
+ }
+
+ memset (&incv, 0, sizeof (incv));
+ incv.X_unsigned = 1;
+ incv.X_op = O_symbol;
+ incv.X_add_symbol = p->loc.view;
+ incv.X_add_number = 1;
+
+ if (viewx.X_op == O_constant)
+ {
+ gas_assert (viewx.X_add_number == 1);
+ viewx = incv;
+ }
+ else
+ {
+ viewx.X_add_symbol = make_expr_symbol (&viewx);
+ viewx.X_add_number = 0;
+ viewx.X_op_symbol = make_expr_symbol (&incv);
+ viewx.X_op = O_multiply;
+ }
+ }
+
+ if (!S_IS_DEFINED (e->loc.view))
+ {
+ symbol_set_value_expression (e->loc.view, &viewx);
+ S_SET_SEGMENT (e->loc.view, expr_section);
+ symbol_set_frag (e->loc.view, &zero_address_frag);
+ }
+
+ /* Define and attempt to simplify any earlier views needed to
+ compute E's. */
+ if (h && p && p->loc.view && !S_IS_DEFINED (p->loc.view))
+ {
+ struct line_entry *h2;
+ /* Reverse the list to avoid quadratic behavior going backwards
+ in a single-linked list. */
+ struct line_entry *r = reverse_line_entry_list (h);
+
+ gas_assert (r == p);
+ /* Set or check views until we find a defined or absent view. */
+ do
+ {
+ /* Do not define the head of a (sub?)segment view while
+ handling others. It would be defined too early, without
+ regard to the last view of other subsegments.
+ set_or_check_view will be called for every head segment
+ that needs it. */
+ if (r == h)
+ break;
+ set_or_check_view (r, r->next, NULL);
+ }
+ while (r->next && r->next->loc.view && !S_IS_DEFINED (r->next->loc.view)
+ && (r = r->next));
+
+ /* Unreverse the list, so that we can go forward again. */
+ h2 = reverse_line_entry_list (p);
+ gas_assert (h2 == h);
+
+ /* Starting from the last view we just defined, attempt to
+ simplify the view expressions, until we do so to P. */
+ do
+ {
+ /* The head view of a subsegment may remain undefined while
+ handling other elements, before it is linked to the last
+ view of the previous subsegment. */
+ if (r == h)
+ continue;
+ gas_assert (S_IS_DEFINED (r->loc.view));
+ resolve_expression (symbol_get_value_expression (r->loc.view));
+ }
+ while (r != p && (r = r->next));
+
+ /* Now that we've defined and computed all earlier views that might
+ be needed to compute E's, attempt to simplify it. */
+ resolve_expression (symbol_get_value_expression (e->loc.view));
+ }
}
/* 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 *ss;
+ struct line_subseg *lss;
struct line_entry *e;
- e = (struct line_entry *) xmalloc (sizeof (*e));
+ e = XNEW (struct line_entry);
e->next = NULL;
e->label = label;
e->loc = *loc;
- ss = get_line_subseg (now_seg, now_subseg);
- *ss->ptail = e;
- ss->ptail = &e->next;
+ lss = get_line_subseg (now_seg, now_subseg, TRUE);
+
+ /* Subseg heads are chained to previous subsegs in
+ dwarf2_finish. */
+ if (loc->view && lss->head)
+ set_or_check_view (e,
+ (struct line_entry *)lss->ptail,
+ lss->head);
+
+ *lss->ptail = e;
+ lss->ptail = &e->next;
}
/* Record an entry for LOC occurring at OFS within the current fragment. */
line = loc->line;
filenum = loc->filenum;
- sym = symbol_temp_new (now_seg, ofs, frag_now);
+ if (linkrelax)
+ {
+ char name[120];
+
+ /* Use a non-fake name for the line number location,
+ so that it can be referred to by relocations. */
+ sprintf (name, ".Loc.%u.%u", line, filenum);
+ sym = symbol_new (name, now_seg, ofs, frag_now);
+ }
+ else
+ sym = symbol_temp_new (now_seg, ofs, frag_now);
dwarf2_gen_line_info_1 (sym, loc);
}
{
if (debug_type == DEBUG_DWARF2)
{
- char *filename;
- as_where (&filename, &line->line);
+ const char *filename;
+
+ memset (line, 0, sizeof (*line));
+ filename = as_where (&line->line);
line->filenum = get_filenum (filename, 0);
line->column = 0;
line->flags = DWARF2_FLAG_IS_STMT;
line->isa = current.isa;
line->discriminator = current.discriminator;
+ line->view = NULL;
}
else
*line = current;
{
struct dwarf2_line_info loc;
- if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
+ if (debug_type != DEBUG_DWARF2
+ ? !dwarf2_loc_directive_seen
+ : !seen_at_least_1_file ())
return;
dwarf2_where (&loc);
- dwarf2_gen_line_info (frag_now_fix () - size, &loc);
+ dwarf2_gen_line_info ((frag_now_fix_octets () - size) / OCTETS_PER_BYTE, &loc);
dwarf2_consume_line_info ();
}
+/* Move all previously-emitted line entries for the current position by
+ DELTA bytes. This function cannot be used to move the same entries
+ twice. */
+
+void
+dwarf2_move_insn (int delta)
+{
+ struct line_subseg *lss;
+ struct line_entry *e;
+ valueT now;
+
+ if (delta == 0)
+ return;
+
+ lss = get_line_subseg (now_seg, now_subseg, FALSE);
+ if (!lss)
+ return;
+
+ now = frag_now_fix ();
+ while ((e = *lss->pmove_tail))
+ {
+ if (S_GET_VALUE (e->label) == now)
+ S_SET_VALUE (e->label, now + delta);
+ lss->pmove_tail = &e->next;
+ }
+}
+
/* Called after the current line information has been either used with
dwarf2_gen_line_info or saved with a machine instruction for later use.
This resets the state of the line number information to reflect that
| DWARF2_FLAG_PROLOGUE_END
| DWARF2_FLAG_EPILOGUE_BEGIN);
current.discriminator = 0;
+ current.view = NULL;
}
/* Called for each (preferably code) label. If dwarf2_loc_mark_labels
return;
if (S_GET_SEGMENT (label) != now_seg)
return;
- if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
+ if (!(bfd_section_flags (now_seg) & SEC_CODE))
return;
if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
return;
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;
if (dir >= dirs_allocated)
{
dirs_allocated = dir + 32;
- dirs = (char **)
- xrealloc (dirs, (dir + 32) * sizeof (const char *));
+ dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
}
- dirs[dir] = xmalloc (dir_len + 1);
- memcpy (dirs[dir], filename, dir_len);
- dirs[dir][dir_len] = '\0';
+ dirs[dir] = xmemdup0 (filename, dir_len);
dirs_in_use = dir + 1;
}
}
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;
unsigned int old = files_allocated;
files_allocated = i + 32;
- files = (struct file_entry *)
- xrealloc (files, (i + 32) * sizeof (struct file_entry));
+ /* Catch wraparound. */
+ if (files_allocated <= old)
+ {
+ as_bad (_("file number %lu is too big"), (unsigned long) i);
+ return 0;
+ }
+ files = XRESIZEVEC (struct file_entry, files, files_allocated);
memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
}
- files[i].filename = num ? file : xstrdup (file);
+ files[i].filename = file;
files[i].dir = dir;
if (files_in_use < i + 1)
files_in_use = i + 1;
- Pass .file "source.c" to s_app_file
- Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
- If an entry is added to the file table, return a pointer to the filename. */
+ If an entry is added to the file table, return a pointer to the filename. */
char *
-dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
+dwarf2_directive_filename (void)
{
- offsetT num;
+ valueT num;
char *filename;
int filename_len;
return NULL;
demand_empty_rest_of_line ();
- if (num < 1)
+ if ((offsetT) num < 1)
{
as_bad (_("file number less than one"));
return NULL;
being supplied. Turn off gas generated debug info. */
debug_type = DEBUG_NONE;
- if (num < (int) files_in_use && files[num].filename != 0)
+ if (num != (unsigned int) num
+ || num >= (size_t) -1 / sizeof (struct file_entry) - 32)
+ {
+ as_bad (_("file number %lu is too big"), (unsigned long) num);
+ return NULL;
+ }
+ if (num < files_in_use && files[num].filename != 0)
{
- as_bad (_("file number %ld already allocated"), (long) num);
+ as_bad (_("file number %u already allocated"), (unsigned int) num);
return NULL;
}
- get_filenum (filename, num);
+ get_filenum (filename, (unsigned int) num);
return filename;
}
+/* Calls dwarf2_directive_filename, but discards its result.
+ Used in pseudo-op tables where the function result is ignored. */
+
+void
+dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
+{
+ (void) dwarf2_directive_filename ();
+}
+
void
dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
{
{
size_t dir_len = strlen (dirs[files[filenum].dir]);
size_t file_len = strlen (files[filenum].filename);
- char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
+ char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1);
memcpy (cp, dirs[files[filenum].dir], dir_len);
INSERT_DIR_SEPARATOR (cp, dir_len);
memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
cp[dir_len + file_len + 1] = '\0';
listing_source_file (cp);
+ free (cp);
}
else
listing_source_file (files[filenum].filename);
char *p, c;
offsetT value;
- p = input_line_pointer;
- c = get_symbol_end ();
+ c = get_symbol_name (& p);
if (strcmp (p, "basic_block") == 0)
{
}
else if (strcmp (p, "is_stmt") == 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
value = get_absolute_expression ();
if (value == 0)
current.flags &= ~DWARF2_FLAG_IS_STMT;
}
else if (strcmp (p, "isa") == 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
value = get_absolute_expression ();
if (value >= 0)
current.isa = value;
}
else if (strcmp (p, "discriminator") == 0)
{
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
value = get_absolute_expression ();
if (value >= 0)
current.discriminator = value;
return;
}
}
+ else if (strcmp (p, "view") == 0)
+ {
+ symbolS *sym;
+
+ (void) restore_line_pointer (c);
+ SKIP_WHITESPACE ();
+
+ if (ISDIGIT (*input_line_pointer)
+ || *input_line_pointer == '-')
+ {
+ bfd_boolean force_reset = *input_line_pointer == '-';
+
+ value = get_absolute_expression ();
+ if (value != 0)
+ {
+ as_bad (_("numeric view can only be asserted to zero"));
+ return;
+ }
+ if (force_reset && force_reset_view)
+ sym = force_reset_view;
+ else
+ {
+ sym = symbol_temp_new (absolute_section, value,
+ &zero_address_frag);
+ if (force_reset)
+ force_reset_view = sym;
+ }
+ }
+ else
+ {
+ char *name = read_symbol_name ();
+
+ if (!name)
+ return;
+ sym = symbol_find_or_make (name);
+ if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
+ {
+ if (S_IS_VOLATILE (sym))
+ sym = symbol_clone (sym, 1);
+ else if (!S_CAN_BE_REDEFINED (sym))
+ {
+ as_bad (_("symbol `%s' is already defined"), name);
+ return;
+ }
+ }
+ S_SET_SEGMENT (sym, undefined_section);
+ S_SET_VALUE (sym, 0);
+ symbol_set_frag (sym, &zero_address_frag);
+ }
+ current.view = sym;
+ }
else
{
as_bad (_("unknown .loc sub-directive `%s'"), p);
- *input_line_pointer = c;
+ (void) restore_line_pointer (c);
return;
}
- SKIP_WHITESPACE ();
+ SKIP_WHITESPACE_AFTER_NAME ();
}
demand_empty_rest_of_line ();
dwarf2_loc_directive_seen = TRUE;
debug_type = DEBUG_NONE;
+
+ /* If we were given a view id, emit the row right away. */
+ if (current.view)
+ dwarf2_emit_insn (0);
}
void
static void
out_set_addr (symbolS *sym)
{
- expressionS expr;
+ expressionS exp;
+ memset (&exp, 0, sizeof 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.
{
if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
len = 1;
- else
+ else if (addr_delta)
len = 1 + sizeof_leb128 (addr_delta, 0);
return len + 3;
}
{
if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
*p++ = DW_LNS_const_add_pc;
- else
+ else if (addr_delta)
{
*p++ = DW_LNS_advance_pc;
p += output_leb128 (p, addr_delta, 0);
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;
- segT line_seg;
+ expressionS *pexp;
char *end = p + len;
/* Line number sequences cannot go backward in addresses. This means
we've incorrectly ordered the statements in the sequence. */
gas_assert ((offsetT) addr_delta >= 0);
+ /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
+ gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
+
/* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
if (line_delta != INT_MAX)
{
p += output_leb128 (p, line_delta, 1);
}
- exp = symbol_get_value_expression (frag->fr_symbol);
- line_seg = subseg_get (".debug_line", 0);
+ pexp = symbol_get_value_expression (frag->fr_symbol);
/* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
advance the address by at most 64K. Linker relaxation (without
which this function would not be used) could change the operand by
an unknown amount. If the address increment is getting close to
the limit, just reset the address. */
- if (addr_delta > 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;
+ memset (&exp, 0, sizeof 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;
- expr.X_op = O_symbol;
- expr.X_add_symbol = to_sym;
- expr.X_add_number = 0;
- subseg_change (line_seg, 0);
- emit_expr_fix (&expr, sizeof_address, frag, p);
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = to_sym;
+ exp.X_add_number = 0;
+ emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE);
p += sizeof_address;
}
else
{
*p++ = DW_LNS_fixed_advance_pc;
- subseg_change (line_seg, 0);
- emit_expr_fix (exp, 2, frag, p);
+ emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE);
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;
+ memset (&exp, 0, sizeof exp);
+ 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 between 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
symbolS *last_lab = NULL, *lab;
struct line_entry *next;
+ if (flag_dwarf_sections)
+ {
+ char * name;
+ const char * sec_name;
+
+ /* Switch to the relevant sub-section before we start to emit
+ the line number table.
+
+ FIXME: These sub-sections do not have a normal Line Number
+ Program Header, thus strictly speaking they are not valid
+ DWARF sections. Unfortunately the DWARF standard assumes
+ a one-to-one relationship between compilation units and
+ line number tables. Thus we have to have a .debug_line
+ section, as well as our sub-sections, and we have to ensure
+ that all of the sub-sections are merged into a proper
+ .debug_line section before a debugger sees them. */
+
+ sec_name = bfd_section_name (seg);
+ if (strcmp (sec_name, ".text") != 0)
+ {
+ name = concat (".debug_line", sec_name, (char *) NULL);
+ subseg_set (subseg_get (name, FALSE), 0);
+ }
+ else
+ /* Don't create a .debug_line.text section -
+ that is redundant. Instead just switch back to the
+ normal .debug_line section. */
+ subseg_set (subseg_get (".debug_line", FALSE), 0);
+ }
+
do
{
int line_delta;
frag = symbol_get_frag (lab);
frag_ofs = S_GET_VALUE (lab);
- if (last_frag == NULL)
+ if (last_frag == NULL
+ || (e->loc.view == force_reset_view && force_reset_view
+ /* If we're going to reset the view, but we know we're
+ advancing the PC, we don't have to force with
+ set_address. We know we do when we're at the same
+ address of the same frag, and we know we might when
+ we're in the beginning of a frag, and we were at the
+ end of the previous frag. */
+ && (frag == last_frag
+ ? (last_frag_ofs == frag_ofs)
+ : (frag_ofs == 0
+ && ((offsetT)last_frag_ofs
+ >= get_frag_fix (last_frag, seg))))))
{
out_set_addr (lab);
out_inc_line_addr (line_delta, 0);
out_uleb128 (files[i].dir); /* directory number */
/* Output the last modification timestamp. */
out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
- files[i].dir ? dirs [files [i].dir] : ""));
+ 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] : ""));
+ files[i].dir ? dirs [files [i].dir] : ""));
}
/* Terminate filename list. */
/* 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. */
+ to the end of the section. EXPR->X_add_number will be set to the
+ negative size of the header. */
static int
-out_header (asection *sec, expressionS *expr)
+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 ();
+
+ if (flag_dwarf_sections)
+ {
+ /* If we are going to put the start and end symbols in different
+ sections, then we need real symbols, not just fake, local ones. */
+ frag_now_fix ();
+ start_sym = symbol_make (".Ldebug_line_start");
+ end_sym = symbol_make (".Ldebug_line_end");
+ symbol_set_value_now (start_sym);
+ }
+ else
+ {
+ start_sym = symbol_temp_new_now_octets ();
+ 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;
- symbolS *prologue_end;
+ expressionS exp;
+ symbolS *prologue_start, *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;
+ memset (&exp, 0, sizeof exp);
+ 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_start = symbol_temp_make ();
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_op = O_subtract;
+ exp.X_add_symbol = prologue_end;
+ exp.X_op_symbol = prologue_start;
+ exp.X_add_number = 0;
+ emit_expr (&exp, sizeof_offset);
+ symbol_set_value_now (prologue_start);
/* Parameters of the state machine. */
out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
/* For each section, emit a statement program. */
for (s = all_segs; s; s = s->next)
- process_entries (s->seg, s->head->head);
+ if (SEG_NORMAL (s->seg))
+ process_entries (s->seg, s->head->head);
+ else
+ as_warn ("dwarf line number information for %s ignored",
+ segment_name (s->seg));
+
+ if (flag_dwarf_sections)
+ /* We have to switch to the special .debug_line_end section
+ before emitting the end-of-debug_line symbol. The linker
+ script arranges for this section to be placed after all the
+ (potentially garbage collected) .debug_line.<foo> sections.
+ This section contains the line_end symbol which is used to
+ compute the size of the linked .debug_line section, as seen
+ in the DWARF Line Number header. */
+ subseg_set (subseg_get (".debug_line_end", FALSE), 0);
symbol_set_value_now (line_end);
}
{
unsigned int addr_size = sizeof_address;
struct line_seg *s;
- expressionS expr;
+ expressionS exp;
unsigned int i;
+ memset (&exp, 0, sizeof exp);
subseg_set (ranges_seg, 0);
/* Base Address Entry. */
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. */
out_debug_aranges (segT aranges_seg, segT info_seg)
{
unsigned int addr_size = sizeof_address;
+ offsetT size;
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;
+ memset (&exp, 0, sizeof exp);
+ sizeof_offset = out_header (aranges_seg, &exp);
+ aranges_end = exp.X_add_symbol;
+ size = -exp.X_add_number;
/* Version. */
- out_two (2);
+ out_two (DWARF2_ARANGES_VERSION);
+ size += 2;
/* Offset to .debug_info. */
TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
+ size += sizeof_offset;
/* Size of an address (offset portion). */
out_byte (addr_size);
+ size++;
/* Size of a segment descriptor. */
out_byte (0);
+ size++;
/* Align the header. */
- frag_align (ffs (2 * addr_size) - 1, 0, 0);
+ while ((size++ % (2 * addr_size)) > 0)
+ out_byte (0);
for (s = all_segs; s; s = s->next)
{
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
{
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);
+ out_abbrev (DW_AT_name, DW_FORM_strp);
+ out_abbrev (DW_AT_comp_dir, DW_FORM_strp);
+ out_abbrev (DW_AT_producer, DW_FORM_strp);
out_abbrev (DW_AT_language, DW_FORM_data2);
out_abbrev (0, 0);
/* Emit a description of this compilation unit for .debug_info. */
static void
-out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
+out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg,
+ symbolS *name_sym, symbolS *comp_dir_sym, symbolS *producer_sym)
{
- 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;
+ memset (&exp, 0, sizeof exp);
+ 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
{
TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
}
+ /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
+ setup in out_debug_str below. */
+ TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset);
+ TC_DWARF2_EMIT_OFFSET (comp_dir_sym, sizeof_offset);
+ TC_DWARF2_EMIT_OFFSET (producer_sym, sizeof_offset);
+
+ /* DW_AT_language. Yes, this is probably not really MIPS, but the
+ dwarf2 draft has no standard code for assembler. */
+ out_two (DW_LANG_Mips_Assembler);
+
+ symbol_set_value_now (info_end);
+}
+
+/* Emit the three debug strings needed in .debug_str and setup symbols
+ to them for use in out_debug_info. */
+static void
+out_debug_str (segT str_seg, symbolS **name_sym, symbolS **comp_dir_sym,
+ symbolS **producer_sym)
+{
+ char producer[128];
+ const char *comp_dir;
+ const char *dirname;
+ char *p;
+ int len;
+
+ subseg_set (str_seg, 0);
+
/* 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. */
+ *name_sym = symbol_temp_new_now_octets ();
if (files_in_use == 0)
abort ();
if (files[1].dir)
memcpy (p, files[1].filename, len);
/* DW_AT_comp_dir */
+ *comp_dir_sym = symbol_temp_new_now_octets ();
comp_dir = remap_debug_filename (getpwd ());
len = strlen (comp_dir) + 1;
p = frag_more (len);
memcpy (p, comp_dir, len);
/* DW_AT_producer */
+ *producer_sym = symbol_temp_new_now_octets ();
sprintf (producer, "GNU AS %s", VERSION);
len = strlen (producer) + 1;
p = frag_more (len);
memcpy (p, producer, len);
+}
- /* DW_AT_language. Yes, this is probably not really MIPS, but the
- dwarf2 draft has no standard code for assembler. */
- out_two (DW_LANG_Mips_Assembler);
-
- symbol_set_value_now (info_end);
+void
+dwarf2_init (void)
+{
+ last_seg_ptr = &all_segs;
+
+ /* Select the default CIE version to produce here. The global
+ starts with a value of -1 and will be modified to a valid value
+ either by the user providing a command line option, or some
+ targets will select their own default in md_after_parse_args. If
+ we get here and the global still contains -1 then it is up to us
+ to pick a sane default. The default we choose is 1, this is the
+ CIE version gas has produced for a long time, and there seems no
+ reason to change it yet. */
+ if (flag_dwarf_cie_version == -1)
+ flag_dwarf_cie_version = 1;
}
+
/* 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. */
/* Create and switch to the line number section. */
line_seg = subseg_new (".debug_line", 0);
- bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
+ bfd_set_section_flags (line_seg, SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
/* 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;
+
+ /* Reset the initial view of the first subsection of the
+ section. */
+ if (lss->head && lss->head->loc.view)
+ set_or_check_view (lss->head, NULL, NULL);
- while ((ss = ss->next) != NULL)
+ while ((lss = lss->next) != NULL)
{
- *ptail = ss->head;
- ptail = ss->ptail;
+ /* Link the first view of subsequent subsections to the
+ previous view. */
+ if (lss->head && lss->head->loc.view)
+ set_or_check_view (lss->head,
+ !s->head ? NULL : (struct line_entry *)ptail,
+ s->head ? s->head->head : NULL);
+ *ptail = lss->head;
+ ptail = lss->ptail;
}
}
out_debug_line (line_seg);
/* If this is assembler generated line info, and there is no
- debug_info already, we need .debug_info and .debug_abbrev
- sections as well. */
+ debug_info already, we need .debug_info, .debug_abbrev and
+ .debug_str sections as well. */
if (emit_other_sections)
{
segT abbrev_seg;
segT aranges_seg;
segT ranges_seg;
+ segT str_seg;
+ symbolS *name_sym, *comp_dir_sym, *producer_sym;
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);
-
- bfd_set_section_flags (stdoutput, info_seg,
- SEC_READONLY | SEC_DEBUGGING);
- bfd_set_section_flags (stdoutput, abbrev_seg,
- SEC_READONLY | SEC_DEBUGGING);
- bfd_set_section_flags (stdoutput, aranges_seg,
- SEC_READONLY | SEC_DEBUGGING);
+ str_seg = subseg_new (".debug_str", 0);
+
+ bfd_set_section_flags (info_seg,
+ SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
+ bfd_set_section_flags (abbrev_seg,
+ SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
+ bfd_set_section_flags (aranges_seg,
+ SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
+ bfd_set_section_flags (str_seg,
+ SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS
+ | SEC_MERGE | SEC_STRINGS);
+ str_seg->entsize = 1;
record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
else
{
ranges_seg = subseg_new (".debug_ranges", 0);
- bfd_set_section_flags (stdoutput, ranges_seg,
- SEC_READONLY | SEC_DEBUGGING);
+ bfd_set_section_flags (ranges_seg,
+ SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
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, info_seg, line_seg);
- out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);
+ out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym);
+ out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg,
+ name_sym, comp_dir_sym, producer_sym);
+ }
+}
+
+/* Perform any deferred checks pertaining to debug information. */
+
+void
+dwarf2dbg_final_check (void)
+{
+ /* Perform reset-view checks. Don't evaluate view_assert_failed
+ recursively: it could be very deep. It's a chain of adds, with
+ each chain element pointing to the next in X_add_symbol, and
+ holding the check value in X_op_symbol. */
+ while (view_assert_failed)
+ {
+ expressionS *exp;
+ symbolS *sym;
+ offsetT failed;
+
+ gas_assert (!symbol_resolved_p (view_assert_failed));
+
+ exp = symbol_get_value_expression (view_assert_failed);
+ sym = view_assert_failed;
+
+ /* If view_assert_failed looks like a compound check in the
+ chain, break it up. */
+ if (exp->X_op == O_add && exp->X_add_number == 0 && exp->X_unsigned)
+ {
+ view_assert_failed = exp->X_add_symbol;
+ sym = exp->X_op_symbol;
+ }
+ else
+ view_assert_failed = NULL;
+
+ failed = resolve_symbol_value (sym);
+ if (!symbol_resolved_p (sym) || failed)
+ {
+ as_bad (_("view number mismatch"));
+ break;
+ }
}
}
projects / deliverable / binutils-gdb.git / blobdiff