/* dwarf2dbg.c - DWARF2 debug support
- Copyright (C) 1999-2019 Free Software Foundation, Inc.
+ Copyright (C) 1999-2020 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
#include "as.h"
#include "safe-ctype.h"
+#include "bignum.h"
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
#ifndef DWARF2_FILE_TIME_NAME
-#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
+#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) -1
#endif
#ifndef DWARF2_FILE_SIZE_NAME
-#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
+#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1
#endif
#ifndef DWARF2_VERSION
-#define DWARF2_VERSION 2
+#define DWARF2_VERSION dwarf_level
#endif
/* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
/* This implementation outputs version 3 .debug_line information. */
#ifndef DWARF2_LINE_VERSION
-#define DWARF2_LINE_VERSION 3
+#define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
#endif
#include "subsegs.h"
/* Flag that indicates the initial value of the is_stmt_start flag. */
#define DWARF2_LINE_DEFAULT_IS_STMT 1
+#ifndef DWARF2_LINE_MAX_OPS_PER_INSN
+#define DWARF2_LINE_MAX_OPS_PER_INSN 1
+#endif
+
/* Given a special op, return the line skip amount. */
#define SPECIAL_LINE(op) \
(((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
static struct line_seg *all_segs;
static struct line_seg **last_seg_ptr;
+#define NUM_MD5_BYTES 16
+
struct file_entry
{
- const char *filename;
- unsigned int dir;
+ const char * filename;
+ unsigned int dir;
+ unsigned char md5[NUM_MD5_BYTES];
};
/* Table of files used by .debug_line. */
static unsigned int files_allocated;
/* Table of directories used by .debug_line. */
-static char **dirs;
-static unsigned int dirs_in_use;
-static unsigned int dirs_allocated;
+static char ** dirs = NULL;
+static unsigned int dirs_in_use = 0;
+static unsigned int dirs_allocated = 0;
/* TRUE when we've seen a .loc directive recently. Used to avoid
doing work when there's nothing to do. */
/* The size of an address on the target. */
static unsigned int sizeof_address;
\f
-static unsigned int get_filenum (const char *, unsigned int);
-
#ifndef TC_DWARF2_EMIT_OFFSET
#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
last_seg_ptr = &s->next;
seg_info (seg)->dwarf2_line_seg = s;
}
+
gas_assert (seg == s->seg);
for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
gas_assert (r == p);
/* Set or check views until we find a defined or absent view. */
do
- set_or_check_view (r, r->next, NULL);
+ {
+ /* 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));
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));
}
lss = get_line_subseg (now_seg, now_subseg, TRUE);
- if (loc->view)
+ /* Subseg heads are chained to previous subsegs in
+ dwarf2_finish. */
+ if (loc->view && lss->head)
set_or_check_view (e,
- !lss->head ? NULL : (struct line_entry *)lss->ptail,
+ (struct line_entry *)lss->ptail,
lss->head);
*lss->ptail = e;
symbolS *sym;
/* Early out for as-yet incomplete location information. */
- if (loc->filenum == 0 || loc->line == 0)
+ if (loc->line == 0)
+ return;
+ if (loc->filenum == 0 && DWARF2_LINE_VERSION < 5)
return;
/* Don't emit sequences of line symbols for the same line when the
dwarf2_gen_line_info_1 (sym, loc);
}
+static const char *
+get_basename (const char * pathname)
+{
+ const char * file;
+
+ file = lbasename (pathname);
+ /* Don't make empty string from / or A: from A:/ . */
+#ifdef HAVE_DOS_BASED_FILE_SYSTEM
+ if (file <= pathname + 3)
+ file = pathname;
+#else
+ if (file == pathname + 1)
+ file = pathname;
+#endif
+ return file;
+}
+
+static unsigned int
+get_directory_table_entry (const char * dirname,
+ size_t dirlen,
+ bfd_boolean can_use_zero)
+{
+ unsigned int d;
+
+ if (dirlen == 0)
+ return 0;
+
+#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
+ if (IS_DIR_SEPARATOR (dirname[dirlen - 1]))
+ {
+ -- dirlen;
+ if (dirlen == 0)
+ return 0;
+ }
+#endif
+
+ for (d = 0; d < dirs_in_use; ++d)
+ {
+ if (dirs[d] != NULL
+ && filename_ncmp (dirname, dirs[d], dirlen) == 0
+ && dirs[d][dirlen] == '\0')
+ return d;
+ }
+
+ if (can_use_zero)
+ {
+ if (dirs == NULL || dirs[0] == NULL)
+ d = 0;
+ }
+ else if (d == 0)
+ d = 1;
+
+ if (d >= dirs_allocated)
+ {
+ unsigned int old = dirs_allocated;
+
+ dirs_allocated = d + 32;
+ dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
+ memset (dirs + old, 0, (dirs_allocated - old) * sizeof (char *));
+ }
+
+ dirs[d] = xmemdup0 (dirname, dirlen);
+ if (dirs_in_use <= d)
+ dirs_in_use = d + 1;
+
+ return d;
+}
+
+/* Get a .debug_line file number for PATHNAME. If there is a
+ directory component to PATHNAME, then this will be stored
+ in the directory table, if it is not already present.
+ Returns the slot number allocated to that filename or -1
+ if there was a problem. */
+
+static signed int
+allocate_filenum (const char * pathname)
+{
+ static signed int last_used = -1, last_used_dir_len = 0;
+ const char *file;
+ size_t dir_len;
+ unsigned int i, dir;
+
+ /* Short circuit the common case of adding the same pathname
+ as last time. */
+ if (last_used != -1)
+ {
+ const char * dirname = NULL;
+
+ if (dirs != NULL)
+ dirname = dirs[files[last_used].dir];
+
+ if (dirname == NULL)
+ {
+ if (filename_cmp (pathname, files[last_used].filename) == 0)
+ return last_used;
+ }
+ else
+ {
+ if (filename_ncmp (pathname, dirname, last_used_dir_len) == 0
+ && IS_DIR_SEPARATOR (pathname [last_used_dir_len])
+ && filename_cmp (pathname + last_used_dir_len + 1,
+ files[last_used].filename) == 0)
+ return last_used;
+ }
+ }
+
+ file = get_basename (pathname);
+ dir_len = file - pathname;
+
+ dir = get_directory_table_entry (pathname, dir_len, FALSE);
+
+ /* Do not use slot-0. That is specificailly reserved for use by
+ the '.file 0 "name"' directive. */
+ for (i = 1; i < files_in_use; ++i)
+ if (files[i].dir == dir
+ && files[i].filename
+ && filename_cmp (file, files[i].filename) == 0)
+ {
+ last_used = i;
+ last_used_dir_len = dir_len;
+ return i;
+ }
+
+ if (i >= files_allocated)
+ {
+ unsigned int old = files_allocated;
+
+ files_allocated = i + 32;
+ /* Catch wraparound. */
+ if (files_allocated <= old)
+ {
+ as_bad (_("file number %lu is too big"), (unsigned long) i);
+ return -1;
+ }
+
+ files = XRESIZEVEC (struct file_entry, files, files_allocated);
+ memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
+ }
+
+ files[i].filename = file;
+ files[i].dir = dir;
+ memset (files[i].md5, 0, NUM_MD5_BYTES);
+
+ if (files_in_use < i + 1)
+ files_in_use = i + 1;
+ last_used = i;
+ last_used_dir_len = dir_len;
+
+ return i;
+}
+
+/* Allocate slot NUM in the .debug_line file table to FILENAME.
+ If DIRNAME is not NULL or there is a directory component to FILENAME
+ then this will be stored in the directory table, if not already present.
+ if WITH_MD5 is TRUE then there is a md5 value in generic_bignum.
+ Returns TRUE if allocation succeeded, FALSE otherwise. */
+
+static bfd_boolean
+allocate_filename_to_slot (const char * dirname,
+ const char * filename,
+ unsigned int num,
+ bfd_boolean with_md5)
+{
+ const char *file;
+ size_t dirlen;
+ unsigned int i, d;
+
+ /* Short circuit the common case of adding the same pathname
+ as last time. */
+ if (num < files_allocated && files[num].filename != NULL)
+ {
+ const char * dir = NULL;
+
+ if (dirs)
+ dir = dirs[files[num].dir];
+
+ if (with_md5
+ && memcmp (generic_bignum, files[num].md5, NUM_MD5_BYTES) != 0)
+ goto fail;
+
+ if (dirname != NULL)
+ {
+ if (dir != NULL && filename_cmp (dir, dirname) != 0)
+ goto fail;
+
+ if (filename_cmp (filename, files[num].filename) != 0)
+ goto fail;
+
+ /* If the filenames match, but the directory table entry was
+ empty, then fill it with the provided directory name. */
+ if (dir == NULL)
+ dirs[files[num].dir] = xmemdup0 (dirname, strlen (dirname));
+
+ return TRUE;
+ }
+ else if (dir != NULL)
+ {
+ dirlen = strlen (dir);
+ if (filename_ncmp (filename, dir, dirlen) == 0
+ && IS_DIR_SEPARATOR (filename [dirlen])
+ && filename_cmp (filename + dirlen + 1, files[num].filename) == 0)
+ return TRUE;
+ }
+ else /* dir == NULL */
+ {
+ file = get_basename (filename);
+ if (filename_cmp (file, files[num].filename) == 0)
+ {
+ if (file > filename)
+ /* The filenames match, but the directory table entry is empty.
+ Fill it with the provided directory name. */
+ dirs[files[num].dir] = xmemdup0 (filename, file - filename);
+ return TRUE;
+ }
+ }
+
+ fail:
+ as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"),
+ num,
+ dir == NULL ? "" : dir,
+ dir == NULL ? "" : "/",
+ files[num].filename,
+ dirname == NULL ? "" : dirname,
+ dirname == NULL ? "" : "/",
+ filename);
+ return FALSE;
+ }
+
+ if (dirname == NULL)
+ {
+ dirname = filename;
+ file = get_basename (filename);
+ dirlen = file - filename;
+ }
+ else
+ {
+ dirlen = strlen (dirname);
+ file = filename;
+ }
+
+ d = get_directory_table_entry (dirname, dirlen, num == 0);
+ i = num;
+
+ if (i >= files_allocated)
+ {
+ unsigned int old = files_allocated;
+
+ files_allocated = i + 32;
+ /* Catch wraparound. */
+ if (files_allocated <= old)
+ {
+ as_bad (_("file number %lu is too big"), (unsigned long) i);
+ return FALSE;
+ }
+
+ files = XRESIZEVEC (struct file_entry, files, files_allocated);
+ memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
+ }
+
+ files[i].filename = file;
+ files[i].dir = d;
+ if (with_md5)
+ {
+ if (target_big_endian)
+ {
+ /* md5's are stored in litte endian format. */
+ unsigned int bits_remaining = NUM_MD5_BYTES * BITS_PER_CHAR;
+ unsigned int byte = NUM_MD5_BYTES;
+ unsigned int bignum_index = 0;
+
+ while (bits_remaining)
+ {
+ unsigned int bignum_bits_remaining = LITTLENUM_NUMBER_OF_BITS;
+ valueT bignum_value = generic_bignum [bignum_index];
+ bignum_index ++;
+
+ while (bignum_bits_remaining)
+ {
+ files[i].md5[--byte] = bignum_value & 0xff;
+ bignum_value >>= 8;
+ bignum_bits_remaining -= 8;
+ bits_remaining -= 8;
+ }
+ }
+ }
+ else
+ {
+ unsigned int bits_remaining = NUM_MD5_BYTES * BITS_PER_CHAR;
+ unsigned int byte = 0;
+ unsigned int bignum_index = 0;
+
+ while (bits_remaining)
+ {
+ unsigned int bignum_bits_remaining = LITTLENUM_NUMBER_OF_BITS;
+ valueT bignum_value = generic_bignum [bignum_index];
+
+ bignum_index ++;
+
+ while (bignum_bits_remaining)
+ {
+ files[i].md5[byte++] = bignum_value & 0xff;
+ bignum_value >>= 8;
+ bignum_bits_remaining -= 8;
+ bits_remaining -= 8;
+ }
+ }
+ }
+ }
+ else
+ memset (files[i].md5, 0, NUM_MD5_BYTES);
+
+ if (files_in_use < i + 1)
+ files_in_use = i + 1;
+
+ return TRUE;
+}
+
/* Returns the current source information. If .file directives have
been encountered, the info for the corresponding source file is
returned. Otherwise, the info for the assembly source file is
memset (line, 0, sizeof (*line));
filename = as_where (&line->line);
- line->filenum = get_filenum (filename, 0);
+ line->filenum = allocate_filenum (filename);
+ /* FIXME: We should check the return value from allocate_filenum. */
line->column = 0;
line->flags = DWARF2_FLAG_IS_STMT;
line->isa = current.isa;
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;
dwarf2_consume_line_info ();
}
-/* Get a .debug_line file number for FILENAME. If NUM is nonzero,
- allocate it on that file table slot, otherwise return the first
- empty one. */
-
-static unsigned int
-get_filenum (const char *filename, unsigned int num)
-{
- static unsigned int last_used, last_used_dir_len;
- const char *file;
- size_t dir_len;
- unsigned int i, dir;
-
- if (num == 0 && last_used)
- {
- if (! files[last_used].dir
- && filename_cmp (filename, files[last_used].filename) == 0)
- return last_used;
- if (files[last_used].dir
- && filename_ncmp (filename, dirs[files[last_used].dir],
- last_used_dir_len) == 0
- && IS_DIR_SEPARATOR (filename [last_used_dir_len])
- && filename_cmp (filename + last_used_dir_len + 1,
- files[last_used].filename) == 0)
- return last_used;
- }
-
- file = lbasename (filename);
- /* Don't make empty string from / or A: from A:/ . */
-#ifdef HAVE_DOS_BASED_FILE_SYSTEM
- if (file <= filename + 3)
- file = filename;
-#else
- if (file == filename + 1)
- file = filename;
-#endif
- dir_len = file - filename;
-
- dir = 0;
- if (dir_len)
- {
-#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
- --dir_len;
-#endif
- for (dir = 1; dir < dirs_in_use; ++dir)
- if (filename_ncmp (filename, dirs[dir], dir_len) == 0
- && dirs[dir][dir_len] == '\0')
- break;
-
- if (dir >= dirs_in_use)
- {
- if (dir >= dirs_allocated)
- {
- dirs_allocated = dir + 32;
- dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
- }
-
- dirs[dir] = xmemdup0 (filename, dir_len);
- dirs_in_use = dir + 1;
- }
- }
-
- if (num == 0)
- {
- for (i = 1; i < files_in_use; ++i)
- if (files[i].dir == dir
- && files[i].filename
- && filename_cmp (file, files[i].filename) == 0)
- {
- last_used = i;
- last_used_dir_len = dir_len;
- return i;
- }
- }
- else
- i = num;
-
- if (i >= files_allocated)
- {
- unsigned int old = files_allocated;
-
- files_allocated = i + 32;
- 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].dir = dir;
- if (files_in_use < i + 1)
- files_in_use = i + 1;
- last_used = i;
- last_used_dir_len = dir_len;
-
- return i;
-}
-
/* Handle two forms of .file directive:
- Pass .file "source.c" to s_app_file
- Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
char *
dwarf2_directive_filename (void)
{
- offsetT num;
+ bfd_boolean with_md5 = TRUE;
+ valueT num;
char *filename;
+ const char * dirname = NULL;
int filename_len;
/* Continue to accept a bare string and pass it off. */
}
num = get_absolute_expression ();
+
+ if ((offsetT) num < 1 && DWARF2_LINE_VERSION < 5)
+ {
+ as_bad (_("file number less than one"));
+ ignore_rest_of_line ();
+ return NULL;
+ }
+
+ /* FIXME: Should we allow ".file <N>\n" as an expression meaning
+ "switch back to the already allocated file <N> as the current
+ file" ? */
+
filename = demand_copy_C_string (&filename_len);
if (filename == NULL)
+ /* demand_copy_C_string will have already generated an error message. */
return NULL;
- demand_empty_rest_of_line ();
- if (num < 1)
+ /* For DWARF-5 support we also accept:
+ .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */
+ if (DWARF2_LINE_VERSION > 4)
{
- as_bad (_("file number less than one"));
- return NULL;
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer == '"')
+ {
+ dirname = filename;
+ filename = demand_copy_C_string (&filename_len);
+ SKIP_WHITESPACE ();
+ }
+
+ if (strncmp (input_line_pointer, "md5", 3) == 0)
+ {
+ input_line_pointer += 3;
+ SKIP_WHITESPACE ();
+
+ expressionS exp;
+ expression_and_evaluate (& exp);
+ if (exp.X_op != O_big)
+ as_bad (_("md5 value too small or not a constant"));
+ else
+ with_md5 = TRUE;
+ }
}
+ demand_empty_rest_of_line ();
+
/* 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)
+ if (num != (unsigned int) num
+ || num >= (size_t) -1 / sizeof (struct file_entry) - 32)
{
- as_bad (_("file number %ld already allocated"), (long) num);
+ as_bad (_("file number %lu is too big"), (unsigned long) num);
return NULL;
}
- get_filenum (filename, num);
+ if (! allocate_filename_to_slot (dirname, filename, (unsigned int) num,
+ with_md5))
+ return NULL;
return filename;
}
if (filenum < 1)
{
- as_bad (_("file number less than one"));
- return;
+ if (filenum != 0 || DWARF2_LINE_VERSION < 5)
+ {
+ as_bad (_("file number less than one"));
+ return;
+ }
}
- if (filenum >= (int) files_in_use || files[filenum].filename == 0)
+
+ if (filenum >= (int) files_in_use || files[filenum].filename == NULL)
{
as_bad (_("unassigned file number %ld"), (long) filenum);
return;
if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
{
if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
- {
+ {
as_bad("unaligned opcodes detected in executable segment");
- printed_this = 1;
- }
+ printed_this = 1;
+ }
*addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
}
}
{
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);
that all of the sub-sections are merged into a proper
.debug_line section before a debugger sees them. */
- sec_name = bfd_get_section_name (stdoutput, seg);
+ sec_name = bfd_section_name (seg);
if (strcmp (sec_name, ".text") != 0)
{
name = concat (".debug_line", sec_name, (char *) NULL);
/* Emit the directory and file tables for .debug_line. */
static void
-out_file_list (void)
+out_dir_and_file_list (void)
{
size_t size;
const char *dir;
char *cp;
unsigned int i;
+ bfd_boolean emit_md5 = FALSE;
+ bfd_boolean emit_timestamps = TRUE;
+ bfd_boolean emit_filesize = TRUE;
+ /* Output the Directory Table. */
+
+ if (DWARF2_LINE_VERSION >= 5)
+ {
+ out_byte (1);
+ out_uleb128 (DW_LNCT_path);
+ /* FIXME: it would be better to store these strings in
+ the .debug_line_str section and reference them here. */
+ out_uleb128 (DW_FORM_string);
+ out_uleb128 (dirs_in_use);
+ }
+
/* Emit directory list. */
+ if (DWARF2_LINE_VERSION >= 5)
+ {
+ if (dirs[0] == NULL)
+ dir = remap_debug_filename (".");
+ else
+ dir = remap_debug_filename (dirs[0]);
+
+ size = strlen (dir) + 1;
+ cp = frag_more (size);
+ memcpy (cp, dir, size);
+ }
for (i = 1; i < dirs_in_use; ++i)
{
dir = remap_debug_filename (dirs[i]);
cp = frag_more (size);
memcpy (cp, dir, size);
}
- /* Terminate it. */
- out_byte ('\0');
- for (i = 1; i < files_in_use; ++i)
+ if (DWARF2_LINE_VERSION < 5)
+ /* Terminate it. */
+ out_byte ('\0');
+
+ /* Output the File Name Table. */
+
+ if (DWARF2_LINE_VERSION >= 5)
+ {
+ unsigned int columns = 4;
+
+ if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL)
+ {
+ emit_timestamps = FALSE;
+ -- columns;
+ }
+
+ if (DWARF2_FILE_SIZE_NAME ("", "") == -1)
+ {
+ emit_filesize = FALSE;
+ -- columns;
+ }
+
+ for (i = 0; i < files_in_use; ++i)
+ if (files[i].md5[0] != 0)
+ break;
+ if (i < files_in_use)
+ {
+ emit_md5 = TRUE;
+ ++ columns;
+ }
+
+ /* The number of format entries to follow. */
+ out_byte (columns);
+
+ /* The format of the file name. */
+ out_uleb128 (DW_LNCT_path);
+ /* FIXME: it would be better to store these strings in
+ the .debug_line_str section and reference them here. */
+ out_uleb128 (DW_FORM_string);
+
+ /* The format of the directory index. */
+ out_uleb128 (DW_LNCT_directory_index);
+ out_uleb128 (DW_FORM_udata);
+
+ if (emit_timestamps)
+ {
+ /* The format of the timestamp. */
+ out_uleb128 (DW_LNCT_timestamp);
+ out_uleb128 (DW_FORM_udata);
+ }
+
+ if (emit_filesize)
+ {
+ /* The format of the file size. */
+ out_uleb128 (DW_LNCT_size);
+ out_uleb128 (DW_FORM_udata);
+ }
+
+ if (emit_md5)
+ {
+ /* The format of the MD5 sum. */
+ out_uleb128 (DW_LNCT_MD5);
+ out_uleb128 (DW_FORM_data16);
+ }
+
+ /* The number of entries in the table. */
+ out_uleb128 (files_in_use);
+ }
+
+ for (i = DWARF2_LINE_VERSION > 4 ? 0 : 1; i < files_in_use; ++i)
{
const char *fullfilename;
if (files[i].filename == NULL)
{
- as_bad (_("unassigned file number %ld"), (long) i);
/* Prevent a crash later, particularly for file 1. */
files[i].filename = "";
- continue;
+ if (DWARF2_LINE_VERSION < 5 || i != 0)
+ {
+ as_bad (_("unassigned file number %ld"), (long) i);
+ continue;
+ }
}
fullfilename = DWARF2_FILE_NAME (files[i].filename,
cp = frag_more (size);
memcpy (cp, fullfilename, size);
- out_uleb128 (files[i].dir); /* directory number */
+ /* Directory number. */
+ out_uleb128 (files[i].dir);
+
/* Output the last modification timestamp. */
- out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
- files[i].dir ? dirs [files [i].dir] : ""));
+ if (emit_timestamps)
+ {
+ offsetT timestamp;
+
+ timestamp = DWARF2_FILE_TIME_NAME (files[i].filename,
+ files[i].dir ? dirs [files [i].dir] : "");
+ if (timestamp == -1)
+ timestamp = 0;
+ out_uleb128 (timestamp);
+ }
+
/* Output the filesize. */
- out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
- files[i].dir ? dirs [files [i].dir] : ""));
+ if (emit_filesize)
+ {
+ offsetT filesize;
+ filesize = DWARF2_FILE_SIZE_NAME (files[i].filename,
+ files[i].dir ? dirs [files [i].dir] : "");
+ if (filesize == -1)
+ filesize = 0;
+ out_uleb128 (filesize);
+ }
+
+ /* Output the md5 sum. */
+ if (emit_md5)
+ {
+ int b;
+
+ for (b = 0; b < NUM_MD5_BYTES; b++)
+ out_byte (files[i].md5[b]);
+ }
}
- /* Terminate filename list. */
- out_byte (0);
+ if (DWARF2_LINE_VERSION < 5)
+ /* Terminate filename list. */
+ out_byte (0);
}
/* Switch to SEC and output a header length field. Return the size of
/* Version. */
out_two (DWARF2_LINE_VERSION);
+ if (DWARF2_LINE_VERSION >= 5)
+ {
+ out_byte (sizeof_address);
+ out_byte (0); /* Segment Selector size. */
+ }
/* Length of the prologue following this length. */
prologue_start = symbol_temp_make ();
prologue_end = symbol_temp_make ();
exp.X_op_symbol = prologue_start;
exp.X_add_number = 0;
emit_expr (&exp, sizeof_offset);
- symbol_set_value_now_octets (prologue_start);
+ symbol_set_value_now (prologue_start);
/* Parameters of the state machine. */
out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
+ if (DWARF2_LINE_VERSION >= 4)
+ out_byte (DWARF2_LINE_MAX_OPS_PER_INSN);
out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
out_byte (DWARF2_LINE_BASE);
out_byte (DWARF2_LINE_RANGE);
out_byte (0); /* DW_LNS_set_prologue_end */
out_byte (0); /* DW_LNS_set_epilogue_begin */
out_byte (1); /* DW_LNS_set_isa */
+ /* We have emitted 12 opcode lengths, so make that this
+ matches up to the opcode base value we have been using. */
+ gas_assert (DWARF2_LINE_OPCODE_BASE == 13);
- out_file_list ();
+ out_dir_and_file_list ();
- symbol_set_value_now_octets (prologue_end);
+ symbol_set_value_now (prologue_end);
/* For each section, emit a statement program. */
for (s = all_segs; s; s = s->next)
in the DWARF Line Number header. */
subseg_set (subseg_get (".debug_line_end", FALSE), 0);
- symbol_set_value_now_octets (line_end);
+ symbol_set_value_now (line_end);
}
static void
md_number_to_chars (p, 0, addr_size);
md_number_to_chars (p + addr_size, 0, addr_size);
- symbol_set_value_now_octets (aranges_end);
+ symbol_set_value_now (aranges_end);
}
/* Emit data for .debug_abbrev. Note that this must be kept in
dwarf2 draft has no standard code for assembler. */
out_two (DW_LANG_Mips_Assembler);
- symbol_set_value_now_octets (info_end);
+ symbol_set_value_now (info_end);
}
/* Emit the three debug strings needed in .debug_str and setup symbols
const char *dirname;
char *p;
int len;
+ int first_file = DWARF2_LINE_VERSION > 4 ? 0 : 1;
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.
+ on the command line, so assume files[first_file] 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 ();
+ *name_sym = symbol_temp_new_now_octets ();
if (files_in_use == 0)
abort ();
- if (files[1].dir)
+ if (files[first_file].dir)
{
- dirname = remap_debug_filename (dirs[files[1].dir]);
+ dirname = remap_debug_filename (dirs[files[first_file].dir]);
len = strlen (dirname);
#ifdef TE_VMS
/* Already has trailing slash. */
INSERT_DIR_SEPARATOR (p, len);
#endif
}
- len = strlen (files[1].filename) + 1;
+ len = strlen (files[first_file].filename) + 1;
p = frag_more (len);
- memcpy (p, files[1].filename, len);
+ memcpy (p, files[first_file].filename, len);
/* DW_AT_comp_dir */
- *comp_dir_sym = symbol_temp_new_now ();
+ *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 ();
+ *producer_sym = symbol_temp_new_now_octets ();
sprintf (producer, "GNU AS %s", VERSION);
len = strlen (producer) + 1;
p = frag_more (len);
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;
}
/* 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 *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 ((lss = lss->next) != NULL)
{
+ /* 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;
}
aranges_seg = subseg_new (".debug_aranges", 0);
str_seg = subseg_new (".debug_str", 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);
- bfd_set_section_flags (stdoutput, str_seg,
- (SEC_READONLY | SEC_DEBUGGING
- | SEC_MERGE | SEC_STRINGS));
+ 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);
}
projects / deliverable / binutils-gdb.git / blobdiff