Split out eval_op_f_modulo

This splits BINOP_FORTRAN_MODULO into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* f-lang.c (eval_op_f_modulo): New function.
(evaluate_subexp_f): Use it.

Split out eval_op_f_floor

This splits UNOP_FORTRAN_FLOOR into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* f-lang.c (eval_op_f_floor): New function.
(evaluate_subexp_f): Use it.

Split out eval_op_f_ceil

This splits UNOP_FORTRAN_CEILING into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* f-lang.c (eval_op_f_ceil): New function.
(evaluate_subexp_f): Use it.

Split out eval_op_f_mod

This splits BINOP_MOD into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* f-lang.c (eval_op_f_mod): New function.
(evaluate_subexp_f): Use it.

Split out eval_op_f_abs

This splits UNOP_ABS into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* f-lang.c (eval_op_f_abs): New function.
(evaluate_subexp_f): Use it.

Split out eval_op_type

This splits OP_TYPE into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_type): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_postdec

This splits UNOP_POSTDECREMENT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_postdec): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_postinc

This splits UNOP_POSTINCREMENT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_postinc): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_predec

This splits UNOP_PREDECREMENT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_predec): New file.
(evaluate_subexp_standard): Use it.

Split out eval_op_preinc

This splits UNOP_PREINCREMENT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_preinc): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_memval

This splits UNOP_MEMVAL into a new function for future use.  This new
function is also used to hande UNOP_MEMVAL_TYPE.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_memval): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_alignof

This splits UNOP_ALIGNOF into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_alignof): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_ind

This splits UNOP_IND into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_ind): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_lognot

This splits UNOP_LOGICAL_NOT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_lognot): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_complement

This splits UNOP_COMPLEMENT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_complement): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_neg

This splits UNOP NEG into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_neg): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_plus

This splits UNOP_PLUS into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_plus): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_repeat

This splits BINOP_REPEAT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_repeat): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_leq

This splits BINOP_LEQ into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_leq): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_geq

This splits BINOP_GEQ into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_geq): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_gtr

This splits BINOP_GTR into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_gtr): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_less

This splits BINOP_LESS into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_less): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_notequal

This splits BINOP_NOTEQUAL into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_notequal): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_equal

This splits BINOP_EQUAL into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_equal): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_subscript

This splits BINOP_SUBSCRIPT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_subscript): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_binary

This splits out a new eval_op_binary helper function.  This function
can handle several different binary operations:

    case BINOP_EXP:
    case BINOP_MUL:
    case BINOP_DIV:
    case BINOP_INTDIV:
    case BINOP_REM:
    case BINOP_MOD:
    case BINOP_LSH:
    case BINOP_RSH:
    case BINOP_BITWISE_AND:
    case BINOP_BITWISE_IOR:
    case BINOP_BITWISE_XOR:

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_binary): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_sub

This splits BINOP_SUB into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_sub): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_add

This splits BINOP_ADD into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_add): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_member

This splits STRUCTOP_MEMBER into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_member): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_structop_ptr

This splits STRUCTOP_PTR into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_structop_ptr): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_structop_struct

This splits STRUCTOP_STRUCT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_structop_struct): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_ternop

This splits TERNOP_SLICE into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_ternop): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_concat

This splits BINOP_CONCAT into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_concat): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_objc_selector

This splits OP_OBJC_SELECTOR into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_objc_selector): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_string

This splits OP_STRING into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_string): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_register

This splits OP_REGISTER into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_register): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_func_static_var

This splits OP_FUNC_STATIC_VAR into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_func_static_var): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_var_msym_value

This splits OP_VAR_MSYM_VALUE into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_var_msym_value): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_var_entry_value

This splits OP_VAR_ENTRY_VALUE into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_var_entry_value): New function.
(evaluate_subexp_standard): Use it.

Split out eval_op_scope

This splits OP_SCOPE into a new function for future use.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

* eval.c (eval_op_scope): New function.
(evaluate_subexp_standard): Use it.

sim: delete unused BUILD_LIBS setting

This hasn't been initialized anywhere for years.  It used to be for
passing in the path to libiberty, but that stopped happening long ago.
Delete it to simplify the build logic.

sim: igen: update options API

This local macro doesn't take any args, so adjust the API to match.
No one really noticed as this is behind code that is not normally
built, only when a dev specifically tries to compile it.

Automatic date update in version.in

Regenerated

sim: testsuite: merge into toplevel automake

This allows us to delete most of our custom test logic,
and avoids a recursive make for minor speed up.

sim: switch top level to automake

This doesn't gain us much by itself, but it sets us up for using more
features as we try to unify ports and avoid recursive make.

Automatic date update in version.in

Fix build bug in ada-lang.c

An earlier patch of mine introduced a build failure in ada-lang.c.  A
couple of "to_string" calls were not namespace-qualified.  In the
failing setup, the std string_view is being used, and so (apparently)
ADL doesn't find gdb::to_string.

This patch, from the bug, fixes the problem.

gdb/ChangeLog
2021-03-06  Chernov Sergey  <klen_s@mail.ru>

PR gdb/27528:
* ada-lang.c (ada_fold_name): Use gdb::to_string.

Move dwarf2_get_dwz_file to dwarf2/dwz.h

This moves dwarf2_get_dwz_file and some helper code to dwarf2/dwz.h.
The main benefit of this is just shrinking dwarf2/read.c a little bit.

gdb/ChangeLog
2021-03-06  Tom Tromey  <tom@tromey.com>

* dwarf2/sect-names.h (dwarf2_elf_names): Declare.
* dwarf2/read.h (dwarf2_get_dwz_file): Move to dwz.h.
* dwarf2/read.c (dwarf2_elf_names): No longer static.
(locate_dwz_sections, dwz_search_other_debugdirs)
(dwarf2_get_dwz_file): Move to dwz.c.
* dwarf2/dwz.h (dwarf2_get_dwz_file): Move declaration from
read.h.
* dwarf2/dwz.c (locate_dwz_sections, dwz_search_other_debugdirs)
(dwarf2_get_dwz_file): Move from read.c.

Include scoped_fd.h in debuginfod-support.h

debuginfod-support.h requires scoped_fd, so include the header here.

gdb/ChangeLog
2021-03-06  Tom Tromey  <tom@tromey.com>

* debuginfod-support.h: Include scoped_fd.h.

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.

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.

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.

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.

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.

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.

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.

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.

Automatic date update in version.in

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Automatic date update in version.in

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

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.

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.

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.

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.

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.

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.

Automatic date update in version.in

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.

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.

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.

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.

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.

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}.

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.

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.

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.

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.

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.

PR27493, objcopy --weaken-symbol does not weaken undefined symbols

PR 27493
* objcopy.c (filter_symbols): Apply --weaken to undefined symbols.
* NEWS: Mention feature.

--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.

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.

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.

Automatic date update in version.in

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.

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.

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.

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.

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.