binutils-gdb/gdb/buildsym-legacy.c

350 lines
8.5 KiB
C
Raw Normal View History

/* Legacy support routines for building symbol tables in GDB's internal format.
Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "buildsym-legacy.h"
Don't include gdbarch.h from defs.h I touched symtab.h and was surprised to see how many files were rebuilt. I looked into it a bit, and found that defs.h includes gdbarch.h, which in turn includes many things. gdbarch.h is only needed by a minority ofthe files in gdb, so this patch removes the include from defs.h and updates the fallout. I did "wc -l" on the files in build/gdb/.deps; this patch reduces the line count from 139935 to 137030; so there are definitely future build-time savings here. Note that while I configured with --enable-targets=all, it's possible that some *-nat.c file needs an update. I could not test all of these. The buildbot caught a few problems along these lines. gdb/ChangeLog 2019-07-10 Tom Tromey <tom@tromey.com> * defs.h: Don't include gdbarch.h. * aarch64-ravenscar-thread.c, aarch64-tdep.c, alpha-bsd-tdep.h, alpha-linux-tdep.c, alpha-mdebug-tdep.c, arch-utils.h, arm-tdep.h, ax-general.c, btrace.c, buildsym-legacy.c, buildsym.h, c-lang.c, cli/cli-decode.h, cli/cli-dump.c, cli/cli-script.h, cli/cli-style.h, coff-pe-read.h, compile/compile-c-support.c, compile/compile-cplus.h, compile/compile-loc2c.c, corefile.c, cp-valprint.c, cris-linux-tdep.c, ctf.c, d-lang.c, d-namespace.c, dcache.c, dicos-tdep.c, dictionary.c, disasm-selftests.c, dummy-frame.c, dummy-frame.h, dwarf2-frame-tailcall.c, dwarf2expr.c, expression.h, f-lang.c, frame-base.c, frame-unwind.c, frv-linux-tdep.c, gdbarch-selftests.c, gdbtypes.h, go-lang.c, hppa-nbsd-tdep.c, hppa-obsd-tdep.c, i386-dicos-tdep.c, i386-tdep.h, ia64-vms-tdep.c, interps.h, language.c, linux-record.c, location.h, m2-lang.c, m32r-linux-tdep.c, mem-break.c, memattr.c, mn10300-linux-tdep.c, nios2-linux-tdep.c, objfiles.h, opencl-lang.c, or1k-linux-tdep.c, p-lang.c, parser-defs.h, ppc-tdep.h, probe.h, python/py-record-btrace.c, record-btrace.c, record.h, regcache-dump.c, regcache.h, riscv-fbsd-tdep.c, riscv-linux-tdep.c, rust-exp.y, sh-linux-tdep.c, sh-nbsd-tdep.c, source-cache.c, sparc-nbsd-tdep.c, sparc-obsd-tdep.c, sparc-ravenscar-thread.c, sparc64-fbsd-tdep.c, std-regs.c, target-descriptions.h, target-float.c, tic6x-linux-tdep.c, tilegx-linux-tdep.c, top.c, tracefile.c, trad-frame.c, type-stack.h, ui-style.c, utils.c, utils.h, valarith.c, valprint.c, varobj.c, x86-tdep.c, xml-support.h, xtensa-linux-tdep.c, cli/cli-cmds.h: Update. * s390-linux-nat.c, procfs.c, inf-ptrace.c: Likewise.
2019-06-10 05:21:02 +08:00
#include "symtab.h"
/* The work-in-progress of the compunit we are building.
This is created first, before any subfiles by start_symtab. */
static struct buildsym_compunit *buildsym_compunit;
void
record_debugformat (const char *format)
{
buildsym_compunit->record_debugformat (format);
}
void
record_producer (const char *producer)
{
buildsym_compunit->record_producer (producer);
}
/* See buildsym.h. */
void
set_last_source_file (const char *name)
{
gdb_assert (buildsym_compunit != nullptr || name == nullptr);
if (buildsym_compunit != nullptr)
buildsym_compunit->set_last_source_file (name);
}
/* See buildsym.h. */
const char *
get_last_source_file ()
{
if (buildsym_compunit == nullptr)
return nullptr;
return buildsym_compunit->get_last_source_file ();
}
/* See buildsym.h. */
void
set_last_source_start_addr (CORE_ADDR addr)
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->set_last_source_start_addr (addr);
}
/* See buildsym.h. */
CORE_ADDR
get_last_source_start_addr ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_last_source_start_addr ();
}
/* See buildsym.h. */
struct using_direct **
get_local_using_directives ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_local_using_directives ();
}
/* See buildsym.h. */
void
set_local_using_directives (struct using_direct *new_local)
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->set_local_using_directives (new_local);
}
/* See buildsym.h. */
struct using_direct **
get_global_using_directives ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_global_using_directives ();
}
/* See buildsym.h. */
bool
outermost_context_p ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->outermost_context_p ();
}
/* See buildsym.h. */
struct context_stack *
get_current_context_stack ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_current_context_stack ();
}
/* See buildsym.h. */
int
get_context_stack_depth ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_context_stack_depth ();
}
/* See buildsym.h. */
struct subfile *
get_current_subfile ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_current_subfile ();
}
/* See buildsym.h. */
struct pending **
get_local_symbols ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_local_symbols ();
}
/* See buildsym.h. */
struct pending **
get_file_symbols ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_file_symbols ();
}
/* See buildsym.h. */
struct pending **
get_global_symbols ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->get_global_symbols ();
}
void
start_subfile (const char *name)
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->start_subfile (name);
}
void
patch_subfile_names (struct subfile *subfile, const char *name)
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->patch_subfile_names (subfile, name);
}
void
push_subfile ()
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->push_subfile ();
}
const char *
pop_subfile ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->pop_subfile ();
}
/* Delete the buildsym compunit. */
static void
free_buildsym_compunit (void)
{
if (buildsym_compunit == NULL)
return;
delete buildsym_compunit;
buildsym_compunit = NULL;
}
struct compunit_symtab *
end_symtab (CORE_ADDR end_addr, int section)
{
gdb_assert (buildsym_compunit != nullptr);
struct compunit_symtab *result
= buildsym_compunit->end_symtab (end_addr, section);
free_buildsym_compunit ();
return result;
}
struct context_stack *
push_context (int desc, CORE_ADDR valu)
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->push_context (desc, valu);
}
struct context_stack
pop_context ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->pop_context ();
}
struct block *
finish_block (struct symbol *symbol, struct pending_block *old_blocks,
const struct dynamic_prop *static_link,
CORE_ADDR start, CORE_ADDR end)
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit->finish_block (symbol, old_blocks, static_link,
start, end);
}
void
record_block_range (struct block *block, CORE_ADDR start,
CORE_ADDR end_inclusive)
{
gdb_assert (buildsym_compunit != nullptr);
buildsym_compunit->record_block_range (block, start, end_inclusive);
}
void
record_line (struct subfile *subfile, int line, CORE_ADDR pc)
{
gdb_assert (buildsym_compunit != nullptr);
gdb: Add support for tracking the DWARF line table is-stmt field This commit brings support for the DWARF line table is_stmt field to GDB. The is_stmt field is used by the compiler when a single source line is split into multiple assembler instructions, especially if the assembler instructions are interleaved with instruction from other source lines. The compiler will set the is_stmt flag false from some instructions from the source lines, these instructions are not a good place to insert a breakpoint in order to stop at the source line. Instructions which are marked with the is_stmt flag true are a good place to insert a breakpoint for that source line. Currently GDB ignores all instructions for which is_stmt is false. This is fine in a lot of cases, however, there are some cases where this means the debug experience is not as good as it could be. Consider stopping at a random instruction, currently this instruction will be attributed to the last line table entry before this point for which is_stmt was true - as these are the only line table entries that GDB tracks. This can easily be incorrect in code with even a low level of optimisation. With is_stmt tracking in place, when stopping at a random instruction we now attribute the instruction back to the real source line, even when is_stmt is false for that instruction in the line table. When inserting breakpoints we still select line table entries for which is_stmt is true, so the breakpoint placing behaviour should not change. When stepping though code (at the line level, not the instruction level) we will still stop at instruction where is_stmt is true, I think this is more likely to be the desired behaviour. Instruction stepping is, of course, unchanged, stepping one instruction at a time, but we should now report more accurate line table information with each instruction step. The original motivation for this work was a patch posted by Bernd here: https://sourceware.org/ml/gdb-patches/2019-11/msg00792.html As part of that thread it was suggested that many issues would be resolved if GDB supported line table views, this isn't something I've attempted in this patch, though reading the spec, it seems like this would be a useful feature to support in GDB in the future. The spec is here: http://dwarfstd.org/ShowIssue.php?issue=170427.1 And Bernd gives a brief description of the benefits here: https://sourceware.org/ml/gdb-patches/2020-01/msg00147.html With that all said, I think that there is benefit to having proper is_stmt support regardless of whether we have views support, so I think we should consider getting this in first, and then building view support on top of this. The gdb.cp/step-and-next-inline.exp test is based off a test proposed by Bernd Edlinger in this message: https://sourceware.org/ml/gdb-patches/2019-12/msg00842.html gdb/ChangeLog: * buildsym-legacy.c (record_line): Pass extra parameter to record_line. * buildsym.c (buildsym_compunit::record_line): Take an extra parameter, reduce duplication in the line table, and record the is_stmt flag in the line table. * buildsym.h (buildsym_compunit::record_line): Add extra parameter. * disasm.c (do_mixed_source_and_assembly_deprecated): Ignore non-statement lines. * dwarf2/read.c (dwarf_record_line_1): Add extra parameter, pass this to the symtab builder. (dwarf_finish_line): Pass extra parameter to dwarf_record_line_1. (lnp_state_machine::record_line): Pass a suitable is_stmt flag through to dwarf_record_line_1. * infrun.c (process_event_stop_test): When stepping, don't stop at a non-statement instruction, and only refresh the step info when we land in the middle of a line's range. Also add an extra comment. * jit.c (jit_symtab_line_mapping_add_impl): Initialise is_stmt field. * record-btrace.c (btrace_find_line_range): Only record lines marked as is-statement. * stack.c (frame_show_address): Show the frame address if we are in a non-statement sal. * symmisc.c (dump_symtab_1): Print the is_stmt flag. (maintenance_print_one_line_table): Print a header for the is_stmt column, and include is_stmt information in the output. * symtab.c (find_pc_sect_line): Find lines marked as statements in preference to non-statements. (find_pcs_for_symtab_line): Prefer is-statement entries. (find_line_common): Likewise. * symtab.h (struct linetable_entry): Add is_stmt field. (struct symtab_and_line): Likewise. * xcoffread.c (arrange_linetable): Initialise is_stmt field when arranging the line table. gdb/testsuite/ChangeLog: * gdb.cp/step-and-next-inline.cc: New file. * gdb.cp/step-and-next-inline.exp: New file. * gdb.cp/step-and-next-inline.h: New file. * gdb.dwarf2/dw2-is-stmt.c: New file. * gdb.dwarf2/dw2-is-stmt.exp: New file. * gdb.dwarf2/dw2-is-stmt-2.c: New file. * gdb.dwarf2/dw2-is-stmt-2.exp: New file. * gdb.dwarf2/dw2-ranges-base.exp: Update line table pattern.
2019-12-31 05:04:51 +08:00
/* Assume every line entry is a statement start, that is a good place to
put a breakpoint for that line number. */
buildsym_compunit->record_line (subfile, line, pc, true);
}
/* Start a new symtab for a new source file in OBJFILE. Called, for example,
when a stabs symbol of type N_SO is seen, or when a DWARF
TAG_compile_unit DIE is seen. It indicates the start of data for
one original source file.
NAME is the name of the file (cannot be NULL). COMP_DIR is the
directory in which the file was compiled (or NULL if not known).
START_ADDR is the lowest address of objects in the file (or 0 if
not known). LANGUAGE is the language of the source file, or
language_unknown if not known, in which case it'll be deduced from
the filename. */
struct compunit_symtab *
start_symtab (struct objfile *objfile, const char *name, const char *comp_dir,
CORE_ADDR start_addr, enum language language)
{
/* These should have been reset either by successful completion of building
a symtab, or by the scoped_free_pendings destructor. */
gdb_assert (buildsym_compunit == nullptr);
buildsym_compunit = new struct buildsym_compunit (objfile, name, comp_dir,
language, start_addr);
return buildsym_compunit->get_compunit_symtab ();
}
/* Restart compilation for a symtab.
CUST is the result of end_expandable_symtab.
NAME, START_ADDR are the source file we are resuming with.
This is used when a symtab is built from multiple sources.
The symtab is first built with start_symtab/end_expandable_symtab
and then for each additional piece call restart_symtab/augment_*_symtab.
Note: At the moment there is only augment_type_symtab. */
void
restart_symtab (struct compunit_symtab *cust,
const char *name, CORE_ADDR start_addr)
{
/* These should have been reset either by successful completion of building
a symtab, or by the scoped_free_pendings destructor. */
gdb_assert (buildsym_compunit == nullptr);
buildsym_compunit
= new struct buildsym_compunit (COMPUNIT_OBJFILE (cust),
name,
COMPUNIT_DIRNAME (cust),
compunit_language (cust),
start_addr,
cust);
}
/* See buildsym.h. */
struct compunit_symtab *
buildsym_compunit_symtab (void)
{
gdb_assert (buildsym_compunit != NULL);
return buildsym_compunit->get_compunit_symtab ();
}
/* See buildsym.h. */
struct macro_table *
get_macro_table (void)
{
gdb_assert (buildsym_compunit != NULL);
return buildsym_compunit->get_macro_table ();
}
/* At end of reading syms, or in case of quit, ensure everything
associated with building symtabs is freed.
N.B. This is *not* intended to be used when building psymtabs. Some debug
info readers call this anyway, which is harmless if confusing. */
scoped_free_pendings::~scoped_free_pendings ()
{
free_buildsym_compunit ();
}
/* See buildsym-legacy.h. */
struct buildsym_compunit *
get_buildsym_compunit ()
{
gdb_assert (buildsym_compunit != nullptr);
return buildsym_compunit;
}