/* dwarf2dbg.c - DWARF2 debug support
- Copyright (C) 1999-2022 Free Software Foundation, Inc.
+ Copyright (C) 1999-2023 Free Software Foundation, Inc.
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
This file is part of GAS, the GNU Assembler.
.file FILENO "file.c"
.loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
[epilogue_begin] [is_stmt VALUE] [isa VALUE] \
- [discriminator VALUE]
+ [discriminator VALUE] [view VALUE]
*/
#include "as.h"
#define DWARF2_ARANGES_VERSION 2
#endif
-/* This implementation outputs version 3 .debug_line information. */
+/* The .debug_line version is the same as the .debug_info version. */
#ifndef DWARF2_LINE_VERSION
-#define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3)
+#define DWARF2_LINE_VERSION DWARF2_VERSION
#endif
/* The .debug_rnglists has only been in DWARF version 5. */
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(). */
-#define DWARF2_LINE_OPCODE_BASE 13
+#define DWARF2_LINE_OPCODE_BASE (DWARF2_LINE_VERSION == 2 ? 10 : 13)
#ifndef DWARF2_LINE_BASE
/* Minimum line offset in a special line info. opcode. This value
#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
#endif
+#define GAS_ABBREV_COMP_UNIT 1
+#define GAS_ABBREV_SUBPROG 2
+#define GAS_ABBREV_NO_TYPE 3
+
struct line_entry
{
struct line_entry *next;
static unsigned int files_allocated;
/* Table of directories used by .debug_line. */
-static char ** dirs = NULL;
-static unsigned int dirs_in_use = 0;
-static unsigned int dirs_allocated = 0;
+static char ** dirs;
+static unsigned int dirs_in_use;
+static unsigned int dirs_allocated;
/* TRUE when we've seen a .loc directive recently. Used to avoid
doing work when there's nothing to do. Will be reset by
bool dwarf2_loc_mark_labels;
/* Current location as indicated by the most recent .loc directive. */
-static struct dwarf2_line_info current =
-{
- 1, 1, 0, 0,
- DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
- 0, { NULL }
-};
+static struct dwarf2_line_info current;
/* This symbol is used to recognize view number forced resets in loc
lists. */
/* Record an entry for LOC occurring at OFS within the current fragment. */
+static unsigned int dw2_line;
+static const char *dw2_filename;
+static int label_num;
+
void
dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
{
uses them to determine the end of the prologue. */
if (debug_type == DEBUG_DWARF2)
{
- static unsigned int line = -1;
- static const char *filename = NULL;
-
- if (line == loc->line)
+ if (dw2_line == loc->line)
{
- if (filename == loc->u.filename)
+ if (dw2_filename == loc->u.filename)
return;
- if (filename_cmp (filename, loc->u.filename) == 0)
+ if (filename_cmp (dw2_filename, loc->u.filename) == 0)
{
- filename = loc->u.filename;
+ dw2_filename = loc->u.filename;
return;
}
}
- line = loc->line;
- filename = loc->u.filename;
+ dw2_line = loc->line;
+ dw2_filename = loc->u.filename;
}
if (linkrelax)
{
- static int label_num = 0;
char name[32];
/* Use a non-fake name for the line number location,
}
static bool
-assign_file_to_slot (unsigned long i, const char *file, unsigned int dir)
+assign_file_to_slot (unsigned int i, const char *file, unsigned int dir)
{
if (i >= files_allocated)
{
- unsigned int old = files_allocated;
+ unsigned int want = i + 32;
- files_allocated = i + 32;
/* Catch wraparound. */
- if (files_allocated <= old)
+ if (want < files_allocated
+ || want < i
+ || want > UINT_MAX / sizeof (struct file_entry))
{
- as_bad (_("file number %lu is too big"), (unsigned long) i);
+ as_bad (_("file number %u is too big"), i);
return false;
}
- files = XRESIZEVEC (struct file_entry, files, files_allocated);
- memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
+ files = XRESIZEVEC (struct file_entry, files, want);
+ memset (files + files_allocated, 0,
+ (want - files_allocated) * sizeof (struct file_entry));
+ files_allocated = want;
}
files[i].filename = file;
Returns the slot number allocated to that filename or -1
if there was a problem. */
+static int last_used;
+static int last_used_dir_len;
+
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;
}
/* Remove any generated line entries. These don't live comfortably
- with compiler generated line info. */
+ with compiler generated line info. If THELOT then remove
+ everything, freeing all list entries we have created. */
static void
-purge_generated_debug (void)
+purge_generated_debug (bool thelot)
{
- struct line_seg *s;
+ struct line_seg *s, *nexts;
- for (s = all_segs; s; s = s->next)
+ for (s = all_segs; s; s = nexts)
{
- struct line_subseg *lss;
+ struct line_subseg *lss, *nextlss;
- for (lss = s->head; lss; lss = lss->next)
+ for (lss = s->head; lss; lss = nextlss)
{
struct line_entry *e, *next;
for (e = lss->head; e; e = next)
{
- know (e->loc.filenum == -1u);
+ if (!thelot)
+ know (e->loc.filenum == -1u);
next = e->next;
free (e);
}
lss->head = NULL;
lss->ptail = &lss->head;
lss->pmove_tail = &lss->head;
+ nextlss = lss->next;
+ if (thelot)
+ free (lss);
+ }
+ nexts = s->next;
+ if (thelot)
+ {
+ seg_info (s->seg)->dwarf2_line_seg = NULL;
+ free (s);
}
}
}
}
/* Handle two forms of .file directive:
- - Pass .file "source.c" to s_app_file
+ - Pass .file "source.c" to s_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. */
SKIP_WHITESPACE ();
if (*input_line_pointer == '"')
{
- s_app_file (0);
+ s_file (0);
return NULL;
}
{
dirname = filename;
filename = demand_copy_C_string (&filename_len);
+ if (filename == NULL)
+ return NULL;
SKIP_WHITESPACE ();
}
/* A .file directive implies compiler generated debug information is
being supplied. Turn off gas generated debug info. */
if (debug_type == DEBUG_DWARF2)
- purge_generated_debug ();
+ purge_generated_debug (false);
debug_type = DEBUG_NONE;
if (num != (unsigned int) num
}
else if (strcmp (p, "prologue_end") == 0)
{
+ if (dwarf_level < 3)
+ dwarf_level = 3;
current.flags |= DWARF2_FLAG_PROLOGUE_END;
*input_line_pointer = c;
}
else if (strcmp (p, "epilogue_begin") == 0)
{
+ if (dwarf_level < 3)
+ dwarf_level = 3;
current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
*input_line_pointer = c;
}
}
else if (strcmp (p, "isa") == 0)
{
+ if (dwarf_level < 3)
+ dwarf_level = 3;
(void) restore_line_pointer (c);
value = get_absolute_expression ();
if (value >= 0)
if (!name)
return;
sym = symbol_find_or_make (name);
+ free (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);
+ as_bad (_("symbol `%s' is already defined"),
+ S_GET_NAME (sym));
return;
}
}
emit_expr (&exp, sizeof_address);
}
-static void scale_addr_delta (addressT *);
-
static void
-scale_addr_delta (addressT *addr_delta)
+scale_addr_delta (int line_delta, addressT *addr_delta)
{
static int printed_this = 0;
if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
{
- if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
+ /* Don't error on non-instruction bytes at end of section. */
+ if (line_delta != INT_MAX
+ && *addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
{
as_bad("unaligned opcodes detected in executable segment");
printed_this = 1;
int len = 0;
/* Scale the address delta by the minimum instruction length. */
- scale_addr_delta (&addr_delta);
+ scale_addr_delta (line_delta, &addr_delta);
/* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
We cannot use special opcodes here, since we want the end_sequence
tmp += DWARF2_LINE_OPCODE_BASE;
/* Avoid overflow when addr_delta is large. */
- if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
+ if (addr_delta < 256U + MAX_SPECIAL_ADDR_DELTA)
{
/* Try using a special opcode. */
opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
gas_assert ((offsetT) addr_delta >= 0);
/* Scale the address delta by the minimum instruction length. */
- scale_addr_delta (&addr_delta);
+ scale_addr_delta (line_delta, &addr_delta);
/* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
We cannot use special opcodes here, since we want the end_sequence
tmp += DWARF2_LINE_OPCODE_BASE;
/* Avoid overflow when addr_delta is large. */
- if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
+ if (addr_delta < 256U + MAX_SPECIAL_ADDR_DELTA)
{
/* Try using a special opcode. */
opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
fragS *last_frag = NULL, *frag;
addressT last_frag_ofs = 0, frag_ofs;
symbolS *last_lab = NULL, *lab;
- struct line_entry *next;
if (flag_dwarf_sections)
{
last_frag = frag;
last_frag_ofs = frag_ofs;
- next = e->next;
- free (e);
- e = next;
+ e = e->next;
}
while (e);
out_dir_and_file_list (segT line_seg, int sizeof_offset)
{
size_t size;
- const char *dir;
+ char *dir;
char *cp;
unsigned int i, j;
bool emit_md5 = false;
bool emit_timestamps = true;
bool emit_filesize = true;
segT line_str_seg = NULL;
- symbolS *line_strp;
+ symbolS *line_strp, *file0_strp = NULL;
/* Output the Directory Table. */
if (DWARF2_LINE_VERSION >= 5)
line_str_seg->entsize = 1;
/* DWARF5 uses slot zero, but that is only set explicitly
- using a .file 0 directive. If that isn't used, but dir
- one is used, then use that as main file directory.
- Otherwise use pwd as main file directory. */
- if (dirs_in_use > 0 && dirs != NULL && dirs[0] != NULL)
+ using a .file 0 directive. Otherwise use pwd as main file
+ directory. */
+ if (dirs_in_use > 0 && dirs[0] != NULL)
dir = remap_debug_filename (dirs[0]);
- else if (dirs_in_use > 1
- && dirs != NULL
- && dirs[1] != NULL
- /* DWARF-5 directory tables expect dir[0] to be the same as
- DW_AT_comp_dir, which is the same as pwd. */
- && dwarf_level < 5)
- dir = remap_debug_filename (dirs[1]);
else
dir = remap_debug_filename (getpwd ());
line_strp = add_line_strp (line_str_seg, dir);
+ free (dir);
subseg_set (line_seg, 0);
TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset);
}
subseg_set (line_seg, 0);
TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset);
}
+ free (dir);
}
if (DWARF2_LINE_VERSION < 5)
if (files[i].filename == NULL)
{
- /* Prevent a crash later, particularly for file 1. DWARF5
- uses slot zero, but that is only set explicitly using a
- .file 0 directive. If that isn't used, but file 1 is,
- then use that as main file name. */
- if (DWARF2_LINE_VERSION >= 5 && i == 0 && files_in_use >= 1 && files[0].filename == NULL)
+ if (DWARF2_LINE_VERSION < 5 || i != 0)
+ {
+ as_bad (_("unassigned file number %ld"), (long) i);
+ continue;
+ }
+ /* DWARF5 uses slot zero, but that is only set explicitly using
+ a .file 0 directive. If that isn't used, but file 1 is, then
+ use that as main file name. */
+ if (files_in_use > 1 && files[1].filename != NULL)
{
files[0].filename = files[1].filename;
files[0].dir = files[1].dir;
files[0].md5[j] = files[1].md5[j];
}
else
- files[i].filename = "";
- if (DWARF2_LINE_VERSION < 5 || i != 0)
- {
- as_bad (_("unassigned file number %ld"), (long) i);
- continue;
- }
+ files[0].filename = "";
}
fullfilename = DWARF2_FILE_NAME (files[i].filename,
}
else
{
- line_strp = add_line_strp (line_str_seg, fullfilename);
+ if (!file0_strp)
+ line_strp = add_line_strp (line_str_seg, fullfilename);
+ else
+ line_strp = file0_strp;
subseg_set (line_seg, 0);
TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset);
+ if (i == 0 && files_in_use > 1
+ && files[0].filename == files[1].filename)
+ file0_strp = line_strp;
+ else
+ file0_strp = NULL;
}
/* Directory number. */
out_byte (0); /* DW_LNS_set_basic_block */
out_byte (0); /* DW_LNS_const_add_pc */
out_byte (1); /* DW_LNS_fixed_advance_pc */
- 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);
+ if (DWARF2_LINE_VERSION >= 3)
+ {
+ 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);
+ }
+ else
+ gas_assert (DWARF2_LINE_OPCODE_BASE == 10);
out_dir_and_file_list (line_seg, sizeof_offset);
static void
out_debug_abbrev (segT abbrev_seg,
segT info_seg ATTRIBUTE_UNUSED,
- segT line_seg ATTRIBUTE_UNUSED)
+ segT line_seg ATTRIBUTE_UNUSED,
+ unsigned char *func_formP)
{
int secoff_form;
+ bool have_efunc = false, have_lfunc = false;
+
+ /* Check the symbol table for function symbols which also have their size
+ specified. */
+ if (symbol_rootP)
+ {
+ symbolS *symp;
+
+ for (symp = symbol_rootP; symp; symp = symbol_next (symp))
+ {
+ /* A warning construct is a warning symbol followed by the
+ symbol warned about. Skip this and the following symbol. */
+ if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
+ {
+ symp = symbol_next (symp);
+ if (!symp)
+ break;
+ continue;
+ }
+
+ if (!S_IS_DEFINED (symp) || !S_IS_FUNCTION (symp))
+ continue;
+
+#if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
+ if (S_GET_SIZE (symp) == 0)
+ {
+ if (!IS_ELF || symbol_get_obj (symp)->size == NULL)
+ continue;
+ }
+#else
+ continue;
+#endif
+
+ if (S_IS_EXTERNAL (symp))
+ have_efunc = true;
+ else
+ have_lfunc = true;
+ }
+ }
+
subseg_set (abbrev_seg, 0);
- out_uleb128 (1);
+ out_uleb128 (GAS_ABBREV_COMP_UNIT);
out_uleb128 (DW_TAG_compile_unit);
- out_byte (DW_CHILDREN_no);
+ out_byte (have_efunc || have_lfunc ? DW_CHILDREN_yes : DW_CHILDREN_no);
if (DWARF2_VERSION < 4)
{
if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
out_abbrev (DW_AT_language, DW_FORM_data2);
out_abbrev (0, 0);
+ if (have_efunc || have_lfunc)
+ {
+ out_uleb128 (GAS_ABBREV_SUBPROG);
+ out_uleb128 (DW_TAG_subprogram);
+ out_byte (DW_CHILDREN_no);
+ out_abbrev (DW_AT_name, DW_FORM_strp);
+ if (have_efunc)
+ {
+ if (have_lfunc || DWARF2_VERSION < 4)
+ *func_formP = DW_FORM_flag;
+ else
+ *func_formP = DW_FORM_flag_present;
+ out_abbrev (DW_AT_external, *func_formP);
+ }
+ else
+ /* Any non-zero value other than DW_FORM_flag will do. */
+ *func_formP = DW_FORM_block;
+
+ /* PR 29517: Provide a return type for the function. */
+ if (DWARF2_VERSION > 2)
+ out_abbrev (DW_AT_type, DW_FORM_ref_udata);
+
+ out_abbrev (DW_AT_low_pc, DW_FORM_addr);
+ out_abbrev (DW_AT_high_pc,
+ DWARF2_VERSION < 4 ? DW_FORM_addr : DW_FORM_udata);
+ out_abbrev (0, 0);
+
+ if (DWARF2_VERSION > 2)
+ {
+ /* PR 29517: We do not actually know the return type of these
+ functions, so provide an abbrev that uses DWARF's unspecified
+ type. */
+ out_uleb128 (GAS_ABBREV_NO_TYPE);
+ out_uleb128 (DW_TAG_unspecified_type);
+ out_byte (DW_CHILDREN_no);
+ out_abbrev (0, 0);
+ }
+ }
+
/* Terminate the abbreviations for this compilation unit. */
out_byte (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,
+out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT str_seg,
symbolS *ranges_sym, symbolS *name_sym,
- symbolS *comp_dir_sym, symbolS *producer_sym)
+ symbolS *comp_dir_sym, symbolS *producer_sym,
+ unsigned char func_form)
{
expressionS exp;
symbolS *info_end;
}
/* DW_TAG_compile_unit DIE abbrev */
- out_uleb128 (1);
+ out_uleb128 (GAS_ABBREV_COMP_UNIT);
/* DW_AT_stmt_list */
TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
dwarf2 draft has no standard code for assembler. */
out_two (DW_LANG_Mips_Assembler);
+ if (func_form)
+ {
+ symbolS *symp;
+ symbolS *no_type_tag;
+
+ if (DWARF2_VERSION > 2)
+ no_type_tag = symbol_make (".Ldebug_no_type_tag");
+ else
+ no_type_tag = NULL;
+
+ for (symp = symbol_rootP; symp; symp = symbol_next (symp))
+ {
+ const char *name;
+ size_t len;
+ expressionS size = { .X_op = O_constant };
+
+ /* Skip warning constructs (see above). */
+ if (symbol_get_bfdsym (symp)->flags & BSF_WARNING)
+ {
+ symp = symbol_next (symp);
+ if (!symp)
+ break;
+ continue;
+ }
+
+ if (!S_IS_DEFINED (symp) || !S_IS_FUNCTION (symp))
+ continue;
+
+#if defined (OBJ_ELF) /* || defined (OBJ_MAYBE_ELF) */
+ size.X_add_number = S_GET_SIZE (symp);
+ if (size.X_add_number == 0 && IS_ELF
+ && symbol_get_obj (symp)->size != NULL)
+ {
+ size.X_op = O_add;
+ size.X_op_symbol = make_expr_symbol (symbol_get_obj (symp)->size);
+ }
+#endif
+ if (size.X_op == O_constant && size.X_add_number == 0)
+ continue;
+
+ subseg_set (str_seg, 0);
+ name_sym = symbol_temp_new_now_octets ();
+ name = S_GET_NAME (symp);
+ len = strlen (name) + 1;
+ memcpy (frag_more (len), name, len);
+
+ subseg_set (info_seg, 0);
+
+ /* DW_TAG_subprogram DIE abbrev */
+ out_uleb128 (GAS_ABBREV_SUBPROG);
+
+ /* DW_AT_name */
+ TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset);
+
+ /* DW_AT_external. */
+ if (func_form == DW_FORM_flag)
+ out_byte (S_IS_EXTERNAL (symp));
+
+ /* PR 29517: Let consumers know that we do not have
+ return type information for this function. */
+ if (DWARF2_VERSION > 2)
+ {
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = no_type_tag;
+ exp.X_add_number = 0;
+ emit_leb128_expr (&exp, 0);
+ }
+
+ /* DW_AT_low_pc */
+ exp.X_op = O_symbol;
+ exp.X_add_symbol = symp;
+ exp.X_add_number = 0;
+ emit_expr (&exp, sizeof_address);
+
+ /* DW_AT_high_pc */
+ if (DWARF2_VERSION < 4)
+ {
+ if (size.X_op == O_constant)
+ size.X_op = O_symbol;
+ size.X_add_symbol = symp;
+ emit_expr (&size, sizeof_address);
+ }
+ else if (size.X_op == O_constant)
+ out_uleb128 (size.X_add_number);
+ else
+ emit_leb128_expr (symbol_get_value_expression (size.X_op_symbol), 0);
+ }
+
+ if (DWARF2_VERSION > 2)
+ {
+ /* PR 29517: Generate a DIE for the unspecified type abbrev.
+ We do it here because it cannot be part of the top level DIE. */
+ subseg_set (info_seg, 0);
+ symbol_set_value_now (no_type_tag);
+ out_uleb128 (GAS_ABBREV_NO_TYPE);
+ }
+
+ /* End of children. */
+ out_leb128 (0);
+ }
+
symbol_set_value_now (info_end);
}
symbolS **producer_sym)
{
char producer[128];
- const char *comp_dir;
- const char *dirname;
char *p;
int len;
int first_file = DWARF2_LINE_VERSION > 4 ? 0 : 1;
abort ();
if (files[first_file].dir)
{
- dirname = remap_debug_filename (dirs[files[first_file].dir]);
+ char *dirname = remap_debug_filename (dirs[files[first_file].dir]);
len = strlen (dirname);
#ifdef TE_VMS
/* Already has trailing slash. */
memcpy (p, dirname, len);
INSERT_DIR_SEPARATOR (p, len);
#endif
+ free (dirname);
}
len = strlen (files[first_file].filename) + 1;
p = frag_more (len);
/* DW_AT_comp_dir */
*comp_dir_sym = symbol_temp_new_now_octets ();
- comp_dir = remap_debug_filename (getpwd ());
+ char *comp_dir = remap_debug_filename (getpwd ());
len = strlen (comp_dir) + 1;
p = frag_more (len);
memcpy (p, comp_dir, len);
+ free (comp_dir);
/* DW_AT_producer */
*producer_sym = symbol_temp_new_now_octets ();
void
dwarf2_init (void)
{
+ all_segs = NULL;
last_seg_ptr = &all_segs;
+ files = NULL;
+ files_in_use = 0;
+ files_allocated = 0;
+ dirs = NULL;
+ dirs_in_use = 0;
+ dirs_allocated = 0;
+ dwarf2_loc_directive_seen = false;
+ dwarf2_any_loc_directive_seen = false;
+ dwarf2_loc_mark_labels = false;
+ current.filenum = 1;
+ current.line = 1;
+ current.column = 0;
+ current.isa = 0;
+ current.flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
+ current.discriminator = 0;
+ current.u.view = NULL;
+ force_reset_view = NULL;
+ view_assert_failed = NULL;
+ dw2_line = -1;
+ dw2_filename = NULL;
+ label_num = 0;
+ last_used = -1;
/* Select the default CIE version to produce here. The global
starts with a value of -1 and will be modified to a valid value
flag_dwarf_cie_version = 1;
}
+static void
+dwarf2_cleanup (void)
+{
+ purge_generated_debug (true);
+ free (files);
+ for (unsigned int i = 0; i < dirs_in_use; i++)
+ free (dirs[i]);
+ free (dirs);
+}
+
/* Finish the dwarf2 debug sections. We emit .debug.line if there
were any .file/.loc directives, or --gdwarf2 was given, and if the
file has a non-empty .debug_info section and an 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;
+ {
+ dwarf2_cleanup ();
+ return;
+ }
/* Calculate the size of an address for the target machine. */
sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
!s->head ? NULL : (struct line_entry *)ptail,
s->head ? s->head->head : NULL);
*ptail = lss->head;
+ lss->head = NULL;
ptail = lss->ptail;
}
}
segT aranges_seg;
segT str_seg;
symbolS *name_sym, *comp_dir_sym, *producer_sym, *ranges_sym;
+ unsigned char func_form = 0;
gas_assert (all_segs);
}
out_debug_aranges (aranges_seg, info_seg);
- out_debug_abbrev (abbrev_seg, info_seg, line_seg);
+ out_debug_abbrev (abbrev_seg, info_seg, line_seg, &func_form);
out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym);
- out_debug_info (info_seg, abbrev_seg, line_seg, ranges_sym,
- name_sym, comp_dir_sym, producer_sym);
+ out_debug_info (info_seg, abbrev_seg, line_seg, str_seg,
+ ranges_sym, name_sym, comp_dir_sym, producer_sym,
+ func_form);
}
+ dwarf2_cleanup ();
}
/* Perform any deferred checks pertaining to debug information. */
projects / binutils-gdb.git / blobdiff