Tom Tromey [Sat, 6 Mar 2021 16:26:39 +0000 (09:26 -0700)]
Avoid crash on missing dwz file
If DWARF contains a reference to a "dwz" file, but there is no
.gnu_debugaltlink section, then gdb will crash. This happens because
dwarf2_get_dwz_file will return NULL, but some callers do not expect
this.
This patch changes dwarf2_get_dwz_file so that callers can require a
dwz file. Then, it updates the callers that are attempting to process
references to the dwz file to require one.
This includes a new testcase. The dwarf.exp changes don't handle the
new forms exactly correctly -- they are only handled well enough to
let this test case complete.
gdb/ChangeLog
2021-03-06 Tom Tromey <tom@tromey.com>
* dwarf2/read.h (dwarf2_get_dwz_file): Add 'require' parameter.
* dwarf2/read.c (dwarf2_get_dwz_file): Add 'require' parameter.
(get_abbrev_section_for_cu, read_attribute_value)
(get_debug_line_section): Update.
* dwarf2/macro.c (dwarf_decode_macro_bytes): Update.
gdb/testsuite/ChangeLog
2021-03-06 Tom Tromey <tom@tromey.com>
* lib/dwarf.exp (_handle_DW_FORM): Treat DW_FORM_GNU_ref_alt and
DW_FORM_GNU_strp_alt like DW_FORM_sec_offset.
* gdb.dwarf2/dwznolink.exp: New file.
Tom Tromey [Sat, 6 Mar 2021 16:26:39 +0000 (09:26 -0700)]
Change section_is_p to a method on dwarf2_section_names
This replaces section_is_p with a method on dwarf2_section_names.
gdb/ChangeLog
2021-03-06 Tom Tromey <tom@tromey.com>
* dwarf2/sect-names.h (struct dwarf2_section_names) <matches>: New
method.
* dwarf2/read.c (section_is_p): Remove.
(dwarf2_per_bfd::locate_sections)
(dwarf2_per_bfd::locate_sections, locate_dwz_sections)
(locate_v1_virtual_dwo_sections, dwarf2_locate_dwo_sections)
(dwarf2_locate_common_dwp_sections)
(dwarf2_locate_v2_dwp_sections, dwarf2_locate_v5_dwp_sections):
Update.
Tom Tromey [Sat, 6 Mar 2021 16:26:39 +0000 (09:26 -0700)]
Create new file dwarf2/sect-names.h
This creates a new file, dwarf2/sect-names.h, and moves some
DWARF-specific type definitions from symfile.h into it.
gdb/ChangeLog
2021-03-06 Tom Tromey <tom@tromey.com>
* xcoffread.c: Include sect-names.h.
* symfile.h (struct dwarf2_section_names, struct
dwarf2_debug_sections): Move to dwarf2/sect-names.h.
* dwarf2/sect-names.h: New file, from symfile.h.
* dwarf2/read.c: Include sect-names.h.
Tom Tromey [Sat, 6 Mar 2021 16:16:59 +0000 (09:16 -0700)]
Micro-optimize abbrev reading and storage
Currently, and abbrev_info points to a separately allocated array of
attr_abbrev objects. This array is constructed in a temporary vector,
then copied to the abbrev table's obstack.
This patch changes abbrev_info to use the struct hack to store the
objects directly, and changes abbrev_table::read to avoid an extra
copy when allocating, using the "growing objects" capability of
obstacks.
This saves a bit of space, and also perhaps a little time.
2021-03-06 Tom Tromey <tom@tromey.com>
* dwarf2/read.c (read_attribute): Make 'abbrev' const.
* dwarf2/abbrev.c (abbrev_table::alloc_abbrev): Remove.
(abbrev_table::read): Update.
* dwarf2/abbrev.h (struct attr_abbrev): Move earlier.
(struct abbrev_info): Reformat.
<attrs>: Now an array.
(struct abbrev_table) <alloc_abbrev>: Remove.
H.J. Lu [Sat, 6 Mar 2021 02:24:56 +0000 (18:24 -0800)]
elf/x86-64: Subtract __ImageBase for R_AMD64_IMAGEBASE
When linking Windows x86-64 relocatable object files to generate x86-64
ELF executable, we need to subtract __ImageBase, aka __executable_start,
for R_AMD64_IMAGEBASE relocation:
1. Add link_info to struct output_elf_obj_tdata to store linker info and
_bfd_get_link_info() to retrieve it.
2. Add ldelf_set_output_arch to set up link_info.
3. Add pex64_link_add_symbols to create an indirect reference to
__executable_start for __ImageBase to support R_AMD64_IMAGEBASE relocation
when adding symbols from Windows x86-64 relocatable object files to
generate x86-64 ELF executable.
4. Also subtract __ImageBase for R_AMD64_IMAGEBASE when generating x86-64
ELF executable.
bfd/
PR ld/27425
PR ld/27432
* bfd.c (_bfd_get_link_info): New function.
* elf-bfd.h (output_elf_obj_tdata): Add link_info.
(elf_link_info): New.
* libbfd-in.h (_bfd_get_link_info): New prototype.
* coff-x86_64.c (coff_amd64_reloc): Also subtract __ImageBase for
R_AMD64_IMAGEBASE when generating x86-64 ELF executable.
* pe-x86_64.c: Include "coff/internal.h" and "libcoff.h".
(pex64_link_add_symbols): New function.
(coff_bfd_link_add_symbols): New macro.
* libbfd.h: Regenerated.
ld/
PR ld/27425
PR ld/27432
* ldelf.c (ldelf_set_output_arch): New function.
* ldelf.h (ldelf_set_output_arch): New prototype.
* emultempl/elf.em (LDEMUL_SET_OUTPUT_ARCH): Default to
ldelf_set_output_arch.
* ld-x86-64/pe-x86-64-1.od: Expect __executable_start.
* testsuite/ld-x86-64/pe-x86-64-2.od: Likewise.
* testsuite/ld-x86-64/pe-x86-64-3.od: Likewise.
* testsuite/ld-x86-64/pe-x86-64-4.od: Likewise.
* testsuite/ld-x86-64/pe-x86-64-5.od: Likewise.
* testsuite/ld-x86-64/pe-x86-64-5.rd: Likewise.
* testsuite/ld-x86-64/pe-x86-64-6.obj.bz2: New file.
* testsuite/ld-x86-64/pe-x86-64-6.od: Likewise.
* testsuite/ld-x86-64/pe-x86-64.exp: Run ld/27425 test.
Mark Wielaard [Sat, 6 Mar 2021 00:49:27 +0000 (01:49 +0100)]
Make valgrind tests more robust by adding --wait=1 to vgdb invocation
On my setup some valgrind tests failed somewhat reliably because
the target remote | vgdb command couldn't find the vgdb-pipe files
because valgrind startup hadn't finished yet.
I tried to fix this by replacing the "Memcheck, a memory error detector"
match to "TO DEBUG THIS PROCESS USING GDB: start GDB like this" which is
right before valgrind creates the vgdb-pipe files. But even that didn't
guarantee that the vgdb-pipe files were there (maybe valgrind should
print that text after it has created them?). But also not all tests
use --vgdb-error=0, so the text isn't always printed.
To make the tests reliable I added --wait=1 to the vgdb invocation.
That tells vgdb to try to find the vgdb-pipe files, and if they aren't
there yet, to wait 1 second and try again.
gdb/testsuite/ChangeLog:
* lib/valgrind.exp (vgdb_start): Add --wait=1 to vgdbcmd.
Weimin Pan [Sat, 6 Mar 2021 00:17:00 +0000 (19:17 -0500)]
CTF: add all members of an enum type to psymtab
With the following change which was made last April:
[gdb] Use partial symbol table to find language for main
commit
d3214198119c1a2f9a6a2b8fcc56d8c324e1a245
The ctf reader was modified to enter all members of an enum type,
similar to what the dwarf2 reader did, into the psymtab or gdb
won't be able to find them. In addition, the empty name checking
needed to be moved down so members of a unnamed enum were not left
out.
gdb/ChangeLog:
* ctfread.c (ctf_psymtab_add_enums): New function.
(ctf_psymtab_type_cb): call ctf_psymtab_add_enums.
Weimin Pan [Fri, 5 Mar 2021 23:31:26 +0000 (18:31 -0500)]
CTF: set up debug info for function arguments
Added this support in read_func_kind_type after gcc started generating
CTF for function arguments.
Replaced XNEW with std::vector and NULL with nullptr.
Expanded gdb.base/ctf-ptype.exp to test function arguments. Also fixed
some typos.
gdb/ChangeLog:
* ctfread.c (read_func_kind_type): Set up function arguments.
gdb/testsuite/ChangeLog:
* gdb.base/ctf-ptype.exp: Add function tests and fix typos.
GDB Administrator [Sat, 6 Mar 2021 00:00:16 +0000 (00:00 +0000)]
Automatic date update in version.in
Andrew Burgess [Fri, 27 Nov 2020 14:39:23 +0000 (14:39 +0000)]
gdb/riscv: write CSRs into baremetal core dumps
Use the current target description to include CSRs into the RISC-V
baremetal core dumps.
Every CSR declared in the current target description will be included
in the core dump.
It will be critical for users that they have the same target
description in use when loading the core file as was in use when
writing the core file. This should be fine if the user allows the
target description to be written into the core file.
In more detail, this commit adds a NT_RISCV_CSR note type. The
contents of this section is a series of either 4-byte (on RV32
targets), or 8-byte (on RV64 targets) values. Every CSR that is
mentioned in the current target description is written out in the
order the registers appear in the target description. As a
consequence it is critical that the exact same target description,
including the same register order, is in use when the CSRs are loaded
from the core file.
gdb/ChangeLog:
* riscv-none-tdep.c: Add 'user-regs.h' and 'target-description.h'
includes.
(riscv_csrset): New static global.
(riscv_update_csrmap): New function.
(riscv_iterate_over_regset_sections): Process CSRs.
Andrew Burgess [Mon, 15 Feb 2021 16:07:48 +0000 (16:07 +0000)]
gdb/riscv: make riscv target description names global
A later commit will need the names of the RISC-V target description
features in files other than riscv-tdep.c. This commit just makes the
names global strings that can be accessed from other riscv-*.c files.
There should be no user visible changes after this commit.
gdb/ChangeLog:
* riscv-tdep.c (riscv_feature_name_csr): Define.
(riscv_feature_name_cpu): Define.
(riscv_feature_name_fpu): Define.
(riscv_feature_name_virtual): Define.
(riscv_xreg_feature): Use riscv_feature_name_cpu.
(riscv_freg_feature): Use riscv_feature_name_fpu.
(riscv_virtual_feature): Use riscv_feature_name_virtual.
(riscv_csr_feature): Use riscv_feature_name_csr.
* riscv-tdep.h (riscv_feature_name_csr): Declare.
Andrew Burgess [Fri, 27 Nov 2020 14:04:16 +0000 (14:04 +0000)]
bfd/binutils: add support for RISC-V CSRs in core files
Adds support for including RISC-V control and status registers into
core files.
The value for the define NT_RISCV_CSR is set to 0x900, this
corresponds to a patch I have proposed for the Linux kernel here:
http://lists.infradead.org/pipermail/linux-riscv/2020-December/003910.html
As I have not yet heard if the above patch will be accepted into the
kernel or not I have set the note name string to "GDB", and the note
type to NT_RISCV_CSR.
This means that if the above patch is rejected from the kernel, and
the note type number 0x900 is assigned to some other note type, we
will still be able to distinguish between the GDB produced
NT_RISCV_CSR, and the kernel produced notes, where the name would be
set to "CORE".
bfd/ChangeLog:
* elf-bfd.h (elfcore_write_riscv_csr): Declare.
* elf.c (elfcore_grok_riscv_csr): New function.
(elfcore_grok_note): Handle NT_RISCV_CSR.
(elfcore_write_riscv_csr): New function.
(elfcore_write_register_note): Handle '.reg-riscv-csr'.
binutils/ChangeLog:
* readelf.c (get_note_type): Handle NT_RISCV_CSR.
include/ChangeLog:
* elf/common.h (NT_RISCV_CSR): Define.
Andrew Burgess [Mon, 30 Nov 2020 12:15:08 +0000 (12:15 +0000)]
gdb/riscv: introduce bare metal core dump support
This commit adds the ability for bare metal RISC-V target to generate
core files from within GDB.
The intended use case is that a user will connect to a remote bare
metal target, debug up to some error condition, then generate a core
file in the normal way using:
(gdb) generate-core-file
This core file can then be used to revisit the state of the remote
target without having to reconnect to the remote target.
The core file creation code is split between two new files. In
elf-none-tdep.c is code for any architecture with the none
ABI (i.e. bare metal) when the BFD library is built with ELF support.
In riscv-none-tdep.c are the RISC-V specific parts. This is where the
regset and regcache_map_entry structures are defined that control how
registers are laid out in the core file. As this file could (in
theory at least) be used for a non-ELF bare metal RISC-V target, the
calls into elf-none-tdep.c are guarded with '#ifdef HAVE_ELF'.
Currently for RISC-V only the x-regs and f-regs (if present) are
written out. In future commits I plan to add support for writing out
the RISC-V CSRs.
The core dump format is based around generating an ELF containing
sections for the writable regions of memory that a user could be
using. Which regions are dumped rely on GDB's existing common core
dumping code, GDB will attempt to figure out the stack and heap as
well as copying out writable data sections as identified by the
original ELF.
Register information is added to the core dump using notes, just as it
is for Linux of FreeBSD core dumps. The note types used consist of
the 3 basic types you would expect in a OS based core dump,
NT_PRPSINFO, NT_PRSTATUS, NT_FPREGSET.
The layout of these notes differs slightly (due to field sizes)
between RV32 and RV64. Below I describe the data layout for each
note. In all cases, all padding fields should be set to zero.
Note NT_PRPSINFO is optional. Its data layout is:
struct prpsinfo32_t /* For RV32. */
{
uint8_t padding[32];
char fname[16];
char psargs[80];
}
struct prpsinfo64_t /* For RV64. */
{
uint8_t padding[40];
char fname[16];
char psargs[80];
}
Field 'fname' - null terminated string consisting of the basename of
(up to the fist 15 characters of) the executable. Any additional
space should be set to zero. If there's no executable name then
this field can be set to all zero.
Field 'psargs' - a null terminated string up to 80 characters in
length. Any additional space should be filled with zero. This
field contains the full executable path and any arguments passed
to the executable. If there's nothing sensible to write in this
field then fill it with zero.
Note NT_PRSTATUS is required, its data layout is:
struct prstatus32_t /* For RV32. */
{
uint8_t padding_1[12];
uint16_t sig;
uint8_t padding_2[10];
uint32_t thread_id;
uint8_t padding_3[44];
uint32_t x_regs[32];
uint8_t padding_4[4];
}
struct prstatus64_t /* For RV64. */
{
uint8_t padding_1[12];
uint16_t sig;
uint8_t padding_2[18];
uint32_t thread_id;
uint8_t padding_3[76];
uint64_t x_regs[32];
uint8_t padding_4[4];
}
Field 'sig' - the signal that stopped this thread. It's implementation
defined what this field actually means. Within GDB this will be
the signal number that the remote target reports as the stop
reason for this thread.
Field 'thread_is' - the thread id for this thread. It's implementation
defined what this field actually means. Within GDB this will be
thread thread-id that is assigned to each remote thread.
Field 'x_regs' - at index 0 we store the program counter, and at
indices 1 to 31 we store x-registers 1 to 31. x-register 0 is not
stored, its value is always zero anyway.
Note NT_FPREGSET is optional, its data layout is:
fpregset32_t /* For targets with 'F' extension. */
{
uint32_t f_regs[32];
uint32_t fcsr;
}
fpregset64_t /* For targets with 'D' extension . */
{
uint64_t f_regs[32];
uint32_t fcsr;
}
Field 'f_regs' - stores f-registers 0 to 31.
Field 'fcsr' - stores the fcsr CSR register, and is always 4-bytes.
The rules for ordering the notes is the same as for Linux. The
NT_PRSTATUS note must come before any other notes about additional
register sets. And for multi-threaded targets all registers for a
single thread should be grouped together. This is because only
NT_PRSTATUS includes a thread-id, all additional register notes after
a NT_PRSTATUS are assumed to belong to the same thread until a
different NT_PRSTATUS is seen.
gdb/ChangeLog:
* Makefile.in (ALL_TARGET_OBS): Add riscv-none-tdep.o.
(ALLDEPFILES): Add riscv-none-tdep.c.
* configure: Regenerate.
* configure.ac (CONFIG_OBS): Add elf-none-tdep.o when BFD has ELF
support.
* configure.tgt (riscv*-*-*): Include riscv-none-tdep.c.
* elf-none-tdep.c: New file.
* elf-none-tdep.h: New file.
* riscv-none-tdep.c: New file.
Andrew Burgess [Mon, 30 Nov 2020 12:14:38 +0000 (12:14 +0000)]
bfd/riscv: prepare to handle bare metal core dump creation
When creating a core file GDB will call the function
elfcore_write_prstatus to write out the general purpose registers
along with the pid/tid for the thread (into a prstatus structure) and
the executable name and arguments (into a prpsinfo_t structure).
However, for a bare metal RISC-V tool chain the prstatus_t and
prpsinfo_t types are not defined so the elfcore_write_prstatus
function will return NULL, preventing core file creation.
This commit provides the `elf_backend_write_core_note' hook and uses
the provided function to write out the required information.
In order to keep changes in the non bare metal tools to a minimum, the
provided backend function will itself return NULL when the prstatus_t
or pspsinfo_t types are available, the consequence of this is that the
generic code in elfcore_write_prstatus will be used just as before.
But, when prstatus_t or prpsinfo_t is not available, the new backend
function will write out the information using predefined offsets.
This new functionality will be used by a later GDB commit that will
add bare metal core dumps for RISC-V.
bfd/ChangeLog:
* elfnn-riscv.c (PRPSINFO_PR_FNAME_LENGTH): Define.
(PRPSINFO_PR_PSARGS_LENGTH): Define.
(riscv_write_core_note): New function.
(riscv_elf_grok_psinfo): Make use of two new length defines.
(elf_backend_write_core_note): Define.
Andrew Burgess [Fri, 27 Nov 2020 15:41:52 +0000 (15:41 +0000)]
gdb: write target description into core file
When a core file is created from within GDB add the target description
into a note within the core file.
When loading a core file, if the target description note is present
then load the target description from the core file.
The benefit of this is that we can be sure that, when analysing the
core file within GDB, that we are using the exact same target
description as was in use at the time the core file was created.
GDB already supports a mechanism for figuring out the target
description from a given corefile; gdbarch_core_read_description.
This new mechanism (GDB adding the target description) is not going to
replace the old mechanism. Core files generated outside of GDB will
not include a target description, and so GDB still needs to be able to
figure out a target description for these files.
My primary motivation for adding this feature is that, in a future
commit, I will be adding support for bare metal core dumps on some
targets. For RISC-V specifically, I want to be able to dump all the
available control status registers. As different targets will present
different sets of register in their target description, including
registers that are possibly not otherwise known to GDB I wanted a way
to capture these registers in the core dump.
I therefore need a mechanism to write out an arbitrary set of
registers, and to then derive a target description from this arbitrary
set when later loading the core file. The obvious approach (I think)
is to just reuse the target description.
Once I'd decided to add support for writing out the target description
I could either choose to make this RISC-V only, or make it generic. I
figure that having the target description in the core file doesn't
hurt, and _might_ be helpful. So that's how I got here, general
support for including the target description in GDB generated core
files.
In previous versions of this patch I added the target description from
generic code (in gcore.c). However, doing this creates a dependency
between GDB's common code and bfd ELF support. As ELF support in gdb
is optional (for example the target x86_64-apple-darwin20.3.0 does not
include ELF support) then having gcore.c require ELF support would
break the GDB build in some cases.
Instead, in this version of the patch, writing the target description
note is done from each specific targets make notes function. Each of
these now calls a common function in gcore-elf.c (which is only linked
in when bfd has ELF support). And so only targets that are ELF based
will call the new function and we can therefore avoid an unconditional
dependency on ELF support.
gdb/ChangeLog:
* corelow.c: Add 'xml-tdesc.h' include.
(core_target::read_description): Load the target description from
the core file when possible.
* fbsd-tdep.c (fbsd_make_corefile_notes): Add target description
note.
* gcore-elf.c: Add 'gdbsupport/tdesc.h' include.
(gcore_elf_make_tdesc_note): New function.
* gcore-elf.h (gcore_elf_make_tdesc_note): Declare.
* linux-tdep.c (linux_make_corefile_notes): Add target description
note.
Andrew Burgess [Fri, 27 Nov 2020 15:41:37 +0000 (15:41 +0000)]
bfd/binutils: support for gdb target descriptions in the core file
This commit lays the ground work for allowing GDB to write its target
description into a generated core file.
The goal of this work is to allow a user to connect to a remote
target, capture a core file from within GDB, then pass the executable
and core file to another user and have the user be able to examine the
state of the machine without needing to connect to a running target.
Different remote targets can have different register sets and this
information is communicated from the target to GDB in the target
description.
It is possible for a user to extract the target description from GDB
and pass this along with the core file so that when the core file is
used the target description can be fed back into GDB, however this is
not a great user experience.
It would be nicer, I think, if GDB could write the target description
directly into the core file, and then make use of this description
when loading a core file.
This commit performs the binutils/bfd side of this task, adding the
boiler plate functions to access the target description from within a
core file note, and reserving a new number for a note containing the
target description. Later commits will extend GDB to make use of
this.
The new note is given the name 'GDB' and a type NT_GDB_TDESC. This
should hopefully protect us if there's ever a reuse of the number
assigned to NT_GDB_TDESC by some other core file producer. It should
also, hopefully, make it clearer to users that this note carries GDB
specific information.
bfd/ChangeLog:
* elf-bfd.h (elfcore_write_gdb_tdesc): Declare new function.
* elf.c (elfcore_grok_gdb_tdesc): New function.
(elfcore_grok_note): Handle NT_GDB_TDESC.
(elfcore_write_gdb_tdesc): New function.
(elfcore_write_register_note): Handle NT_GDB_TDESC.
binutils/ChangeLog:
* readelf.c (get_note_type): Handle NT_GDB_TDESC.
include/ChangeLog:
* elf/common.h (NT_GDB_TDESC): Define.
Andrew Burgess [Mon, 18 Jan 2021 16:00:38 +0000 (16:00 +0000)]
gdb: unify parts of the Linux and FreeBSD core dumping code
While reviewing the Linux and FreeBSD core dumping code within GDB for
another patch series, I noticed that the code that collects the
registers for each thread and writes these into ELF note format is
basically identical between Linux and FreeBSD.
This commit merges this code and moves it into a new file gcore-elf.c.
The function find_signalled_thread is moved from linux-tdep.c to
gcore.c despite not being shared. A later commit will make use of
this function.
I did merge, and then revert a previous version of this patch (commit
82a1fd3a4935 for the original patch and
03642b7189bc for the revert).
The problem with the original patch is that it introduced a
unconditional dependency between GDB and some ELF specific functions
in the BFD library, e.g. elfcore_write_prstatus and
elfcore_write_register_note. It was pointed out in this mailing list
post:
https://sourceware.org/pipermail/gdb-patches/2021-February/175750.html
that this change was breaking any build of GDB for non-ELF targets.
To confirm this breakage, and to test this new version of GDB I
configured and built for the target x86_64-apple-darwin20.3.0.
Where the previous version of this patch placed all of the common code
into gcore.c, which is included in all builds of GDB, this new patch
only places non-ELF specific generic code (i.e. find_signalled_thread)
into gcore.c, the ELF specific code is put into the new gcore-elf.c
file, which is only included in GDB if BFD has ELF support.
The contents of gcore-elf.c are referenced unconditionally from
linux-tdep.c and fbsd-tdep.c, this is fine, we previously always
assumed that these two targets required ELF support, and we continue
to make that assumption after this patch; nothing has changed there.
With my previous version of this patch the darwin target mentioned
above failed to build, but with the new version, the target builds
fine.
There are a couple of minor changes to the FreeBSD target after this
commit, but I believe that these are changes for the better:
(1) For FreeBSD we always used to record the thread-id in the core
file by using ptid_t.lwp (). In contrast the Linux code did this:
/* For remote targets the LWP may not be available, so use the TID. */
long lwp = ptid.lwp ();
if (lwp == 0)
lwp = ptid.tid ();
Both target now do this:
/* The LWP is often not available for bare metal target, in which case
use the tid instead. */
if (ptid.lwp_p ())
lwp = ptid.lwp ();
else
lwp = ptid.tid ();
Which is equivalent for Linux, but is a change for FreeBSD. I think
that all this means is that in some cases where GDB might have
previously recorded a thread-id of 0 for each thread, we might now get
something more useful.
(2) When collecting the registers for Linux we collected into a zero
initialised buffer. By contrast on FreeBSD the buffer is left
uninitialised. In the new code the buffer is always zero initialised.
I suspect once the registers are copied into the buffer there's
probably no gaps left so this makes no difference, but if it does then
using zeros rather than random bits of GDB's memory is probably a good
thing.
Otherwise, there should be no other user visible changes after this
commit.
Tested this on x86-64/GNU-Linux and x86-64/FreeBSD-12.2 with no
regressions.
gdb/ChangeLog:
* Makefile.in (SFILES): Add gcore-elf.c.
(HFILES_NO_SRCDIR): Add gcore-elf.h
* configure: Regenerate.
* configure.ac: Add gcore-elf.o to CONFIG_OBS if we have ELF
support.
* fbsd-tdep.c: Add 'gcore-elf.h' include.
(struct fbsd_collect_regset_section_cb_data): Delete.
(fbsd_collect_regset_section_cb): Delete.
(fbsd_collect_thread_registers): Delete.
(struct fbsd_corefile_thread_data): Delete.
(fbsd_corefile_thread): Delete.
(fbsd_make_corefile_notes): Call
gcore_elf_build_thread_register_notes instead of the now deleted
FreeBSD code.
* gcore-elf.c: New file, the content was moved here from
linux-tdep.c, functions were renamed and given minor cleanup.
* gcore-elf.h: New file.
* gcore.c (gcore_find_signalled_thread): Moved here from
linux-tdep.c and given a new name. Minor cleanups.
* gcore.h (gcore_find_signalled_thread): Declare.
* linux-tdep.c: Add 'gcore.h' and 'gcore-elf.h' includes.
(struct linux_collect_regset_section_cb_data): Delete.
(linux_collect_regset_section_cb): Delete.
(linux_collect_thread_registers): Delete.
(linux_corefile_thread): Call
gcore_elf_build_thread_register_notes.
(find_signalled_thread): Delete.
(linux_make_corefile_notes): Call gcore_find_signalled_thread.
Nick Clifton [Fri, 5 Mar 2021 17:06:59 +0000 (17:06 +0000)]
Add support for the DW_FORM_strx* forms to the BFD library.
PR 27521
* dwarf2.c (is_str_attr): Add DW_FORM_strx* forms.
(read_indexed_string): Placeholder function.
(read_attribute_value): Handle DW_FORM_strx* and DW_FORM_addrx*
forms.
Nick Clifton [Fri, 5 Mar 2021 12:56:24 +0000 (12:56 +0000)]
Fix the dislay of .debug_macro.dwo sections.
PR 27387
* dwarf.c (display_debug_macro): Handle the displaying of
DW_MACRO_define_strp and DW_MACRO_undef_strp in v4
.debug_macro.dwo sections.
Alan Modra [Thu, 4 Mar 2021 12:28:54 +0000 (22:58 +1030)]
Move x86_64 PE changes out of bfd_perform_relocation
bfd_perform_relocation should not have special case target code. This
patch moves the code that was there for x86_64 PE linking to ELF
output into the x86_64 PE howto special function, correcting that
function for linking to targets other than ELF too. The fixes in
bfd_perform_relocation were over-complicated due to needing to
compensate for things that had already gone wrong in coff_amd64_reloc.
In particular, an adjustment for pc-relative relocs was done in a way
that meant adjustment for things related to symbol offsets was lost.
I think those two things are orthogonal, but who knows with COFF where
addends and symbol values are found randomly in the section contents.
Note that linking natively to an x86_64 PE output relocates by
coff_pe_amd64_relocate_section, which does not use arelent relocs or
bfd_perform_relocation, but be aware of coff_amd64_rtype_to_howto
hacking addends for relocations. The adjustments for a particular
relocation type there and in coff_amd64_reloc ought to match after
taking into consideration CALC_ADDEND. They don't. For example,
the pc-relative adjustment for R_PCRWORD is 2 bytes in
coff_amd64_reloc and 4 bytes in coff_amd64_rtype_to_howto.
* reloc.c (bfd_perform_relocation): Revert 2021-01-12 and
2020-09-16 changes.
* coff-x86_64.c (coff_amd64_reloc): Do more or less the same
adjustments here instead. Separate pc-relative adjustments
from symbol related adjustments. Tidy comments and formatting.
GDB Administrator [Fri, 5 Mar 2021 00:00:21 +0000 (00:00 +0000)]
Automatic date update in version.in
Simon Marchi [Thu, 4 Mar 2021 15:57:03 +0000 (10:57 -0500)]
gdb: set current thread in sparc_{fetch,collect}_inferior_registers (PR gdb/27147)
PR 27147 shows that on sparc64, GDB is unable to properly unwind:
Expected result (from GDB 9.2):
#0 0x0000000000108de4 in puts ()
#1 0x0000000000100950 in hello () at gdb-test.c:4
#2 0x0000000000100968 in main () at gdb-test.c:8
Actual result (from GDB latest git):
#0 0x0000000000108de4 in puts ()
#1 0x0000000000100950 in hello () at gdb-test.c:4
Backtrace stopped: previous frame inner to this frame (corrupt stack?)
The first failing commit is
5b6d1e4fa4fc ("Multi-target support"). The cause
of the change in behavior is due to (thanks for Andrew Burgess for finding
this):
- inferior_ptid is no longer set on entry of target_ops::wait, whereas
it was set to something valid previously
- deep down in linux_nat_target::wait (see stack trace below), we fetch
the registers of the event thread
- on sparc64, fetching registers involves reading memory (in
sparc_supply_rwindow, see stack trace below)
- reading memory (target_ops::xfer_partial) relies on inferior_ptid
being set to the thread from which we want to read memory
This is where things go wrong:
#0 linux_nat_target::xfer_partial (this=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, annex=0x0, readbuf=0x7feffe3b000 "", writebuf=0x0, offset=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:3697
#1 0x00000100007f5b10 in raw_memory_xfer_partial (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, readbuf=0x7feffe3b000 "", writebuf=0x0, memaddr=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/target.c:912
#2 0x00000100007f60e8 in memory_xfer_partial_1 (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, readbuf=0x7feffe3b000 "", writebuf=0x0, memaddr=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/target.c:1043
#3 0x00000100007f61b4 in memory_xfer_partial (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, readbuf=0x7feffe3b000 "", writebuf=0x0, memaddr=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/target.c:1072
#4 0x00000100007f6538 in target_xfer_partial (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, annex=0x0, readbuf=0x7feffe3b000 "", writebuf=0x0, offset=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/target.c:1129
#5 0x00000100007f7094 in target_read_partial (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, annex=0x0, buf=0x7feffe3b000 "", offset=
8791798050744, len=8, xfered_len=0x7feffe3ae88) at /home/simark/src/binutils-gdb/gdb/target.c:1375
#6 0x00000100007f721c in target_read (ops=0x10000fa2c40 <the_sparc64_linux_nat_target>, object=TARGET_OBJECT_MEMORY, annex=0x0, buf=0x7feffe3b000 "", offset=
8791798050744, len=8) at /home/simark/src/binutils-gdb/gdb/target.c:1415
#7 0x00000100007f69d4 in target_read_memory (memaddr=
8791798050744, myaddr=0x7feffe3b000 "", len=8) at /home/simark/src/binutils-gdb/gdb/target.c:1218
#8 0x0000010000758520 in sparc_supply_rwindow (regcache=0x10000fea4f0, sp=
8791798050736, regnum=-1) at /home/simark/src/binutils-gdb/gdb/sparc-tdep.c:1960
#9 0x000001000076208c in sparc64_supply_gregset (gregmap=0x10000be3190 <sparc64_linux_ptrace_gregmap>, regcache=0x10000fea4f0, regnum=-1, gregs=0x7feffe3b230) at /home/simark/src/binutils-gdb/gdb/sparc64-tdep.c:1974
#10 0x0000010000751b64 in sparc_fetch_inferior_registers (regcache=0x10000fea4f0, regnum=80) at /home/simark/src/binutils-gdb/gdb/sparc-nat.c:170
#11 0x0000010000759d68 in sparc64_linux_nat_target::fetch_registers (this=0x10000fa2c40 <the_sparc64_linux_nat_target>, regcache=0x10000fea4f0, regnum=80) at /home/simark/src/binutils-gdb/gdb/sparc64-linux-nat.c:38
#12 0x00000100008146ec in target_fetch_registers (regcache=0x10000fea4f0, regno=80) at /home/simark/src/binutils-gdb/gdb/target.c:3287
#13 0x00000100006a8c5c in regcache::raw_update (this=0x10000fea4f0, regnum=80) at /home/simark/src/binutils-gdb/gdb/regcache.c:584
#14 0x00000100006a8d94 in readable_regcache::raw_read (this=0x10000fea4f0, regnum=80, buf=0x7feffe3b7c0 "") at /home/simark/src/binutils-gdb/gdb/regcache.c:598
#15 0x00000100006a93b8 in readable_regcache::cooked_read (this=0x10000fea4f0, regnum=80, buf=0x7feffe3b7c0 "") at /home/simark/src/binutils-gdb/gdb/regcache.c:690
#16 0x00000100006b288c in readable_regcache::cooked_read<unsigned long, void> (this=0x10000fea4f0, regnum=80, val=0x7feffe3b948) at /home/simark/src/binutils-gdb/gdb/regcache.c:777
#17 0x00000100006a9b44 in regcache_cooked_read_unsigned (regcache=0x10000fea4f0, regnum=80, val=0x7feffe3b948) at /home/simark/src/binutils-gdb/gdb/regcache.c:791
#18 0x00000100006abf3c in regcache_read_pc (regcache=0x10000fea4f0) at /home/simark/src/binutils-gdb/gdb/regcache.c:1295
#19 0x0000010000507920 in save_stop_reason (lp=0x10000fc5b10) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:2612
#20 0x00000100005095a4 in linux_nat_filter_event (lwpid=520983, status=1407) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:3050
#21 0x0000010000509f9c in linux_nat_wait_1 (ptid=..., ourstatus=0x7feffe3c8f0, target_options=...) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:3194
#22 0x000001000050b1d0 in linux_nat_target::wait (this=0x10000fa2c40 <the_sparc64_linux_nat_target>, ptid=..., ourstatus=0x7feffe3c8f0, target_options=...) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:3432
#23 0x00000100007f8ac0 in target_wait (ptid=..., status=0x7feffe3c8f0, options=...) at /home/simark/src/binutils-gdb/gdb/target.c:2000
#24 0x00000100004ac17c in do_target_wait_1 (inf=0x1000116d280, ptid=..., status=0x7feffe3c8f0, options=...) at /home/simark/src/binutils-gdb/gdb/infrun.c:3464
#25 0x00000100004ac3b8 in operator() (__closure=0x7feffe3c678, inf=0x1000116d280) at /home/simark/src/binutils-gdb/gdb/infrun.c:3527
#26 0x00000100004ac7cc in do_target_wait (wait_ptid=..., ecs=0x7feffe3c8c8, options=...) at /home/simark/src/binutils-gdb/gdb/infrun.c:3540
#27 0x00000100004ad8c4 in fetch_inferior_event () at /home/simark/src/binutils-gdb/gdb/infrun.c:3880
#28 0x0000010000485568 in inferior_event_handler (event_type=INF_REG_EVENT) at /home/simark/src/binutils-gdb/gdb/inf-loop.c:42
#29 0x000001000050d394 in handle_target_event (error=0, client_data=0x0) at /home/simark/src/binutils-gdb/gdb/linux-nat.c:4060
#30 0x0000010000ab5c8c in handle_file_event (file_ptr=0x10001207270, ready_mask=1) at /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:575
#31 0x0000010000ab6334 in gdb_wait_for_event (block=0) at /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:701
#32 0x0000010000ab487c in gdb_do_one_event () at /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:212
#33 0x0000010000542668 in start_event_loop () at /home/simark/src/binutils-gdb/gdb/main.c:348
#34 0x000001000054287c in captured_command_loop () at /home/simark/src/binutils-gdb/gdb/main.c:408
#35 0x0000010000544e84 in captured_main (data=0x7feffe3d188) at /home/simark/src/binutils-gdb/gdb/main.c:1242
#36 0x0000010000544f2c in gdb_main (args=0x7feffe3d188) at /home/simark/src/binutils-gdb/gdb/main.c:1257
#37 0x00000100000c1f14 in main (argc=4, argv=0x7feffe3d548) at /home/simark/src/binutils-gdb/gdb/gdb.c:32
There is a target_read_memory call in sparc_supply_rwindow, whose return
value is not checked. That call fails, because inferior_ptid does not
contain a valid ptid, and uninitialized buffer contents is used.
Ultimately it results in a corrupt stop_pc.
target_ops::fetch_registers can be (and should remain, in my opinion)
independent of inferior_ptid, because the ptid of the thread from which
to fetch registers can be obtained from the regcache. In other words,
implementations of target_ops::fetch_registers should not rely on
inferior_ptid having a sensible value on entry.
The sparc64_linux_nat_target::fetch_registers case is special, because it calls
a target method that is dependent on the inferior_ptid value
(target_read_inferior, and ultimately target_ops::xfer_partial). So I would
say it's the responsibility of sparc64_linux_nat_target::fetch_registers to set
up inferior_ptid correctly prior to calling target_read_inferior.
This patch makes sparc64_linux_nat_target::fetch_registers (and
store_registers, since it works the same) temporarily set inferior_ptid. If we
ever make target_ops::xfer_partial independent of inferior_ptid, setting
inferior_ptid won't be necessary, we'll simply pass down the ptid as a
parameter in some way.
I chose to set/restore inferior_ptid in sparc_fetch_inferior_registers, because
I am not convinced that doing so in an inner location (in sparc_supply_rwindow
for instance) would always be correct. We have access to the ptid in
sparc_supply_rwindow (from the regcache), so we _could_ set inferior_ptid
there. However, I don't want to just set inferior_ptid, as that would make it
not desync'ed with `current_thread ()` and `current_inferior ()`. It's
preferable to use switch_to_thread instead, as that switches all the global
"current" stuff in a coherent way. But doing so requires a `thread_info *`,
and getting a `thread_info *` from a ptid requires a `process_stratum_target
*`. We could use `current_inferior()->process_target()` in
sparc_supply_rwindow for this (using target_read_memory uses the current
inferior's target stack anyway). However, sparc_supply_rwindow is also used in
the context of BSD uthreads, where a thread stratum target defines threads. I
presume the ptid in the regcache would be the ptid of the uthread, defined by
the thread stratum target (bsd_uthread_target). Using
`current_inferior()->process_target()` would look up a ptid defined by the
thread stratum target using the process stratum target. I don't think it would
give good results. So I prefer playing it safe and looking up the thread
earlier, in sparc_fetch_inferior_registers.
I added some assertions (in sparc_supply_rwindow and others) to verify
that the regcache's ptid matches inferior_ptid. That verifies that the
caller has properly set the correct global context. This would have
caught (though a failed assertion) the current problem.
gdb/ChangeLog:
PR gdb/27147
* sparc-nat.h (sparc_fetch_inferior_registers): Add
process_stratum_target parameter,
sparc_store_inferior_registers): update callers.
* sparc-nat.c (sparc_fetch_inferior_registers,
sparc_store_inferior_registers): Add process_stratum_target
parameter. Switch current thread before calling
sparc_supply_gregset / sparc_collect_rwindow.
(sparc_store_inferior_registers): Likewise.
* sparc-obsd-tdep.c (sparc32obsd_supply_uthread): Add assertion.
(sparc32obsd_collect_uthread): Likewise.
* sparc-tdep.c (sparc_supply_rwindow, sparc_collect_rwindow):
Add assertion.
* sparc64-obsd-tdep.c (sparc64obsd_collect_uthread,
sparc64obsd_supply_uthread): Add assertion.
Change-Id: I16c658cd70896cea604516714f7e2428fbaf4301
Jan Beulich [Thu, 4 Mar 2021 15:56:40 +0000 (16:56 +0100)]
ld: adjust ld-scripts/map-address.*
Without setting an image base address and without naming at least .text,
this test produces entirely bogus PE output. To be honest, even the ELF
output looks odd: .text gets placed at 0x10204, and both foo and bar get
associated with .text despite living below its start address.
Since neither image base nor .text placement are the subject of this
test, specify .text placement explicitly and in the PE case force the
image base to zero.
Jan Beulich [Thu, 4 Mar 2021 15:56:02 +0000 (16:56 +0100)]
bfd: prune COFF/PE section flags setting
It is my understanding that IMAGE_SCN_LNK_* are supposed to communicate
information to the (static) linker, and become at best meaningless in PE
images. I wouldn't call loaders wrong which would refuse to process
sections with any of these bits set. While there's no replacement for
IMAGE_SCN_LNK_COMDAT, use IMAGE_SCN_MEM_DISCARDABLE in place of
IMAGE_SCN_LNK_REMOVE in this case.
Jan Beulich [Thu, 4 Mar 2021 15:55:01 +0000 (16:55 +0100)]
ld: don't generate base relocations in PE output for absolute symbols
It is the very nature of absolute symbols that they don't change even
if the loader decides to put the image at other than its link-time base
address. Of the linker-defined (and PE-specific) symbols __image_base__
(and its alias) needs special casing, as it'll still appear to be
absolute at this point.
A new inquiry function in ldexp.c is needed because PE base relocations
get generated before ldexp_finalize_syms() runs, yet whether a
relocation is needed depends on the ultimate property of a symbol.
Tom Tromey [Thu, 4 Mar 2021 14:30:42 +0000 (07:30 -0700)]
Use "bool" in ada-lang.c
Christian suggested switching an "int" in ada-lang.c to "bool"
instead. This patch makes this change. Tested on x86-64 Fedora 32.
gdb/ChangeLog
2021-03-04 Tom Tromey <tromey@adacore.com>
* ada-lang.c (struct match_data) <found_sym>: Now bool.
(aux_add_nonlocal_symbols): Update.
(ada_add_block_symbols): Change "found_sym" to bool.
Nick Clifton [Thu, 4 Mar 2021 10:41:22 +0000 (10:41 +0000)]
Gate the displaying of non-debug sections in separate debuginfo files.
PR 27478
* objdump.c (process_links): New variable.
(usage): Add --process-links.
(long_options): Likewise.
(dump_bfd): Stop processing once the bfd has been loaded unless
this is the main file or process_links has been enabled.
(main): Handle the process-links option.
* readelf.c (process_links): New variable.
(struct filedata): Add is_separate field.
(options): Add --process-links.
(usage): Likewise.
(parse_args): Likewise.
(process_file_header): Include the filename when dumping
information for separate debuginfo files.
(process_program_headers): Likewise.
(process_section_headers): Likewise.
(process_section_groups): Likewise.
(process_relocs): Likewise.
(process_dynamic_section): Likewise.
(process_version_sections): Likewise.
(display_lto_symtab): Likewise.
(process_symbol_table): Likewise.
(process_syminfo): Likewise.
(initialise_dumps_by_name): Likewise.
(process_section_contents): Likewise.
(process_notes_at): Likewise.
(process_notes): Likewise.
(open_file): Add is_separate parameter. Use to initialise the
is_separate field in the filedata structure.
(open_deug): Update call to open_file.
(process_object): Add processing of the contents of separate
debuginfo files, gated by the process_links variable.
(process_archive): Update call to open_file.
(process_file): Initialise the is_separate field in the filedata
structure.
* dwarf.c (load_separate_debug_info_file): Only report the
loading of a separate file if debug links are being dumped.
* objcopy.c (keep_section_symbols): New variable.
(enum command_line_switch): Add OPTION_KEEP_SYMBOLS.
(strip_options): Add keep-section-symbols.
(copy_options): Likewise.
(copy_usage): Likewise.
(strip_usage): Likewise.
(copy_object): Keep section symbols if requested by command line
option.
(strip_main): Handle --keep-section-symbols.
(copy_main): Likewise.
* doc/binutils.texi: Document the new options.
* NEWS: Mention the new features.
* testsuite/binutils-all/compress.exp (test_gnu_debuglink):
Update options passed to objdump. Use diff rather than cmp to
compare the dumped data.
* testsuite/binutils-all/objdump.WK2: Update regexp.
* testsuite/binutils-all/objdump.WK3: Update regexp.
* testsuite/binutils-all/objdump.exp: Use --process-links
instead of --dwarf=follow-links.
* testsuite/binutils-all/readelf.exp (readelf_test): Include
readelf's output in the log when the test fails.
Add the -P option to the -wKis test.
* testsuite/binutils-all/readelf.wKis: Update expected output.
Libor Bukata [Mon, 1 Mar 2021 11:08:31 +0000 (12:08 +0100)]
GNU strip fails to set sh_link and sh_info on Solaris SPARC64
The patch adds a missing elf64_sparc_copy_solaris_special_section_fields
function that enables to fill sh_link and sh_info fields in .SUNW_* sections.
Note that elf64_sparc_copy_solaris_special_section_fields is empty since
the default handling is currently sufficient for GNU strip command.
This is a followup patch of the following upstream commits:
commit
5522f910cb539905d6adfdceab208ddfa5e84557
Author: Nick Clifton <nickc@redhat.com>
Date: Fri Apr 29 09:24:42 2016 +0100
Enhance support for copying and stripping Solaris and ARM binaries.
commit
84865015459b4e9e8ac67f9b91617fbd856d5119
Author: Nick Clifton <nickc@redhat.com>
Date: Thu Apr 14 12:04:09 2016 +0100
Fix copying Solaris binaries with objcopy.
gdb/ChangeLog:
2021-03-01 Libor Bukata <libor.bukata@oracle.com>
* bfd/elf64-sparc.c: Fix GNU strip on Solaris SPARC64.
GDB Administrator [Thu, 4 Mar 2021 00:00:15 +0000 (00:00 +0000)]
Automatic date update in version.in
Alan Modra [Wed, 3 Mar 2021 22:16:22 +0000 (08:46 +1030)]
binutils fails to compile on AIX due to mismatched declaration
rs6000-core.c:280:19: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
const bfd_cleanup rs6000coff_core_p (bfd *abfd);
^~~~~~~~~~~~~~~~~
rs6000-core.c:336:1: error: conflicting types for 'rs6000coff_core_p'
rs6000coff_core_p (bfd *abfd)
^~~~~~~~~~~~~~~~~
rs6000-core.c:280:19: note: previous declaration of 'rs6000coff_core_p' was here
const bfd_cleanup rs6000coff_core_p (bfd *abfd);
^~~~~~~~~~~~~~~~~
* rs6000-core.c (rs6000coff_core_p): Correct prototype.
Tom Tromey [Wed, 3 Mar 2021 19:02:16 +0000 (12:02 -0700)]
Minor Ada-related cleanups
This patch addresses some review comments that I forgot to deal with
in an earlier patch. See the comments here:
https://sourceware.org/pipermail/gdb-patches/2021-February/176278.html
For the most part this is fixing up comments, but it also includes
adding a constructor and initializers to "match_data".
Regression tested on x86-64 Fedora 32.
gdb/ChangeLog
2021-03-03 Tom Tromey <tromey@adacore.com>
* ada-lang.c (ada_resolve_function): Update comment.
(is_nonfunction, add_symbols_from_enclosing_procs)
(remove_extra_symbols): Likewise.
(struct match_data): Add constructor, initializers.
(add_nonlocal_symbols): Remove memset.
(aux_add_nonlocal_symbols): Update comment.
(ada_add_block_renamings, add_nonlocal_symbols)
(ada_add_all_symbols): Likewise.
* ada-exp.y (write_var_or_type): Clean up trailing whitespace.
Jan Beulich [Wed, 3 Mar 2021 11:57:08 +0000 (12:57 +0100)]
x86: infer operand count of templates
Having this count explicitly in the table is redundant and (even if just
slightly) disturbs clarity. Infer the count from the number of operands
actually found.
Also convert the "no operands" indicator from "{ 0 }" to just "{}", as
that (now) ends up being easier to parse.
Markus Metzger [Wed, 13 Jan 2021 15:41:43 +0000 (16:41 +0100)]
gdb, testsuite: enforce lazy binding for gdb.btrace/rn-dl-bind.exp
In gdb.btrace/rn-dl-bind.exp we test that we can reverse-step over
recorded dynamic linking. The test covers specific behaviour to support
_dl_runtime_resolve calling the resolved function by returning to it.
This would normally mess up stepping as we'd end up with backtraces that
contain the same functions but different frame ids.
Since GDB needs to recognize a return from _dl_runtime_resolve, the test
only passes when debug information for _dl_runtime_resolve is available.
The test requires that symbols are bound lazily. Otherwise, we won't
record dynamic linking and the test will be fairly pointless.
Recent GCC pass -z now by default to bind symbols eagerly. Add -z lazy to
the test's ldflags to enforce lazy binding.
Markus Metzger [Thu, 17 Dec 2020 09:28:18 +0000 (10:28 +0100)]
testsuite, gdb.btrace: adjust expected source line in non-stop.exp
In gdb.btrace/non-stop.exp, we hard-code expected source lines assuming we
know how they would match to the recorded trace. Despite the fact that we
should really have been using an assembly source, the assumptions work
pretty well.
With clang-6 -m32, we found a case where the assumptions do not hold.
Adjust the expected source lines a little bit to cover that case, as well.
Should we run into more cases like this, we will have to switch to an
assembly source file.
Markus Metzger [Thu, 17 Dec 2020 08:34:54 +0000 (09:34 +0100)]
testsuite, gdb.btrace: remove implicit debug option in stepi.exp
We use pre-compiled assembly including debug information for stepi, yet we
compiled with -g, which was implicitly set by prepare_for_testing.
Add {} options to avoid the implicit {debug}.
Markus Metzger [Tue, 15 Dec 2020 15:18:34 +0000 (16:18 +0100)]
testsuite, gdb.btrace: adjust expected output to pass with clang
Clang generates slightly different debug information. Adjust the expected
output of gdb.btrace/function_call_history.exp to work with both gcc and
clang.
Also modify gdb.btrace/exception.cc to reliably trace into main and update
the corresponding patterns in gdb.btrace/exception.exp.
Markus Metzger [Wed, 16 Dec 2020 17:15:04 +0000 (18:15 +0100)]
testsuite, gdb.btrace: move -Wl,-x to ldflags
In gdb.btrace/unknown_functions.exp we need the linker to discard local
symbols so GDB wouldn't know about them from the symbol table.
When building with clang, it complains about the option not being used at
compile-time. Move the option to ldflags to only pass it at link-time.
Markus Metzger [Tue, 15 Dec 2020 14:01:21 +0000 (15:01 +0100)]
testsuite, gdb.btrace: pass rn-dl-bind.exp with clang
Clang generates slightly different debug information causing
gdb.btrace/rn-dl-bind.exp to fail on its way to the actual test.
Modify the test to remove that dependency.
Markus Metzger [Tue, 15 Dec 2020 11:46:58 +0000 (12:46 +0100)]
testsuite, gdb.btrace: remove assembly-check in delta.exp
In gdb.btrace/delta.exp, we test that we do not extend the trace
unintentionally. This can be tested by checking the number of
instructions.
If we wanted to check the instruction history, as well, we'd need to work
on an assembly file to have deterministic behaviour. This isn't really
necessary for this test, however, and covered elsewhere. Also remove the
function call history check for the same reason.
Markus Metzger [Mon, 21 Dec 2020 07:34:25 +0000 (08:34 +0100)]
testsuite: extend nopie handling to add -fno-pie to compiler flags
Some older GCC, e.g. 7.5.0 on Ubuntu 18.04 need -fno-pie to be passed to
the compiler in addition to -no-pie to be passed to the linker for non-pie
code generation.
The gdb,nopie_flag is already documented as getting passed to the
compiler, not the linker. Use that for the new -fno-pie compiler flag and
add a new gdb,nopie_ldflag for the existing -no-pie linker flag.
CAUTION: this might break existing board files that specify
gdb,nopie_flag. Affected board files need to rename
gdb,nopie_flag into gdb,nopie_ldflag.
Alan Modra [Wed, 3 Mar 2021 04:45:23 +0000 (15:15 +1030)]
PR27493, objcopy --weaken-symbol does not weaken undefined symbols
PR 27493
* objcopy.c (filter_symbols): Apply --weaken to undefined symbols.
* NEWS: Mention feature.
Alan Modra [Wed, 3 Mar 2021 01:44:55 +0000 (12:14 +1030)]
--gc-sections with groups and start/stop syms
The testcases added here show situations where synthesized start/stop
symbols don't cause their associated input sections to be marked.
Fixed with the elflink.c and ldlang.c changes.
bfd/
PR 27500
* elflink.c (_bfd_elf_gc_mark_rsec): Do special start/stop
processing not when start/stop symbol section is unmarked but
on first time a start/stop symbol is processed.
ld/
* ldlang.c (insert_undefined): Don't mark symbols here.
(lang_mark_undefineds): Do so here instead, new function.
(lang_process): Call lang_mark_undefineds.
* testsuite/ld-gc/start3.d,
* testsuite/ld-gc/start3.s: New test.
* testsuite/ld-gc/start4.d,
* testsuite/ld-gc/start4.s: New test.
* testsuite/ld-gc/gc.exp: Run them.
Alan Modra [Wed, 3 Mar 2021 06:55:28 +0000 (17:25 +1030)]
ld-gc tests on underscore targets
Adjust tests to reference __start and __stop syms with an extra
leading underscore when appropriate, and run tests on more targets.
* testsuite/ld-gc/gc.exp: Define UNDERSCORE in ASFLAGS.
Move tests with ELF section directives to is_elf_format block.
* testsuite/ld-gc/abi-note.d: Run on more targets.
* testsuite/ld-gc/pr19167.d: Likewise and adjust xfails.
* testsuite/ld-gc/start.d: Likewise.
* testsuite/ld-gc/start2.d: Likewise.
* testsuite/ld-gc/stop.d: Likewise.
* testsuite/ld-gc/pr19167a.s: Add support for underscore targets.
* testsuite/ld-gc/start.s: Likewise.
* testsuite/ld-gc/start2.s: Likewise.
Alan Modra [Tue, 2 Mar 2021 01:36:14 +0000 (12:06 +1030)]
Split relocation defines out of coff/internal.h
include/
* coff/internal.h: Delete obsolete relocation defines. Move used
relocation defines..
* coff/i386.h: ..to here..
* coff/ti.h: ..and here..
* coff/x86_64.h: ..and here..
* coff/z80.h: ..and here..
* coff/z8k.h: ..and here.
bfd/
* reloc.c: Include x86_64.h rather than internal.h.
GDB Administrator [Wed, 3 Mar 2021 00:00:19 +0000 (00:00 +0000)]
Automatic date update in version.in
Tom Tromey [Tue, 2 Mar 2021 20:42:37 +0000 (13:42 -0700)]
Fix Readline 8.1 build on mingw
The mingw build fails with Readline 8.1, because sigprocmask is called
unconditionally. This patch adds the missing check for
HAVE_POSIX_SIGNALS.
I reported this upstream here:
https://lists.gnu.org/archive/html/bug-readline/2021-01/msg00011.html
readline/ChangeLog
2021-03-02 Tom Tromey <tom@tromey.com>
* readline/signals.c (_rl_handle_signal): Add missing check for
HAVE_POSIX_SIGNALS.
Tom Tromey [Tue, 2 Mar 2021 20:42:37 +0000 (13:42 -0700)]
Import GNU Readline 8.1
This imports readline 8.1. I did this via various hackery in a
readline git repository to make a version of readline identical to
gdb's, then did a git merge.
readline/ChangeLog
2021-03-02 Tom Tromey <tom@tromey.com>
* Import readline 8.1.
Tom Tromey [Tue, 2 Mar 2021 20:08:24 +0000 (13:08 -0700)]
Rewrite GNAT-encoded fixed point types in DWARF reader
gdb currently supports two different styles of fixed-point. The
original style, where fixed point types are "GNAT encoded", is handled
primarily in the Ada code. The newer style, encoded using DWARF, is
handled by the core of gdb.
This patch changes gdb to read the GNAT encodings in the DWARF reader
as well. This removes some code and unifies the two paths. As a
result, GNAT-encoded fixed-point now works a bit better.
One possible drawback of this change is that, if someone uses stabs,
then fixed-point might now stop working. I consider stabs to be fully
obsolete, though, so I don't intend to address this.
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.c (cast_from_gnat_encoded_fixed_point_type)
(cast_to_gnat_encoded_fixed_point_type): Remove.
(ada_value_cast, ada_evaluate_subexp): Update.
(gnat_encoded_fixed_point_type_info)
(ada_is_gnat_encoded_fixed_point_type)
(gnat_encoded_fixed_point_delta)
(gnat_encoded_fixed_point_scaling_factor): Remove.
* ada-lang.h (ada_is_gnat_encoded_fixed_point_type)
(gnat_encoded_fixed_point_delta)
(gnat_encoded_fixed_point_scaling_factor): Don't declare.
* ada-typeprint.c (print_gnat_encoded_fixed_point_type): Remove.
(ada_print_type): Update.
* ada-valprint.c (ada_value_print_num): Update.
* dwarf2/read.c (ada_get_gnat_encoded_number)
(ada_get_gnat_encoded_ratio): New functions.
(finish_fixed_point_type): Use them. Add parameters.
(GNAT_FIXED_POINT_SUFFIX): New define.
(gnat_encoded_fixed_point_type_info): New function.
(read_base_type): Handle gnat encodings.
gdb/testsuite/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* gdb.ada/fixed_points.exp: Remove most special cases for minimal
encodings.
Tom Tromey [Tue, 2 Mar 2021 20:00:45 +0000 (13:00 -0700)]
Use std::string rather than grow_vect
This removes the "GROW_VECT" macro and helper function in favor of
simply using std::string in a few spots.
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.c (ada_fold_name, ada_variant_discrim_name)
(ada_enum_name, scan_discrim_bound, to_fixed_range_type): Use
std::string.
(GROW_VECT): Remove.
(grow_vect): Remove.
Tom Tromey [Tue, 2 Mar 2021 20:00:45 +0000 (13:00 -0700)]
Return a vector from ada_lookup_symbol_list
This changes ada_lookup_symbol_list to return a std::vector, and
changes various other helper functions to follow. This simplifies the
code, and makes it more type-safe (by using a vector where an obstack
had been used).
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.h (ada_lookup_symbol_list): Return a vector.
* ada-lang.c (resolve_subexp): Update.
(ada_resolve_function): Accept a vector.
(is_nonfunction, add_defn_to_vec)
(add_symbols_from_enclosing_procs): Likewise.
(num_defns_collected, defns_collected): Remove.
(remove_extra_symbols): Return a vector.
(remove_irrelevant_renamings): Return void.
(ada_add_local_symbols): Accept a vector.
(struct match_data) <obstackp>: Remove.
<resultp>: New member.
(aux_add_nonlocal_symbols): Update.
(ada_add_block_renamings, add_nonlocal_symbols)
(ada_add_all_symbols): Accept a vector.
(ada_lookup_symbol_list_worker, ada_lookup_symbol_list): Return a
vector.
(ada_lookup_symbol): Update.
(ada_add_block_symbols): Accept a vector.
(get_var_value, iterate_over_symbols): Update.
* ada-exp.y (block_lookup, write_var_or_type, write_name_assoc):
Update.
Tom Tromey [Tue, 2 Mar 2021 20:00:45 +0000 (13:00 -0700)]
Simplify resolve_subexp by using C++ algorithms
This changes resolve_subexp to use any_of and the erase-remove idiom
to simplify the code somewhat. This simplifies the next patch a bit.
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.c (resolve_subexp): Use any_of and erase-remove idiom.
Tom Tromey [Tue, 2 Mar 2021 20:00:45 +0000 (13:00 -0700)]
Use new for ada_symbol_cache
This changes the ada_symbol_cache to be allocated with 'new' and
managed via unique_ptr. This simplifies the code somewhat. Also,
ada_clear_symbol_cache is changed so that it does not allocate a
symbol cache just to clear it.
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.c (struct ada_symbol_cache) <cache_space>: Now an
auto_obstack.
<root>: Initialize.
(ada_pspace_data): Remove destructor.
<sym_cache>: Now a unique_ptr.
(ada_init_symbol_cache, ada_free_symbol_cache): Remove.
(ada_get_symbol_cache): Use 'new'.
(ada_clear_symbol_cache): Rewrite.
Tom Tromey [Tue, 2 Mar 2021 18:57:01 +0000 (11:57 -0700)]
Check objfile->sf in ada-lang.c
Most places in gdb that reference objfile->sf also check that it is
not null. It is valid for it to be null, because find_sym_fns can
return null for some kinds of object file. However, it's rare to
encounter this scenario with Ada code. I only encountered it when
looking at a fork of gdb that, I believe, makes its own objfiles
without setting 'sf'.
This patch changes ada-lang.c to check this field before using it.
This avoids any potential crash here. There's no test case because
I'm not even sure this is possible to trip over with an unmodified
gdb.
There are some other unchecked uses in gdb, but at a quick glance they
all seem to be involved with symbol reading, which of course won't
happen when sf==null.
gdb/ChangeLog
2021-03-02 Tom Tromey <tromey@adacore.com>
* ada-lang.c (add_nonlocal_symbols): Handle case where objfile->sf
is null.
Nick Clifton [Tue, 2 Mar 2021 16:08:23 +0000 (16:08 +0000)]
Fix the BFD library's parsing of DIEs where specification attributes can refer to variables that are defined later on.
PR 27484
* dwarf2.c (scan_unit_for_symbols): Scan twice, once to accumulate
function and variable tags and a second time to resolve their
attributes.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
bfd, ld, libctf: skip zero-refcount strings in CTF string reporting
This is a tricky one. BFD, on the linker's behalf, reports symbols to
libctf via the ctf_new_symbol and ctf_new_dynsym callbacks, which
ultimately call ctf_link_add_linker_symbol. But while this happens
after strtab offsets are finalized, it happens before the .dynstr is
actually laid out, so we can't iterate over it at this stage and
it is not clear what the reported symbols are actually called. So
a second callback, examine_strtab, is called after the .dynstr is
finalized, which calls ctf_link_add_strtab and ultimately leads
to ldelf_ctf_strtab_iter_cb being called back repeatedly until the
offsets of every string in the .dynstr is passed to libctf.
libctf can then use this to get symbol names out of the input (which
usually stores symbol types in the form of a name -> type mapping at
this stage) and extract the types of those symbols, feeding them back
into their final form as a 1:1 association with the real symtab's
STT_OBJ and STT_FUNC symbols (with a few skipped, see
ctf_symtab_skippable).
This representation is compact, but has one problem: if libctf somehow
gets confused about the st_type of a symbol, it'll stick an entry into
the function symtypetab when it should put it into the object
symtypetab, or vice versa, and *every symbol from that one on* will have
the wrong CTF type because it's actually looking up the type for a
different symbol.
And we have just such a bug. ctf_link_add_strtab was not taking the
refcounts of strings into consideration, so even strings that had been
eliminated from the strtab by virtue of being in objects eliminated via
--as-needed etc were being reported. This is harmful because it can
lead to multiple strings with the same apparent offset, and if the last
duplicate to be reported relates to an eliminated symbol, we look up the
wrong symbol from the input and gets its type wrong: if it's unlucky and
the eliminated symbol is also of the wrong st_type, we will end up with
a corrupted symtypetab.
Thankfully the wrong-st_type case is already diagnosed by a
this-can-never-happen paranoid warning:
CTF warning: Symbol 61a added to CTF as a function but is of type 1
or the converse
* CTF warning: Symbol a3 added to CTF as a data object but is of type 2
so at least we can tell when the corruption has spread to more than one
symbol's type.
Skipping zero-refcounted strings is easy: teach _bfd_elf_strtab_str to
skip them, and ldelf_ctf_strtab_iter_cb to loop over skipped strings
until it falls off the end or finds one that isn't skipped.
bfd/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* elf-strtab.c (_bfd_elf_strtab_str): Skip strings with zero refcount.
ld/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ldelfgen.c (ldelf_ctf_strtab_iter_cb): Skip zero-refcount strings.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-create.c (symtypetab_density): Report the symbol name as
well as index in the name != object error; note the likely
consequences.
* ctf-link.c (ctf_link_shuffle_syms): Report the symbol index
as well as name.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf: free ctf_dynsyms properly
In the "no symbols" case (commonplace for executables), we were freeing
the ctf_dynsyms using free(), instead of ctf_dynhash_destroy(), leaking
a little memory.
(This is harmless in the common case of ld usage, but libctf might be
used by persistent processes too.)
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-link.c (ctf_link_shuffle_syms): Free ctf_dynsyms properly.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf: fix signed/unsigned comparison confusion
Comparing an encoding's cte_bits to a ctf_type_size needs a cast:
one is a uint32_t and the other is an ssize_t.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-dump.c (ctf_dump_format_type): Fix signed/unsigned confusion.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf: minor error-handling fixes
A transient bug in the preceding change (fixed before commit) exposed a
new failure, of ld/testsuite/ld-ctf/diag-parname.d. This attempts to
ensure that if we link a dict with child type IDs but no attached
parent, we get a suitable ECTF_NOPARENT error. This was happening
before this commit, but only by chance, because ctf_variable_iter and
ctf_variable_next check to see if the dict they're passed is a child
dict without an associated parent. We forgot error-checking on the
ctf_variable_next call, and as a result this was concealed -- and
looking for the problem exposed a new bug.
If any of the lookups beneath ctf_dedup_hash_type fail, the CTF link
does *not* fail, but acts quite bizarrely, skipping the type but
emitting an error to the CTF error/warning log -- so the linker will
report an error, emit a partial CTF dict missing some types, and exit
with exitcode 0 as if nothing went wrong. Since ctf_dedup_hash_type is
never expected to fail in normal operation, this is surely wrong:
failures at emission time do not emit partial CTF dicts, so failures
at hashing time should not either.
So propagate the error back up.
Also fix a couple of smaller bugs where we fail to properly free things
and/or propagate error codes on various rare link-time errors and
out-of-memory conditions.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-dedup.c (ctf_dedup): Pass on errors from ctf_dedup_hash_type.
Call ctf_dedup_fini properly on other errors.
(ctf_dedup_emit_type): Set the errno on dynhash insertion failure.
* ctf-link.c (ctf_link_deduplicating_per_cu): Close outputs beyond
output 0 when asserting because >1 output is found.
(ctf_link_deduplicating): Likewise, when asserting because the
shared output is not the same as the passed-in fp.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf: add a deduplicator-specific type mapping table
When CTF linking is done, the linker has to track the association
between types in the inputs and types in the outputs. The deduplicator
does this via the cd_output_emission_hashes, which maps from hashes of
types (valid in both the input and output) to the IDs of types in the
specific dict in which the cd_emission_hashes is held. However, the
nondeduplicating linker and ctf_add_type used a different mechanism, a
dedicated hashtab stored in the ctf_link_type_mapping, populated via
ctf_add_type_mapping and queried via the ctf_type_mapping function. To
allow the same functions to be used for variable and symbol population
in both the deduplicating and nondeduplicating linker, the deduplicator
carefully transferred all its input->output mappings into this hashtab
before returning.
This is *expensive*. The number of entries in this hashtab scales as the
number of input types, and unlike the hashing machinery the type mapping
machinery (the only other thing which scales that way) has not been much
optimized.
Now the nondeduplicating linker is gone, we can throw this out, move
the existing type mapping machinery to ctf-create.c and dedicate it to
ctf_add_type alone, and add a new function ctf_dedup_type_mapping which
uses the deduplicator's built-in knowledge of type mappings directly,
without requiring an expensive repopulation phase.
This speeds up a test link of nouveau.ko (a good worst-case candidate
with a lot of types in each of a lot of input files) from 9.11s to 7.15s
in my testing, a speedup of over 20%.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-impl.h (ctf_dict_t) <ctf_link_type_mapping>: No longer used
by the nondeduplicating linker.
(ctf_add_type_mapping): Removed, now static.
(ctf_type_mapping): Likewise.
(ctf_dedup_type_mapping): New.
(ctf_dedup_t) <cd_input_nums>: New.
* ctf-dedup.c (ctf_dedup_init): Populate it.
(ctf_dedup_fini): Free it again. Emphasise that this has to be
the last thing called.
(ctf_dedup): Populate it.
(ctf_dedup_populate_type_mapping): Removed.
(ctf_dedup_populate_type_mappings): Likewise.
(ctf_dedup_emit): No longer call it. No longer call
ctf_dedup_fini either.
(ctf_dedup_type_mapping): New.
* ctf-link.c (ctf_unnamed_cuname): New.
(ctf_create_per_cu): Arguments must be non-null now.
(ctf_in_member_cb_arg): Removed.
(ctf_link): No longer populate it. No longer discard the
mapping table.
(ctf_link_deduplicating_one_symtypetab): Use
ctf_dedup_type_mapping, not ctf_type_mapping. Use
ctf_unnamed_cuname.
(ctf_link_one_variable): Likewise. Pass in args individually: no
longer a ctf_variable_iter callback.
(empty_link_type_mapping): Removed.
(ctf_link_deduplicating_variables): Use ctf_variable_next, not
ctf_variable_iter. No longer pack arguments to
ctf_link_one_variable into a struct.
(ctf_link_deduplicating_per_cu): Call ctf_dedup_fini once
all link phases are done.
(ctf_link_deduplicating): Likewise.
(ctf_link_intern_extern_string): Improve comment.
(ctf_add_type_mapping): Migrate...
(ctf_type_mapping): ... these functions...
* ctf-create.c (ctf_add_type_mapping): ... here...
(ctf_type_mapping): ... and make static, for the sole use of
ctf_add_type.
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf: remove reference to "unconflicted link mode".
There is no such thing, and the comment makes no sense, and doesn't
match what the code is doing. We always want to put variables in the
same dicts as the types they relate to if at all possible.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-link.c (ctf_link_one_variable): Remove reference to
"unconflicted link mode".
Nick Alcock [Tue, 2 Mar 2021 15:10:05 +0000 (15:10 +0000)]
libctf, include: remove the nondeduplicating CTF linker
The nondeduplicating CTF linker was kept around when the deduplicating
one was added so that people had something to fall back to in case the
deduplicating linker turned out to be buggy. It's now much more stable
than the nondeduplicating linker, in addition to much faster, using much
less memory and producing much better output. In addition, while
libctf has a linker flag to invoke the nondeduplicating linker, ld does
not expose it: the only way to turn it on within ld is an intentionally-
undocumented environment variable. So we can remove it without any ABI
or user-visibility concerns (the only thing we leave around is the
CTF_LINK_NONDEDUP flag, which can easily be interpreted as "deduplicate
less", though right now it does nothing).
This lets us remove a lot of complexity associated with tracking
filenames and CU names separately (something the deduplcating linker
never bothered with, since the cunames are always reliable and ld never
hands us useful filenames anyway)
The biggest lacuna left behind is the ctf_type_mapping machinery, which
slows down deduplicating links quite a lot. We can't just ditch it
because ctf_add_type uses it: removing the slowdown from the
deduplicating linker is a job for another commit.
include/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-api.h (CTF_LINK_SHARE_DUPLICATED): Note that this might
merely change how much deduplication is done.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-link.c (ctf_create_per_cu): Drop FILENAME now that it is
always identical to CUNAME.
(ctf_link_deduplicating_one_symtypetab): Adjust.
(ctf_link_one_type): Remove.
(ctf_link_one_input_archive_member): Likewise.
(ctf_link_close_one_input_archive): Likewise.
(ctf_link_one_input_archive): Likewise.
(ctf_link): No longer call it. Drop CTF_LINK_NONDEDUP path.
Improve header comment a bit (dicts, not files). Adjust
ctf_create_per_cu call.
(ctf_link_deduplicating_variables): Simplify.
(ctf_link_in_member_cb_arg_t) <cu_name>: Remove.
<in_input_cu_file>: Likewise.
<in_fp_parent>: Likewise.
<done_parent>: Likewise.
(ctf_link_one_variable): Turn uses of in_file_name to in_cuname.
Nick Alcock [Tue, 23 Feb 2021 13:41:59 +0000 (13:41 +0000)]
libctf: fix ChangeLog date
I pushed this change without fixing up the date by mistake.
Nick Alcock [Thu, 18 Feb 2021 17:03:28 +0000 (17:03 +0000)]
libctf: reimplement many _iter iterators in terms of _next
Ever since the generator-style _next iterators were introduced, there
have been separate implementations of the functional-style _iter
iterators that do the same thing as _next.
This is annoying and adds more dependencies on the internal guts of the
file format. Rip them all out and replace them with the corresponding
_next iterators. Only ctf_archive_raw_iter and ctf_label_iter survive,
the former because there is no access to the raw binary data of archives
via any _next iterator, and the latter because ctf_label_next hasn't
been implemented (because labels are currently not used for anything).
Tested by reverting the change (already applied) that reimplemented
ctf_member_iter in terms of ctf_member_next, then verifying that the
_iter and _next iterators produced the same results for every iterable
entity within a large type archive.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-types.c (ctf_member_iter): Move 'rc' to an inner scope.
(ctf_enum_iter): Reimplement in terms of ctf_enum_next.
(ctf_type_iter): Reimplement in terms of ctf_type_next.
(ctf_type_iter_all): Likewise.
(ctf_variable_iter): Reimplement in terms of ctf_variable_next.
* ctf-archive.c (ctf_archive_iter_internal): Remove.
(ctf_archive_iter): Reimplement in terms of ctf_archive_next.
Nick Alcock [Thu, 18 Feb 2021 16:56:23 +0000 (16:56 +0000)]
libctf: ctf_archive_next should set the parent name consistently
The top level of CTF containers is a "CTF archive", which contains a
collection of named members (each a CTF dictionary). In the serialized
file format, this is optional and skipped if the archive would have only
one member, as when no ambiguous types are present: so it is commonplace
to have a simple ctf_dict_t written out, with no archive container
wrapped around it.
But, unlike ctf_archive_iter, ctf_archive_next didn't quite handle this
case right. It should set the name of this fake "member" to
_CTF_SECTION, i.e. ".ctf", but it was failing to do so, so callers got
an unintialized variable back instead and were understandably confused.
So set the name properly.
libctf/ChangeLog
2021-03-02 Nick Alcock <nick.alcock@oracle.com>
* ctf-archive.c (ctf_archive_next): Set the name of parents in
single-member archives.
Alan Modra [Tue, 2 Mar 2021 10:55:20 +0000 (21:25 +1030)]
PR27451, -z start_stop_gc for powerpc64
PowerPC64 has its own gc_mark_dynamic_ref.
bfd/
PR 27451
* elf64-ppc.c (ppc64_elf_gc_mark_dynamic_ref): Ignore synthesized
linker defined start/stop symbols when start_stop_gc.
ld/
* testsuite/ld-powerpc/startstop.d,
* testsuite/ld-powerpc/startstop.r,
* testsuite/ld-powerpc/startstop.s: New test.
* testsuite/ld-powerpc/powerpc.exp: Run it.
Alan Modra [Tue, 2 Mar 2021 10:52:31 +0000 (21:22 +1030)]
PowerPC64 undefined weak visibility vs GOT optimisation
Undefined weak symbols with non-default visibility are seen as local
by SYMBOL_REFERENCES_LOCAL. This stops a got indirect to relative
optimisation for them, so that pies and dlls don't get non-zero values
when loading somewhere other than the address they are linked at
(which always happens). The optimisation could be allowed for pdes,
but I thought it best not to allow it there too.
bfd/
* elf64-ppc.c (ppc64_elf_relocate_section): Don't optimise got
indirect to pc-relative or toc-relative for undefined symbols.
ld/
* testsuite/ld-powerpc/weak1.d,
* testsuite/ld-powerpc/weak1.r,
* testsuite/ld-powerpc/weak1.s,
* testsuite/ld-powerpc/weak1so.d,
* testsuite/ld-powerpc/weak1so.r: New tests.
* testsuite/ld-powerpc/powerpc.exp: Run them.
GDB Administrator [Tue, 2 Mar 2021 00:00:18 +0000 (00:00 +0000)]
Automatic date update in version.in
Nick Clifton [Mon, 1 Mar 2021 16:25:06 +0000 (16:25 +0000)]
Add DWARF-5 section names to PE and PEP linker scripts.
PR 27268
* scripttempl/pe.sc: Add DWARF-5 section names.
* scripttempl/pep.sc: Likewise.
H.J. Lu [Mon, 1 Mar 2021 13:34:34 +0000 (05:34 -0800)]
Warn for missing separate debug files only if needed
We shouldn't warn missing separate debug files when debug info isn't
needed.
PR binutils/27486
* dwarf.c (load_separate_debug_info): Issue warning only if
do_debug_links is set.
* testsuite/binutils-all/compress.exp: Run objdump and readelf
with missing debug file.
Alan Modra [Sun, 28 Feb 2021 21:52:49 +0000 (08:22 +1030)]
PR27451, -z start_stop_gc
When --gc-sections is in effect, a reference from a retained section
to __start_SECNAME or __stop_SECNAME causes all input sections named
SECNAME to also be retained, if SECNAME is representable as a C
identifier and either __start_SECNAME or __stop_SECNAME is synthesized
by the linker. Add an option to disable that feature, effectively
ignoring any relocation that references a synthesized linker defined
__start_ or __stop_ symbol.
PR 27451
include/
* bfdlink.h (struct bfd_link_info): Add start_stop_gc.
bfd/
* elflink.c (_bfd_elf_gc_mark_rsec): Ignore synthesized linker
defined start/stop symbols when start_stop_gc.
(bfd_elf_gc_mark_dynamic_ref_symbol): Likewise.
(bfd_elf_define_start_stop): Don't modify ldscript_def syms.
* linker.c (bfd_generic_define_start_stop): Likewise.
ld/
* emultempl/elf.em: Handle -z start-stop-gc and -z nostart-stop-gc.
* lexsup.c (elf_static_list_options): Display help for them. Move
help for -z stack-size to here from elf_shlib_list_options. Add
help for -z start-stop-visibility and -z undefs.
* ld.texi: Document -z start-stop-gc and -z nostart-stop-gc.
* NEWS: Mention -z start-stop-gc.
* testsuite/ld-gc/start2.s,
* testsuite/ld-gc/start2.d: New test.
* testsuite/ld-gc/gc.exp: Run it.
Alan Modra [Mon, 1 Mar 2021 01:10:51 +0000 (11:40 +1030)]
Weak references to __start_/__stop_ symbols
If a weak reference to a __start_foo or __stop_foo symbol ends up
having no definition due to all the foo sections being removed for
some reason, undef_start_stop currently makes the symbol strong
undefined. That risks a linker undefined symbol error. Fix that by
making the symbol undefweak and also undo some dynamic symbol state.
Note that saving the state of the symbol type at the time
lang_init_start_stop runs is not sufficient. The linker may have
merged in a shared library reference by that point and made what was
an undefweak in regular objects, a strong undefined. So it is
necessary to look at the ELF symbol flags to decide whether an
undefweak is the proper resolution.
Something probably should be done for COFF/PE too, but I'm unsure how
to do go about that.
* ldlang.c (undef_start_stop): For ELF make undefined start/stop
symbols undefweak if that was how they were referenced. Undo
dynamic state too.
Alan Modra [Sat, 27 Feb 2021 05:09:05 +0000 (15:39 +1030)]
PR27128, nm -P portable output format regression
Add nm --without-symbol-versions.
binutils/
PR 27128
* doc/binutils.texi: Add nm --with-symbol-versions and
--without-symbol-versions documentation.
* nm.c (with_symbol_versions): New variable.
(enum long_option_values): Delete OPTION_WITH_SYMBOL_VERSIONS.
(long_options): Make --with-symbol-versions entry twiddle the flag.
Add --without-symbol-versions.
(print_symname): Strip version when !with_symbol_versions. Add
dynamic version info under control of with_symbol_versions.
(main): Remove OPTION_WITH_SYMBOL_VERSIONS case.
ld/
* testsuite/ld-elf/pr25708.d: Add --with-symbol-versions to nm.
* testsuite/ld-elf/pr27128a.d: Likewise.
* testsuite/ld-elf/pr27128b.d: Likewise.
* testsuite/ld-elf/pr27128c.d: Likewise.
* testsuite/ld-elf/pr27128d.d: Likewise.
* testsuite/ld-elf/pr27128e.d: Likewise.
GDB Administrator [Mon, 1 Mar 2021 00:00:19 +0000 (00:00 +0000)]
Automatic date update in version.in
H.J. Lu [Sun, 28 Feb 2021 12:39:38 +0000 (04:39 -0800)]
Add missing changes to Makefile.tpl
Update Makefile.tpl to add missing changes in
commit
af019bfde9b13d628202fe58054ec7ff08d92a0f
Author: H.J. Lu <hjl.tools@gmail.com>
Date: Sat Jan 9 06:51:15 2021 -0800
Support the PGO build for binutils+gdb
"autogen Makefile.def" showed no changes in Makefile.in.
PR binutils/26766
* Makefile.tpl (PGO_BUILD_TRAINING_FLAGS_TO_PASS): Add
PGO_BUILD_TRAINING=yes.
(PGO_BUILD_TRAINING_MFLAGS): New.
(all): Pass $(PGO_BUILD_TRAINING_MFLAGS) to the PGO build.
Mike Frysinger [Mon, 22 Feb 2021 05:51:34 +0000 (00:51 -0500)]
sim: igen: drop config.h & header checking
While the configure script was checking for a bunch of headers, only
one of them was conditionally included in the source (unistd.h). The
rest were always included. Based on those usage this whole time, we
can reasonably assume that the build also has unistd.h.
All the other files including config.h never actually used any defines
from the header.
Mike Frysinger [Mon, 22 Feb 2021 05:50:59 +0000 (00:50 -0500)]
sim: igen: delete more unused toolchain settings
This package doesn't build any archives or install programs.
Mike Frysinger [Mon, 22 Feb 2021 03:52:00 +0000 (22:52 -0500)]
sim: igen: delete unused FOR_BUILD vars
Mike Frysinger [Mon, 22 Feb 2021 03:15:03 +0000 (22:15 -0500)]
sim: set up build-time compiler settings
Some sim dirs were already setting up CFLAGS_FOR_BUILD in inconsistent
ways. Move it to a common place for reuse.
Mike Frysinger [Mon, 22 Feb 2021 00:26:47 +0000 (19:26 -0500)]
sim: use AC_CHECK_TOOL to find ar
Rather than require $AR be set and then default to `ar`, use the
standard AC_CHECK_TOOL helper to find a good prefixed tool. In
practice this shouldn't change much as we seem to have macros in
the tree that were already setting it up, but we shouldn't rely
on that implicitly.
Mike Frysinger [Mon, 22 Feb 2021 00:24:10 +0000 (19:24 -0500)]
sim: require AC_PROG_CPP explicitly
All the scripts were using this implicitly already, so there's no real
change for them, but we want to call it explicitly as the CPP tool is
used to generate nltvals.def.
Mike Frysinger [Mon, 22 Feb 2021 00:08:14 +0000 (19:08 -0500)]
sim: delete unused SIM_EXTRA_LIBDEPS
This was last used 15 years ago, so clearly not important enough to
keep around. Punt it.
Mike Frysinger [Mon, 22 Feb 2021 00:02:47 +0000 (19:02 -0500)]
sim: delete redundant SIM_EXTRA_ALL
We don't need a variable to add a dependency to the "all" target, and
having one doesn't really add value. Switch to the target directly for
the few ports that actually use this.
GDB Administrator [Sun, 28 Feb 2021 00:00:13 +0000 (00:00 +0000)]
Automatic date update in version.in
Lancelot SIX [Thu, 25 Feb 2021 00:30:49 +0000 (00:30 +0000)]
[PR gdb/27393] set directories: handle empty dirs.
As reported in gdb/27393, the 'directory' and 'set directories' commands
fail when parsing an empty dir name:
(gdb) set directories ""
/home/lsix/dev/gnu/binutils-gdb/gdbsupport/pathstuff.cc:132: internal-error: gdb::unique_xmalloc_ptr<char> gdb_abspath(const char*): Assertion `path != NULL && path[0] != '\0'' failed.
or
(gdb) dir :
/home/lsix/dev/gnu/binutils-gdb/gdbsupport/pathstuff.cc:132: internal-error: gdb::unique_xmalloc_ptr<char> gdb_abspath(const char*): Assertion `path != NULL && path[0] != '\0'' failed.
This patch fixes this issue by ignoring any attempt to add an empty
name to the source directories list. 'set dir ""' will reset the
directories list the same way 'set dir' would do it.
Tested on x86_64.
Tom Tromey [Sat, 27 Feb 2021 00:25:38 +0000 (17:25 -0700)]
Minor fix in skip_ctf_tests
I noticed an oddity in skip_ctf_tests -- for me it ends up caching the
string "!0", because it ends with 'return ![...]'. In Tcl, this is
just string concatenation.
The result works because the users of this function have unbraced if
conditions, like:
if [skip_ctf_tests] {
... which works because "if" re-parses the returned string as an
expression, and evaluates that.
There's only a latent bug here, but this is also un-idiomatic, so I am
checking in this patch to fix it. This way, if someone in the future
uses a braced condition (which is what I normally recommend), it will
continue to work.
gdb/testsuite/ChangeLog
2021-02-26 Tom Tromey <tom@tromey.com>
* lib/gdb.exp (skip_ctf_tests): Use expr on result.
GDB Administrator [Sat, 27 Feb 2021 00:00:21 +0000 (00:00 +0000)]
Automatic date update in version.in
Fangrui Song [Fri, 26 Feb 2021 17:25:45 +0000 (09:25 -0800)]
nm: Add --quiet to suppress "no symbols" diagnostic
PR binutils/27408
* readelf.c (quiet): New option flag.
(enum long_option_values): New enum to hold long option value.
(long_options): Add --quiet.
(usage): Mention --quiet.
(display_rel_file): If quiet is enabled, suppress "no symbols".
(main): Handle the new option.
* NEWS: Mention --quiet.
* docs/binutils.texi: Document --quiet.
Nick Clifton [Fri, 26 Feb 2021 16:37:30 +0000 (16:37 +0000)]
Correct an error message in the ARM assembler.
PR 27411
* config/tc-arm.c (do_t_add_sub): Correct error message.
* testsuite/gas/arm/pr27411.s: New test.
* testsuite/gas/arm/pr27411.d: New test driver.
* testsuite/gas/arm/pr27411.l: Expected error output for new test.
Tom de Vries [Fri, 26 Feb 2021 15:52:39 +0000 (15:52 +0000)]
Add support for decoding DWARF v5 DW_AT_addr_base tags.
* dwarf.c (display_debug_addr): Handle dwarf-5 .debug_addr bits.
Jan Vrany [Fri, 26 Feb 2021 14:34:04 +0000 (14:34 +0000)]
testsuite: Remove extra \n from expected output of tsv notifications
Commit
2450ad54 removed extra trailing \n from tsv notifications but
did not update gdb.trace/mi-tsv-changed.exp accordingly. This commit
removes the extra \n from expected output so gdb.trace/mi-tsv-changed.exp
passes again.
gdb/testsuite/ChangeLog:
* gdb.trace/mi-tsv-changed.exp (test_create_delete_modify_tsv):
Remove trailing \n from expected output.
Tom de Vries [Fri, 26 Feb 2021 13:30:10 +0000 (13:30 +0000)]
Add support for the split DWARF forms.
PR 27390
* dwarf.c: (skip_attr_bytes): Add support for DW_FORM_str* and
DW_FORM_addrx*.
(read_and_display_attr_value): Likewise.
Markus Metzger [Mon, 21 Dec 2020 07:14:55 +0000 (08:14 +0100)]
testsuite: note on use_gdb_stub usage
Add a note to the comment on use_gdb_stub explaining the use of this check
for skipping tests that spawn new inferiors as discussed here:
https://sourceware.org/pipermail/gdb-patches/2020-December/174186.html
Alan Modra [Fri, 26 Feb 2021 02:56:19 +0000 (13:26 +1030)]
Add PR27441 testcase
PR 27441
* testsuite/ld-plugin/pr27441a.c,
* testsuite/ld-plugin/pr27441b.c,
* testsuite/ld-plugin/pr27441c.c,
* testsuite/ld-plugin/pr27441c.d: New test.
* testsuite/ld-plugin/lto.exp: Run it.
Alan Modra [Wed, 24 Feb 2021 08:06:34 +0000 (18:36 +1030)]
libctf regen for NEWS
The previous regen was done on a tree without the new NEWS file.
* Makefile.in: Regenerate.
GDB Administrator [Fri, 26 Feb 2021 00:00:18 +0000 (00:00 +0000)]
Automatic date update in version.in
Kevin Buettner [Thu, 25 Feb 2021 23:00:43 +0000 (16:00 -0700)]
Fix date in ChangeLog
Kevin Buettner [Thu, 25 Feb 2021 22:25:49 +0000 (15:25 -0700)]
Add comment regarding include order of <sys/ptrace.h> and <asm/ptrace.h>
I added the same comment for nat/aarch64-linux-hw-point.c yesterday.
Christian suggested adding the comment for the other file that I had
identified as including both <sys/ptrace.h> and <asm/ptrace.h>.
I searched the sources in gdb/, but found no other files which include
both of these headers.
If possible, I would prefer to see us use <sys/ptrace.h> when possible,
however, from past experience, I've found that this file does not always
contain all of the constants, etc. required by the particular source
file.
gdb/ChangeLog:
* nat/aarch64-sve-linux-ptrace.h: Add comment regarding include
order for <sys/ptrace.h> and <asm/ptrace.h>.
Simon Marchi [Thu, 25 Feb 2021 20:52:29 +0000 (15:52 -0500)]
gdb: relax assertion in target_mourn_inferior
As reported in PR 26861, when killing an inferior on macOS, we hit the
assert:
../../gdb-10.1/gdb/target.c:2149: internal-error: void target_mourn_inferior(ptid_t): Assertion `ptid == inferior_ptid' failed.
This is because darwin_nat_target::kill passes a pid-only ptid to
target_mourn_inferior, with the pid of the current inferior:
target_mourn_inferior (ptid_t (inf->pid));
... which doesn't satisfy the assert in target_mourn_inferior:
gdb_assert (ptid == inferior_ptid);
The reason for this assertion is that target_mourn_inferior is a
prototype shared between GDB and GDBserver, so that shared code in
gdb/nat (used in both GDB and GDBserver) can call target_mourn_inferior.
In GDB's implementation, it is likely that some targets still rely on
inferior_ptid being set to "the current thread we are working on". So
until targets are completely decoupled from inferior_ptid (at least
their mourn_inferior implementations), we need to ensure the passed in
ptid matches inferior_ptid, to ensure the calling code called
target_mourn_inferior with the right global context.
However, I think the assert is a bit too restrictive. The
mourn_inferior operation works on an inferior, not a specific thread.
And by the time we call mourn_inferior, the threads of the inferior
don't exist anymore, the process is gone, so it doesn't really make
sense to require inferior_ptid to point a specific thread.
I looked at all the target_ops::mourn_inferior implementations, those
that read inferior_ptid only care about the pid field, which supports
the idea that only the inferior matters. Other implementations look at
the current inferior (call `current_inferior ()`).
I think it would make sense to change target_mourn_inferior to accept
only a pid rather than a ptid. It would then assert that the pid is the
same as the current inferior's pid. However, this would be a quite
involved change, so I'll keep it for later.
To fix the macOS issue immediately, I propose to relax the assert to
only compare the pids, as is done in this patch.
Another solution would obviously be to make darwin_nat_target::kill pass
inferior_ptid to target_mourn_inferior. However, the solution I propose
is more in line with where I think we want to go (passing a pid to
target_mourn_inferior).
gdb/ChangeLog:
PR gdb/26861
* target.c (target_mourn_inferior): Only compare pids in
target_mourn_inferior.
Change-Id: If2439ccc5aa67272ea16148a43c5362ef23fb2b8
Jan Matyas [Thu, 25 Feb 2021 07:27:09 +0000 (08:27 +0100)]
Fix initial thread state of non-threaded remote targets
This change fixes the initial state of the main thread of remote
targets which have no concept of threading. Such targets are
treated as single-threaded by gdb, and this single thread needs
to be initially set to the "resumed" state, in the same manner as
threads in thread-aware remote targets (see remote.c,
remote_target::remote_add_thread).
Without this fix, the following assert was triggered on thread-
unaware remote targets:
remote_target::select_thread_for_ambiguous_stop_reply(const target_waitstatus*): Assertion `first_resumed_thread != nullptr' failed.
The bug can be reproduced using gdbserver
* by disabling packets 'T' and 'qThreadInfo', or
* by disabling all thread-related packets.
The test suite has been updated to include these two scenarios, see
gdb.server/stop-reply-no-thread.exp.
Change-Id: I2c39c9de17e8d6922a8c1b9e259eb316a554a43d
Nick Clifton [Thu, 25 Feb 2021 17:50:44 +0000 (17:50 +0000)]
Add initial support for .debug_sup sections.
* dwarf.c (get_type_abbrev_from_form): Accept but ignore sup
forms.
(read_and_display_attr_value): Handle sup forms.
(display_debug_sup): New function. Displays the contents of a
.debug_sup section.
(load_debug_sup_file): New function. Loads the contents of a file
referenced by a .debug_sup section.
(check_for_and_load_links): Call load_debug_sup_file.
(debug_displays): Add entry for .debug_sup.
* dwarf.h (enum dwarf_section_display_enum): Add debug_sup.
* readelf.c (process_section_headers): Add support for debug_sup.
* doc/debug.options.texi: Note that the =links option will display
the contents of .debug_sup sections.
* NEWS: Mention the new support.
This page took 0.054334 seconds and 4 git commands to generate.