Use 'const' in ada-exp.y

I found a few spots in ada-exp.y that could use 'const'.
Tested by rebuilding.

2021-07-02  Tom Tromey  <tromey@adacore.com>

* ada-exp.y (chop_selector, chop_separator, write_selectors)
(write_ambiguous_var, get_symbol_field_type): Use const.

Document TUI improvements in the manual & NEWS

gdb/ChangeLog:
yyyy-mm-dd  Pedro Alves  <pedro@palves.net>
    Hannes Domani  <ssbssa@yahoo.de>

* NEWS: Add new "TUI Improvements" section and mention mouse
support and that unrecognized special keys are now passed to
GDB.  Mention Python Window.click in the Python improvements
section.

gdb/doc/ChangeLog:
yyyy-mm-dd  Pedro Alves  <pedro@palves.net>

* gdb.texinfo (TUI): <TUI Mouse Support>: New node/section.

Co-Authored-By: Hannes Domani <ssbssa@yahoo.de>
Change-Id: I0d79a795d8ac561fd28cdc5184bff029ba28bc64

Fix an illegal memory access triggered by an attempt to parse a corrupt input file.

PR 28046
* dwarf2.c (read_ranges): Check that range_ptr does not exceed
range_end.

PR28048, heap-buffer-overflow on readelf -Ww

PR 28048
* dwarf.c (get_type_signedness): Don't run off end of buffer
printing DW_FORM_string attribute.

Re: Fix minor NDS32 renaming snafu

Some extern declarations differ in constnes to their definitions too.
Let's make sure this sort of thing doesn't happen again, but putting
the externs in a header where they belong.

gas/
* config/tc-nds32.c (nds32_keyword_gpr): Don't declare.
(md_begin): Constify k.
opcodes/
* nds32-dis.c (nds32_find_reg_keyword): Constify arg and return.
(nds32_parse_audio_ext, nds32_parse_opcode): Constify psys_reg.
(nds32_field_table, nds32_opcode_table, nds32_keyword_table),
(nds32_opcodes, nds32_operand_fields, nds32_keywords),
(nds32_keyword_gpr): Move declarations to..
* nds32-asm.h: ..here, constifying to match definitions.

Fix minor NDS32 renaming snafu.

* config/tc-nds32.c: Change all references of keyword_gpr to
nds32_keyword_gpr.

sim: unify reserved instruction bits settings

Move these options up to the common dir so we only test & export
them once across all ports.

The setting only affects igen based ports, and they were turning
this on by default, so keep the default in place.

sim: m32r: merge with common configure script

Now that the traps code has been unified, the configure script has no
unique logic in it, so it can be merged into the single common one.

sim: m32r: reformat linux traps code

Do this as a sep commit to try and make the history easier to review.

sim: m32r: unify ELF & Linux traps logic

This makes the simulator work the same regardless of the target (bare
metal m32r-elf or Linux m32r-linux-gnu) by unifying the traps code.
It was mostly already the same with the only difference being support
for trap #2 reserved for Linux syscalls.  We can move that logic to
runtime by checking the current environment operating mode instead.

sim: m32r: replace custom endian helpers with sim-endian

This improves the logic a bit by making the host<->target translations
a bit more clear.  The structs still bleed way too much between the two
worlds, but let's fix one thing at a time.

sim: m32r: fix virtual environment with Linux targets

We don't want to handle Linux syscalls when in the virtual environment,
just the user environment, so adjust the Linux traps logic to check for
that specifically (instead of just skipping the operating environment).

Also tweak some testcases to explicitly specify the environment they run
under rather than relying on the default matching their needs.  This gets
the tests passing for all m32r targets.

sim: m32r: namespace Linux syscall table

The use of __NR_ defines in here conflicts a lot with the standard
host syscalls, sometimes leading to build errors (when the numbers
happen to be the same we get duplicate case handlers), and other
times leading to misbehavior (where the m32r syscall # is not what
is actually checked).

Namespace these using the standard that we already use: change the
__NR_ to TARGET_LINUX_SYS_ with a simple `sed`.

Also add a few missing includes so the code at least compiles.

Automatic date update in version.in

cgen: split GUILE setting out

This makes it easier to override to point to an older version of guile.
The current cgen code doesn't work with guile-2, so need to point to an
older guile-1.8.

opcodes: constify & local meps macros

Avoid exporting this common variable name into writable data.

opcodes: cleanup nds32 variables

For the variables that don't need to be exported, mark them static.
For the ones shared between modules, add a "nds32_" prefix to avoid
collisions with these common variable names.

opcodes: constify & localize z80 opcodes

These aren't used outside of this module, and are never modified.
Mark it static to avoid bad exported variable name issues.

opcodes: constify & scope microblaze opcodes

This is exporting the variable "opcodes" as a large writable blob.
This is not a namespace friendly name, so add a "microblaze" prefix,
and then sprinkle const over its definition & use.

opcodes: constify aarch64_opcode_tables

This table is huge (~350k), so stop putting it into writable .data
since it's only const data.

Partially fix debuginfod tests in binutils testsuite.

PR 28029
* testsuite/binutils-all/debuginfod.exp: Replace -wK with -wk.

Linux: Access memory even if threads are running

Currently, on GNU/Linux, if you try to access memory and you have a
running thread selected, GDB fails the memory accesses, like:

 (gdb) c&
 Continuing.
 (gdb) p global_var
 Cannot access memory at address 0x555555558010

Or:

 (gdb) b main
 Breakpoint 2 at 0x55555555524d: file access-mem-running.c, line 59.
 Warning:
 Cannot insert breakpoint 2.
 Cannot access memory at address 0x55555555524d

This patch removes this limitation.  It teaches the native Linux
target to read/write memory even if the target is running.  And it
does this without temporarily stopping threads.  We now get:

 (gdb) c&
 Continuing.
 (gdb) p global_var
 $1 = 123
 (gdb) b main
 Breakpoint 2 at 0x555555555259: file access-mem-running.c, line 62.

(The scenarios above work correctly with current GDBserver, because
GDBserver temporarily stops all threads in the process whenever GDB
wants to access memory (see prepare_to_access_memory /
done_accessing_memory).  Freezing the whole process makes sense when
we need to be sure that we have a consistent view of memory and don't
race with the inferior changing it at the same time as GDB is
accessing it.  But I think that's a too-heavy hammer for the default
behavior.  I think that ideally, whether to stop all threads or not
should be policy decided by gdb core, probably best implemented by
exposing something like gdbserver's prepare_to_access_memory /
done_accessing_memory to gdb core.)

Currently, if we're accessing (reading/writing) just a few bytes, then
the Linux native backend does not try accessing memory via
/proc/<pid>/mem and goes straight to ptrace
PTRACE_PEEKTEXT/PTRACE_POKETEXT.  However, ptrace always fails when
the ptracee is running.  So the first step is to prefer
/proc/<pid>/mem even for small accesses.  Without further changes
however, that may cause a performance regression, due to constantly
opening and closing /proc/<pid>/mem for each memory access.  So the
next step is to keep the /proc/<pid>/mem file open across memory
accesses.  If we have this, then it doesn't make sense anymore to even
have the ptrace fallback, so the patch disables it.

I've made it such that GDB only ever has one /proc/<pid>/mem file open
at any time.  As long as a memory access hits the same inferior
process as the previous access, then we reuse the previously open
file.  If however, we access memory of a different process, then we
close the previous file and open a new one for the new process.

If we wanted, we could keep one /proc/<pid>/mem file open per
inferior, and never close them (unless the inferior exits or execs).
However, having seen bfd patches recently about hitting too many open
file descriptors, I kept the logic to have only one file open tops.
Also, we need to handle memory accesses for processes for which we
don't have an inferior object, for when we need to detach a
fork-child, and we'd probaly want to handle caching the open file for
that scenario (no inferior for process) too, which would probably end
up meaning caching for last non-inferior process, which is very much
what I'm proposing anyhow.  So always having one file open likely ends
up a smaller patch.

The next step is handling the case of GDB reading/writing memory
through a thread that is running and exits.  The access should not
result in a user-visible failure if the inferior/process is still
alive.

Once we manage to open a /proc/<lwpid>/mem file, then that file is
usable for memory accesses even if the corresponding lwp exits and is
reaped.  I double checked that trying to open the same
/proc/<lwpid>/mem path again fails because the lwp is really gone so
there's no /proc/<lwpid>/ entry on the filesystem anymore, but the
previously open file remains usable.  It's only when the whole process
execs that we need to reopen a new file.

When the kernel destroys the whole address space, i.e., when the
process exits or execs, the reads/writes fail with 0 aka EOF, in which
case there's nothing else to do than returning a memory access
failure.  Note this means that when we get an exec event, we need to
reopen the file, to access the process's new address space.

If we need to open (or reopen) the /proc/<pid>/mem file, and the LWP
we're opening it for exits before we open it and before we reap the
LWP (i.e., the LWP is zombie), the open fails with EACCES.  The patch
handles this by just looking for another thread until it finds one
that we can open a /proc/<pid>/mem successfully for.

If we need to open (or reopen) the /proc/<pid>/mem file, and the LWP
we're opening has exited and we already reaped it, which is the case
if the selected thread is in THREAD_EXIT state, the open fails with
ENOENT.  The patch handles this the same way as a zombie race
(EACCES), instead of checking upfront whether we're accessing a
known-exited thread, because that would result in more complicated
code, because we also need to handle accessing lwps that are not
listed in the core thread list, and it's the core thread list that
records the THREAD_EXIT state.

The patch includes two testcases:

#1 - gdb.base/access-mem-running.exp

  This is the conceptually simplest - it is single-threaded, and has
  GDB read and write memory while the program is running.  It also
  tests setting a breakpoint while the program is running, and checks
  that the breakpoint is hit immediately.

#2 - gdb.threads/access-mem-running-thread-exit.exp

  This one is more elaborate, as it continuously spawns short-lived
  threads in order to exercise accessing memory just while threads are
  exiting.  It also spawns two different processes and alternates
  accessing memory between the two processes to exercise the reopening
  the /proc file frequently.  This also ends up exercising GDB reading
  from an exited thread frequently.  I confirmed by putting abort()
  calls in the EACCES/ENOENT paths added by the patch that we do hit
  all of them frequently with the testcase.  It also exits the
  process's main thread (i.e., the main thread becomes zombie), to
  make sure accessing memory in such a corner-case scenario works now
  and in the future.

The tests fail on GNU/Linux native before the code changes, and pass
after.  They pass against current GDBserver, again because GDBserver
supports memory access even if all threads are running, by
transparently pausing the whole process.

gdb/ChangeLog:
yyyy-mm-dd  Pedro Alves  <pedro@palves.net>

PR mi/15729
PR gdb/13463
* linux-nat.c (linux_nat_target::detach): Close the
/proc/<pid>/mem file if it was open for this process.
(linux_handle_extended_wait) <PTRACE_EVENT_EXEC>: Close the
/proc/<pid>/mem file if it was open for this process.
(linux_nat_target::mourn_inferior): Close the /proc/<pid>/mem file
if it was open for this process.
(linux_nat_target::xfer_partial): Adjust.  Do not fall back to
inf_ptrace_target::xfer_partial for memory accesses.
(last_proc_mem_file): New.
(maybe_close_proc_mem_file): New.
(linux_proc_xfer_memory_partial_pid): New, with bits factored out
from linux_proc_xfer_partial.
(linux_proc_xfer_partial): Delete.
(linux_proc_xfer_memory_partial): New.

gdb/testsuite/ChangeLog
yyyy-mm-dd  Pedro Alves  <pedro@palves.net>

PR mi/15729
PR gdb/13463
* gdb.base/access-mem-running.c: New.
* gdb.base/access-mem-running.exp: New.
* gdb.threads/access-mem-running-thread-exit.c: New.
* gdb.threads/access-mem-running-thread-exit.exp: New.

Change-Id: Ib3c082528872662a3fc0ca9b31c34d4876c874c9

readelf: Reset file position to beginning for thin archive members

* readelf.c (process_archive): Reset file position to the
beginning when calling process_object for thin archive members.
* testsuite/binutils-all/readelf.exp: Add test.
* testsuite/binutils-all/readelf.h.thin: New file.

arm: don't treat XScale features as part of the FPU [PR 28031]

Although the XScale and its iwMMX extensions are implemented in the
Arm co-processor space, they are not considered to be part of the FPU
specification.  In particular, they cannot be enabled or disabled via
a .fpu directive.  It's therefore incorrect to strip these properties
when a new .fpu directive is encountered.

Note that the legacy Maverick co-processor is considered to be a FPU
and it is possible to control this via the .fpu directive.

include:

PR gas/28031
* opcode/arm.h (FPU_ANY): Exclude XScale-related features.

Automatic date update in version.in

sim: ppc: unify (most) compiler warnings with common code

Copy most of the common build warning logic over from the common
code to help keep code behavior a bit consistent, and turn them
on by default.  We disable a few flags for now until we can clean
the code up.

sim: cris/frv/iq2000/lm32: merge with common configure script

Now that the scache logic has been migrated into the common code,
there's nothing specific in these configure scripts, so merge them
into the common one.

The frv unique logic can be moved to a dedicated include and merged
in the common configure since the flag has been scoped to the arch.

sim: unify scache settings

The cgen scache module is enabled by every cgen port, and with the
same default value of 16k (which matches the common default value).
Let's pull this option out of the individual ports (via CPPFLAGS)
and into the common code (via config.h).

The object itself is compiled only for cgen ports atm, so that part
doesn't change.  The scache code is initialized dynamically via the
modules.c logic.  That's why the profile code needs an additional
CGEN_ARCH check.

This will allow us to collapse arch configure files more.  Merging
the source files will require more future work, but integrating the
cgen & non-cgen worlds itself will take a lot.

sim: frv: scope the unique configure flag

This will make it possible to merge into the common configure by
making sure we never collide with other arches.

sim: move scache init to dynamic modules.c

Use the new modules.c framework to find & initialize this module.

sim: move profile init to dynamic modules.c

Use the new modules.c framework to find & initialize this module.

sim: move trace init to dynamic modules.c

Use the new modules.c framework to find & initialize this module.

sim: move engine init to dynamic modules.c

Use the new modules.c framework to find & initialize this module.

Mark .gnu.debuglto_.debug_* as SHT_MIPS_DWARF

PR mips/28009
* bfd/elfxx-mips.c (_bfd_mips_elf_section_from_shdr,
_bfd_mips_elf_fake_sections): Mark LTO debug info as
SHT_MIPS_DWARF.

Handle DW_FORM_implicit_const when displaying an attribute

* dwarf.c (read_and_display_attr_value): Handle
DW_FORM_implicit_const.

Fix signedness of def_cfa_sf and def_cfa_offset_sf

 * dwarf.c (display_debug_frames): Both DW_CFA_def_cfa_sf
 and DW_CFA_def_cfa_offset_sf have a signed offset.

sim: bfin: merge with common configure script

Now that the model logic has been migrated into the runtime, there's
nothing specific in the bfin configure code, so merge it into the
common one.

sim: delete unused model settings

These were never fully migrated from the psim to common code, and since
we've finished moving the logic into the runtime sim state, we won't ever
need these.  So punt them.

sim: move default model to the runtime sim state

This kills off another compile-time option by moving the setting to
the individual arch runtimes.  This will allow dynamic selection by
the arch when doing a single build with multiple arches.

The sim_model_init rework is a little funky.  In the past it was
disabled entirely if no default model was set.  We maintain the
spirit of the logic by gating the fallback logic on whether the
port has defined any models.

sim: namespace sim_machs

We want to do a single build with all arches in one binary which means
we need to namespace sim_machs on a per-arch basis.  Move it from a
global variable to the sim description structure so it can be setup at
runtime.

Changing the SIM_MODEL->num from an enum to an int is unfortunate, but
we specifically don't want to maintain a centralized list anymore, and
this was never used directly in common code, just passed to per-arch
callbacks.

sim: ppc: fix printf warnings

This code hits some format-zero-length warnings, so hack the code
like we did in the common layers.

sim: use -Wunused-but-set-parameter

The code is already clean, so sync this over from gdb warning.m4.
Also shuffle the order of the flags a bit to match the current gdb
warning.m4 code.

sim: fix arch Makefile regen when unified

The $(arch) variable is only setup for cgen ports, so calculate this
value dynamically.  We also need to generate multiple inputs in order
to properly recreate the subdir Makefile, so list them all.

sim: use -Wno-error=maybe-uninitialized

We have some code tripping this warning, but it depends on the gcc
version & optimization levels.  We've added some hints to the code
so some versions of gcc work better, but still not all.  Let's just
disable the warning like gdb does.

sim: callback: add check for HAVE_KILL

Fix building on systems w/out a kill function (e.g. Windows).

sim: cris: remove cgen-ops.h include hack

This has been upstreamed into cgen itself.

sim: model: constify sim_machs storage

The array of pointers is never modified, so mark it const so it ends
up in the read-only data section.

Automatic date update in version.in

gdb: introduce FRAME_SCOPED_DEBUG_ENTER_EXIT

Introduce FRAME_SCOPED_DEBUG_ENTER_EXIT and use it to print enter/exit
messages in important frame-related functions.  I think this helps
understand which lower-level operations are done as part of which
higher-level operation.  And it helps visually skip over a higher-level
operation you are not interested in.

Here's an example, combined with some py-unwind messages:

    [frame] frame_unwind_find_by_frame: enter
      [frame] frame_unwind_find_by_frame: this_frame=0
      [frame] frame_unwind_try_unwinder: trying unwinder "dummy"
      [frame] frame_unwind_try_unwinder: no
      [frame] frame_unwind_try_unwinder: trying unwinder "dwarf2 tailcall"
      [frame] frame_unwind_try_unwinder: no
      [frame] frame_unwind_try_unwinder: trying unwinder "inline"
      [frame] frame_unwind_try_unwinder: no
      [frame] frame_unwind_try_unwinder: trying unwinder "jit"
      [frame] frame_unwind_try_unwinder: no
      [frame] frame_unwind_try_unwinder: trying unwinder "python"
      [py-unwind] pyuw_sniffer: enter
        [frame] frame_unwind_register_value: enter
          [frame] frame_unwind_register_value: frame=-1, regnum=7(rsp)
          [frame] frame_unwind_register_value:   -> register=7 bytes=[40ddffffff7f0000]
        [frame] frame_unwind_register_value: exit
        [py-unwind] pyuw_sniffer: frame=0, sp=0x7fffffffdd40, pc=0x5555555551ec
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_unwind_register_value: enter
          [frame] frame_unwind_register_value: frame=-1, regnum=6(rbp)
          [frame] frame_unwind_register_value:   -> register=6 bytes=[50ddffffff7f0000]
        [frame] frame_unwind_register_value: exit
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] get_prev_frame: enter
          [frame] get_prev_frame_always_1: enter
            [frame] get_prev_frame_always_1: this_frame=-1
            [frame] get_prev_frame_always_1:   -> {level=0,type=NORMAL_FRAME,unwind=0x5588ee3d17c0,pc=0x5555555551ec,id=<not computed>,func=<unknown>} // cached
          [frame] get_prev_frame_always_1: exit
        [frame] get_prev_frame: exit
        [frame] value_fetch_lazy_register: (frame=0, regnum=6(rbp), ...) -> register=6 bytes=[50ddffffff7f0000]
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_unwind_register_value: enter
          [frame] frame_unwind_register_value: frame=-1, regnum=7(rsp)
          [frame] frame_unwind_register_value:   -> register=7 bytes=[40ddffffff7f0000]
        [frame] frame_unwind_register_value: exit
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] get_prev_frame: enter
          [frame] get_prev_frame_always_1: enter
            [frame] get_prev_frame_always_1: this_frame=-1
            [frame] get_prev_frame_always_1:   -> {level=0,type=NORMAL_FRAME,unwind=0x5588ee3d1824,pc=0x5555555551ec,id=<not computed>,func=<unknown>} // cached
          [frame] get_prev_frame_always_1: exit
        [frame] get_prev_frame: exit
        [frame] value_fetch_lazy_register: (frame=0, regnum=7(rsp), ...) -> register=7 bytes=[40ddffffff7f0000]
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_unwind_register_value: enter
          [frame] frame_unwind_register_value: frame=-1, regnum=16(rip)
          [frame] frame_unwind_register_value:   -> register=16 bytes=[ec51555555550000]
        [frame] frame_unwind_register_value: exit
        [frame] frame_id_p: l={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] frame_id_eq: l={stack=<sentinel>,!code,special=0x0000000000000000}, r={stack=<sentinel>,!code,special=0x0000000000000000} -> 1
        [frame] get_prev_frame: enter
          [frame] get_prev_frame_always_1: enter
            [frame] get_prev_frame_always_1: this_frame=-1
            [frame] get_prev_frame_always_1:   -> {level=0,type=NORMAL_FRAME,unwind=0x5588ee3d1888,pc=0x5555555551ec,id=<not computed>,func=<unknown>} // cached
          [frame] get_prev_frame_always_1: exit
        [frame] get_prev_frame: exit
        [frame] value_fetch_lazy_register: (frame=0, regnum=16(rip), ...) -> register=16 bytes=[ec51555555550000]
        [py-unwind] pyuw_sniffer: frame claimed by unwinder test unwinder
      [py-unwind] pyuw_sniffer: exit
      [frame] frame_unwind_try_unwinder: yes
    [frame] frame_unwind_find_by_frame: exit

gdb/ChangeLog:

* frame.h (FRAME_SCOPED_DEBUG_ENTER_EXIT): New.
* frame.c (compute_frame_id, get_prev_frame_always_1,
get_prev_frame): Use FRAME_SCOPED_DEBUG_ENTER_EXIT.
* frame-unwind.c (frame_unwind_find_by_frame): Likewise.
(frame_unwind_register_value): Likewise.

Change-Id: I45b69b4ed962e70572bc55b8adfb211483c1eeed

gdb: add names to unwinders, add debug messages when looking for unwinder

I wrote this while debugging a problem where the expected unwinder for a
frame wasn't used.  It adds messages to show which unwinders are
considered for a frame, why they are not selected (if an exception is
thrown), and finally which unwinder is selected in the end.

To be able to show a meaningful, human-readable name for the unwinders,
add a "name" field to struct frame_unwind, and update all instances to
include a name.

Here's an example of the output:

    [frame] frame_unwind_find_by_frame: this_frame=0
    [frame] frame_unwind_try_unwinder: trying unwinder "dummy"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "dwarf2 tailcall"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "inline"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "jit"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "python"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "amd64 epilogue"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "i386 epilogue"
    [frame] frame_unwind_try_unwinder: no
    [frame] frame_unwind_try_unwinder: trying unwinder "dwarf2"
    [frame] frame_unwind_try_unwinder: yes

gdb/ChangeLog:

* frame-unwind.h (struct frame_unwind) <name>: New.  Update
instances everywhere to include this field.
* frame-unwind.c (frame_unwind_try_unwinder,
frame_unwind_find_by_frame): Add debug messages.

Change-Id: I813f17777422425f0d08b22499817b23922e8ddb

gdb: introduce frame_debug_printf

Introduce frame_debug_printf, to convert the "frame" debug messages to
the new system.  Replace fprint_frame with a frame_info::to_string
method that returns a string, like what was done with
frame_id::to_string.  This makes it easier to use with
frame_debug_printf.

gdb/ChangeLog:

* frame.h (frame_debug_printf): New.
* frame.c: Use frame_debug_printf throughout when printing frame
debug messages.
* amd64-windows-tdep.c: Likewise.
* value.c: Likewise.

gdb/testsuite/ChangeLog:

* gdb.dwarf2/dw2-reg-undefined.exp: Update regexp.

Change-Id: I3c230b0814ea81c23af3e1aca1aac8d4ba91d726

gdb: make frame_debug a boolean

gdb/ChangeLog:

* frame.h (frame_debug): Change type to bool.
* frame.c (frame_debug): Change type to bool.
(_initialize_frame): Adjust.

Change-Id: I27b5359a25ad53ac42618b5708a025c348a1eeda

Add the netbsdpe configuration to the list of obsolete targets.

* config.bfd (obsolete configurations): Add netbsdpe.

gdb: remove duplicate declaration of 'find_thread_ptid'

There are two declarations of 'find_thread_ptid' in gdbthread.h
with the same signature:

  /* Find (non-exited) thread PTID of inferior INF.  */
  extern thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);

and

  /* Search function to lookup a (non-exited) thread by 'ptid'.  Only
     searches in threads of INF.  */
  extern struct thread_info *find_thread_ptid (inferior *inf, ptid_t ptid);

Retain the former, remove the latter.  Tested by rebuilding.

gdb/ChangeLog:
2021-06-29  Tankut Baris Aktemur  <tankut.baris.aktemur@intel.com>

* gdbthread.h (find_thread_ptid): Remove the duplicate declaration.

sim: io: add printf attributes to vprintf funcs too

The compiler can still do basic format checks with vprintf style
funcs, so add the printf attribute to these.

sim: callback: add printf attributes

This helps these funcs get printf format checking coverage.

The sim-io.c hack as a result is a bit unfortunate, but the compiler
throws warnings when printing with empty strings.  In this one case,
we actually want that due to the side-effect of the callback halting
execution for us.

sim: callback: drop unused printf helpers

These cover functions aren't used anywhere, so drop them.  There was
one caller, but it's old DOS code that most likely hasn't been tested
in years, so just delete that too.

sim: cgen: require long long support

We require C11 now, so we can assume & require long long exists.
Drop this old code that hasn't been used for a long long time.

Automatic date update in version.in

gdb: use gdb_bfd_count_sections in macho_symfile_offsets

When loading a mach-o (macOS) executable and trying to set a breakpoint,
a GDB built with ASan or -D_GLIBCXX_DEBUG will crash with an
out-of-bound vector access.  This can be reproduced on Linux using the
repro files in bug 28017 [1]:

    $ ./gdb -nx --data-directory=data-directory -q repro/test -ex "b main" -batch
    /usr/include/c++/11.1.0/debug/vector:445:
    In function:
        std::__debug::vector<_Tp, _Allocator>::const_reference
        std::__debug::vector<_Tp,
        _Allocator>::operator[](std::__debug::vector<_Tp,
        _Allocator>::size_type) const [with _Tp = long unsigned int; _Allocator
        = std::allocator<long unsigned int>; std::__debug::vector<_Tp,
        _Allocator>::const_reference = const long unsigned int&;
        std::__debug::vector<_Tp, _Allocator>::size_type = long unsigned int]

    Error: attempt to subscript container with out-of-bounds index 13, but
    container only holds 13 elements.

    Objects involved in the operation:
        sequence "this" @ 0x0x61300000a590 {
          type = std::__debug::vector<unsigned long, std::allocator<unsigned long> >;
        }

The out-of-bound access happens here:

    #0  0x00007ffff6405d22 in raise () from /usr/lib/libc.so.6
    #1  0x00007ffff63ef862 in abort () from /usr/lib/libc.so.6
    #2  0x00007ffff664e21e in __gnu_debug::_Error_formatter::_M_error() const [clone .cold] from /usr/lib/libstdc++.so.6
    #3  0x000055555699e5ff in std::__debug::vector<unsigned long, std::allocator<unsigned long> >::operator[] (this=0x61300000a590, __n=13) at /usr/include/c++/11.1.0/debug/vector:445
    #4  0x0000555556a58c17 in objfile::section_offset (this=0x61300000a4c0, section=0x55555bbe4ac0 <_bfd_std_section>) at /home/simark/src/binutils-gdb/gdb/objfiles.h:644
    #5  0x0000555556a58cac in obj_section::offset (this=0x62100016d2a8) at /home/simark/src/binutils-gdb/gdb/objfiles.h:838
    #6  0x0000555556a58cfa in obj_section::addr (this=0x62100016d2a8) at /home/simark/src/binutils-gdb/gdb/objfiles.h:850
    #7  0x000055555779f5f7 in sort_cmp (sect1=0x62100016d2a8, sect2=0x62100016d170) at /home/simark/src/binutils-gdb/gdb/objfiles.c:902
    #8  0x00005555577aae35 in __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(obj_section const*, obj_section const*)>::operator()<obj_section**, obj_section**> (this=0x7fffffffa9e0, __it1=0x60c000015970, __it2=0x60c000015940) at /usr/include/c++/11.1.0/bits/predefined_ops.h:158
    #9  0x00005555577aa2b8 in std::__insertion_sort<obj_section**, __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(obj_section const*, obj_section const*)> > (__first=0x60c000015940, __last=0x60c0000159c0, __comp=...) at /usr/include/c++/11.1.0/bits/stl_algo.h:1826
    #10 0x00005555577a8e26 in std::__final_insertion_sort<obj_section**, __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(obj_section const*, obj_section const*)> > (__first=0x60c000015940, __last=0x60c0000159c0, __comp=...) at /usr/include/c++/11.1.0/bits/stl_algo.h:1871
    #11 0x00005555577a723c in std::__sort<obj_section**, __gnu_cxx::__ops::_Iter_comp_iter<bool (*)(obj_section const*, obj_section const*)> > (__first=0x60c000015940, __last=0x60c0000159c0, __comp=...) at /usr/include/c++/11.1.0/bits/stl_algo.h:1957
    #12 0x00005555577a50f4 in std::sort<obj_section**, bool (*)(obj_section const*, obj_section const*)> (__first=0x60c000015940, __last=0x60c0000159c0, __comp=0x55555779f4e7 <sort_cmp(obj_section const*, obj_section const*)>) at /usr/include/c++/11.1.0/bits/stl_algo.h:4875
    #13 0x00005555577a147e in update_section_map (pspace=0x61200001d2c0, pmap=0x6030000d40b0, pmap_size=0x6030000d40b8) at /home/simark/src/binutils-gdb/gdb/objfiles.c:1165
    #14 0x00005555577a19a0 in find_pc_section (pc=0x100003fa0) at /home/simark/src/binutils-gdb/gdb/objfiles.c:1212
    #15 0x00005555576dd39e in lookup_minimal_symbol_by_pc_section (pc_in=0x100003fa0, section=0x0, prefer=lookup_msym_prefer::TEXT, previous=0x0) at /home/simark/src/binutils-gdb/gdb/minsyms.c:750
    #16 0x00005555576de552 in lookup_minimal_symbol_by_pc (pc=0x100003fa0) at /home/simark/src/binutils-gdb/gdb/minsyms.c:986
    #17 0x0000555557d44b54 in find_pc_sect_line (pc=0x100003fa0, section=0x62100016d170, notcurrent=0) at /home/simark/src/binutils-gdb/gdb/symtab.c:3163
    #18 0x0000555557d489fa in find_function_start_sal_1 (func_addr=0x100003fa0, section=0x62100016d170, funfirstline=true) at /home/simark/src/binutils-gdb/gdb/symtab.c:3650
    #19 0x0000555557d49015 in find_function_start_sal (sym=0x621000191670, funfirstline=true) at /home/simark/src/binutils-gdb/gdb/symtab.c:3706
    #20 0x0000555557485283 in symbol_to_sal (result=0x7fffffffbb30, funfirstline=1, sym=0x621000191670) at /home/simark/src/binutils-gdb/gdb/linespec.c:4460
    #21 0x00005555574728c2 in convert_linespec_to_sals (state=0x7fffffffc390, ls=0x7fffffffc3e0) at /home/simark/src/binutils-gdb/gdb/linespec.c:2335
    #22 0x0000555557475a8e in parse_linespec (parser=0x7fffffffc360, arg=0x60200007a550 "main", match_type=symbol_name_match_type::WILD) at /home/simark/src/binutils-gdb/gdb/linespec.c:2716
    #23 0x0000555557479027 in event_location_to_sals (parser=0x7fffffffc360, location=0x606000097be0) at /home/simark/src/binutils-gdb/gdb/linespec.c:3173
    #24 0x00005555574798f7 in decode_line_full (location=0x606000097be0, flags=1, search_pspace=0x0, default_symtab=0x0, default_line=0, canonical=0x7fffffffcca0, select_mode=0x0, filter=0x0) at /home/simark/src/binutils-gdb/gdb/linespec.c:3253
    #25 0x0000555556b4949f in parse_breakpoint_sals (location=0x606000097be0, canonical=0x7fffffffcca0) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:9134
    #26 0x0000555556b6ce95 in create_sals_from_location_default (location=0x606000097be0, canonical=0x7fffffffcca0, type_wanted=bp_breakpoint) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:13819
    #27 0x0000555556b645a6 in bkpt_create_sals_from_location (location=0x606000097be0, canonical=0x7fffffffcca0, type_wanted=bp_breakpoint) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:12631
    #28 0x0000555556b4badf in create_breakpoint (gdbarch=0x621000152d10, location=0x606000097be0, cond_string=0x0, thread=0, extra_string=0x0, force_condition=false, parse_extra=1, tempflag=0, type_wanted=bp_breakpoint, ignore_count=0, pending_break_support=AUTO_BOOLEAN_AUTO, ops=0x55555bd728a0 <bkpt_breakpoint_ops>, from_tty=0, enabled=1, internal=0, flags=0) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:9410
    #29 0x0000555556b4d3b1 in break_command_1 (arg=0x7fffffffe291 "", flag=0, from_tty=0) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:9590
    #30 0x0000555556b4dc1b in break_command (arg=0x7fffffffe28d "main", from_tty=0) at /home/simark/src/binutils-gdb/gdb/breakpoint.c:9660
    #31 0x0000555556d24ca9 in do_const_cfunc (c=0x61100003a240, args=0x7fffffffe28d "main", from_tty=0) at /home/simark/src/binutils-gdb/gdb/cli/cli-decode.c:102
    #32 0x0000555556d2fcd3 in cmd_func (cmd=0x61100003a240, args=0x7fffffffe28d "main", from_tty=0) at /home/simark/src/binutils-gdb/gdb/cli/cli-decode.c:2160
    #33 0x0000555557e84e93 in execute_command (p=0x7fffffffe290 "n", from_tty=0) at /home/simark/src/binutils-gdb/gdb/top.c:674
    #34 0x00005555575a9933 in catch_command_errors (command=0x555557e84043 <execute_command(char const*, int)>, arg=0x7fffffffe28b "b main", from_tty=0, do_bp_actions=true) at /home/simark/src/binutils-gdb/gdb/main.c:523
    #35 0x00005555575a9fdb in execute_cmdargs (cmdarg_vec=0x7fffffffd910, file_type=CMDARG_FILE, cmd_type=CMDARG_COMMAND, ret=0x7fffffffd5b0) at /home/simark/src/binutils-gdb/gdb/main.c:618
    #36 0x00005555575ad48a in captured_main_1 (context=0x7fffffffdd00) at /home/simark/src/binutils-gdb/gdb/main.c:1322
    #37 0x00005555575ada9c in captured_main (data=0x7fffffffdd00) at /home/simark/src/binutils-gdb/gdb/main.c:1343
    #38 0x00005555575adb31 in gdb_main (args=0x7fffffffdd00) at /home/simark/src/binutils-gdb/gdb/main.c:1368
    #39 0x000055555681e179 in main (argc=8, argv=0x7fffffffde78) at /home/simark/src/binutils-gdb/gdb/gdb.c:32

The section being dealt with at that moment is the special *COM*
section:

    (top-gdb) p section.name
    $1 = 0x55555a1bbe60 "*COM*"
    (top-gdb) p section
    $2 = (bfd_section *) 0x55555bbe4ac0 <_bfd_std_section>

I'm not too sure what this section is for, but this is one of four
special BFD sections that GDB puts after the regular sections in the
objfile::sections and objfile::section_offsets lists.  You can check
gdb_bfd_section_index to see how they are handled.
gdb_bfd_count_sections returns "+ 4" to account for those sections.

The problem is that macho_symfile_offsets uses bfd_count_sections
instead of gdb_bfd_count_sections when allocating the
objfile::section_offsets vector.  The vector will therefore contain,
say, 13 elements instead of 17.  When trying to access the section
offset of the *COM* section, the first after the regular sections, we
access section_offsets[13], which is out of bounds.

Fix that by using gdb_bfd_count_sections instead of bfd_count_sections.
I'm fairly confident that this is correct, as this is what
default_symfile_offsets does.

With this patch, the command shown above terminates normally:

    $ ./gdb -nx --data-directory=data-directory -q repro/test -ex "b main" -batch
    Breakpoint 1 at 0x100003fad: file test.c, line 2.

[1] https://sourceware.org/bugzilla/show_bug.cgi?id=28017

gdb/ChangeLog:

PR gdb/28017
* machoread.c (macho_symfile_offsets): Use
gdb_bfd_count_sections to allocate objfile::section_offsets.

Change-Id: Ic3a56f46f7232e9f24581f8255fc1ab981935450

gdb: convert obj_section macros to methods

Convert these three macros to methods of obj_section.  The problem fixed
by the following patch is caused by an out of bound access of the
objfile::section_offsets vector.  Since this is deep in macros, we don't
get a clear backtrace and it's difficult to debug.  Changing that to
methods means we can step in them and break on them.

Because their implementation requires knowing about struct objfile, move
struct obj_section below struct objfile in objfiles.h.

The obj_section_offset was used in one place as an lvalue to set
offsets, in machoread.c.  Replace that with a set_offset method.

Add the objfile::section_offset and objfile::set_section_offset methods
to improve encapsulation (reduce other objects poking into struct
objfile's internals).

gdb/ChangeLog:

* objfiles.h (struct obj_section): Move down.
<offset, set_offset, addr, endaddr>: New.
(obj_section_offset, obj_section_addr, obj_section_endaddr),
replace all users to use obj_section methods.
(struct objfile) <section_offset, set_section_offset>: New.

Change-Id: I97e8fcae93ab2353fbdadcb4a5ec10d7949a7334

gdb: add .flake8 file

Add a .flake8 file, which is used to set default options to the flake8
Python linter.  Use it to disable these two kinds of diagnostics, which
we don't care about since formatting is handled by black.  This reduces
the amount of noise when running flake8 on Python files.

    ./python/lib/gdb/function/caller_is.py:30:80: E501 line too long (81 > 79 characters)
    ./python/lib/gdb/command/frame_filters.py:468:17: W503 line break before binary operator

gdb/ChangeLog:

* .flake8: New.

Change-Id: I2b41379fdd1f6e8bf2a784d55a10b406e4d1c828

Sanitize the address before working with allocation tags

Remove the logical tag/top byte from the address whenever we have to work with
allocation tags.

gdb/ChangeLog:

2021-06-28  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c (aarch64_linux_memtag_matches_p): Remove the top
byte.
(aarch64_linux_set_memtags): Likewise.
(aarch64_linux_get_memtag): Likewise.
(aarch64_linux_report_signal_info): Likewise.

Fix FFR register size for core files.

The FFR register has a size of VL bits, not 32 bits.

This causes issues when writing core files with the gcore command and when
reading them. The FFR register sometimes shows up with garbage data.

gdb/ChangeLog:

2021-06-28  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c
(aarch64_linux_iterate_over_regset_sections): Fix FFR register size.

Fix tag_ctl register size in the core file.

This register should be 64 bits in size, but the current code only saves
32 bits. This is due to an early assumption that tag_ctl would be 32 bits
in size.

gdb/ChangeLog:

2021-06-28  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c
(aarch64_linux_iterate_over_regset_sections): Update tag_ctl register
size.
* aarch64-linux-tdep.h (AARCH64_LINUX_SIZEOF_MTE_REGSET): Set to
8 and update comments.

gdb: remove gdbarch_info_init

While reviewing another patch, I realized that gdbarch_info_init could
easily be removed in favor of initializing gdbarch_info fields directly
in the struct declaration.  The only odd part is the union.  I don't
know if it's actually important for it to be zero-initialized, but I
presume it is.  I added a constructor to gdbarch_info to take care of
that.  A proper solution would be to use std::variant.  Or, these could
also be separate fields, the little extra space required wouldn't
matter.

gdb/ChangeLog:

* gdbarch.sh (struct gdbarch_info): Initialize fields, add
constructor.
* gdbarch.h: Re-generate.
* arch-utils.h (gdbarch_info_init): Remove, delete all usages.
* arch-utils.c (gdbarch_info_init): Remove.

Change-Id: I7502e08fe0f278d84eef1667a072e8a97bda5ab5

gdb: remove gdbarch_info::tdep_info

This field is not actually used, remove it.

gdb/ChangeLog:

* gdbarch.sh (struct gdbarch_info) <tdep_info>: Remove.
(gdbarch_find_by_info): Remove print.
* gdbarch.c, gdbarch.h: Re-generate.

Change-Id: I00af4681b8e1a27727441cbadc3827f5914bd8eb

gdb/remote: Use true/false instead of 1/0

The remote_state::starting_up member variable is already of type bool,
but in some places we still write to it using 1 and 0.  This commit
just updates things to use true and false.

There should be no user visible change after this commit.

gdb/ChangeLog:

* remote.c (remote_target::start_remote): Set 'starting_up' using
boolean values instead of integers.

sim: bpf: enable -Werror usage

Now that all bpf warnings have been cleaned up, turn on -Werror.

sim: bpf: fix printf warnings on 32-bit systems

Use PRI macros to display 64-bit types instead of assuming long is
a 64-bit type itself.

sim: cgen: delete unused record_trace_results functions

Since there are no callers of this anywhere, nor is the function
implemented by anyone, drop it across the board to cleanup warnings.

gdb/fortran: Add type info of formal parameter for clang.

Additional compiler generated formal parameter exist with clang and type
information for the same is added accordingly. Also few kind parameter
printing are removed which is not default for clang.
Note: More details about this kind parameter omission while printing can
be found with similar patch
        commit 0a709cba00d36d490482d0e8673e323ac1e897a6
        Author Alok Kumar Sharma (alokkumar.sharma@amd.com)

gdb/testsuite/ChangeLog:
        * gdb.fortran/ptype-on-functions.exp: Add type info of formal
        parameter for clang. Also removed the kind parameter for clang.

sim: frv: add missing const type

sim: frv: fix engine hook

This hook doesn't return a value, so don't define it to 0 to avoid
the compiler warning about it not being used.

sim: frv: fix up various missing prototype warnings

Some of these were missing includes, some were unused funcs we can
cleanup, and some were missing prototypes for use in other files.

sim: frv: fix some printf type mismatch warnings

The %p usage was a real bug that would probably cause a crash.

sim: frv: fix uninitialized variable warning

This variable isn't set anywhere, so pass down NULL_CIA to indicate
we don't have a pc to pass.

sim: frv: fix return type for post_wait_for funcs

These functions never return anything, so change the int return type
to void to fix a bunch of compiler warnings about missing return.

sim: frv: fix ambiguous else compiler warnings

Add explicit braces to if bodies when the body is another if/else
to fix a bunch of compiler warnings.

Automatic date update in version.in

sim: bpf/cris: include cgen-mem in decoders

These arches use cgen memory functions, so make sure to include the
header in the modules.

sim: bpf: include more local headers & fix broken funcs

Various files were not including the relevant headers, or some funcs
were missing prototypes entirely, leading to mismatch between the
actual definition of the functions.  Add includes to a few places and
fix the broken functions that are uncovered as a result.  Fixing some
compile warnings (e.g. missing prototypes) often find real bugs.

sim: cgen: suppress trace non-literal printf warning

The cgen trace macros are a bit ugly in that they specify a series of
format strings & arguments in a single call.  This means we pass a
non-literal string to printf and the compiler warns about it.  Use
the diagnostic macros to suppress that in this one place.

sim: cgen: add asserts to fix unused engine warnings

If the user passed in values outside the range of [0, MAX_NR_PROCESSORS),
it would cause the code to access out-of-bind engine function pointers.
Add some asserts to catch that and to fix the related compiler warnings.

sim: cgen: add printf attributes in a few more calls

This helps the compiler process calls to these functions and emit
warnings about mismatched format arguments.

sim: cgen: constify trace strings

Shouldn't be any functional changes here.

sim: cgen: always leverage the mem prototypes

This fixes missing prototype warnings, and guarantees the prototypes
stay in sync with the function definitions.  One of the macros had
fallen out by declaring the wrong return type.

sim: cgen: always leverage the ops prototypes

This fixes missing prototype warnings, and guarantees the prototypes
stay in sync with the function definitions.

sim: cgen: sync prototypes with implementation

These prototype blocks are not normally used, so they've fallen out
of sync with the actual function definitions.  Resync them all.

sim: bpf: add explicit casts when using explicit formats

Since the value variable usually has an incompatible type for the wide
variety of types it is printed as, add explicit casts to them all.

sim: bpf: fix mixed decls & code warnings (and style)

sim: erc32: merge with common configure script

Move the unique library tests to the common code so we can delete
the erc32 configure logic entirely.

sim: bfin: move pkg-config & SDL checks to common code

This reduces the unique logic in bfin/configure to make it easier to
(eventually) unify it entirely.

Automatic date update in version.in

gdb/guile: use return values of add_setshow functions in add_setshow_generic

Use the set_show_commands objects returned by the add_setshow functions
in add_setshow_generic.  This lets us avoid looking up the commands
after creating them, instead using the return objects directly.

Make add_setshow_generic return a set_show_commands object, which is a
bit nicer than returning both commands by parameter.

Finally, store using that object in param_smob.

Equivalent of 7bd22f56a3cf ("gdb/python: use return values of
add_setshow functions in add_setshow_generic"), but for guile.

gdb/ChangeLog:

* guile/scm-param.c (struct param_smob) <set_command,
show_command>: Remove.
<commands>: New.
(pascm_is_valid): Adjust.
(add_setshow_generic): Use return values of add_setshow
functions, return a set_show_commands.
(gdbscm_register_parameter_x): Adjust.

Change-Id: I18ed9e7dd5646529491c86749a5cb20763acd1f0

gdb: remove context parameter from add_setshow_enum_cmd

I propose removing the context parameter from add_setshow_enum_cmd.  It
was useful before add_setshow_enum_cmd returned both created commands,
as the caller couldn't easily set the context itself.  But now, I think
it's fine to just let the caller do it.

gdb/ChangeLog:

* command.h (add_setshow_enum_cmd): Remove context parameter.
* cli/cli-decode.c (add_setshow_enum_cmd): Likewise, and don't
set context.
* cli/cli-style.c (cli_style_option::add_setshow_commands): Set
context here.

Change-Id: I377c4e6820ec9d5069492ed28f4cba342ce1336e

gdb: add assert in cmd_list_element::set_context

If something tries to set a context pointer on a cmd_list_element and
m_context is not nullptr, it's likely that two parts of the code are
trying to set different contexts, and one will overwrite the other.
This is almost guaranteed to lead to bad behavior or a crash, as one of
the spots will not be using the data it expects.  This happened to me
during development, so I think having this assert would be useful to
catch this problem earlier.

gdb/ChangeLog:

* cli/cli-decode.h (struct cmd_list_element) <set_context>: Add
assert.

Change-Id: I1f2e9fda1bf2bec1b732c9b90e7d7910a97f2ac6

gdb: add context getter/setter to cmd_list_element

Straightforward replacement of get_cmd_context / set_cmd_context with
cmd_list_element methods.

gdb/ChangeLog:

* cli/cli-decode.h (struct cmd_list_element) <set_context,
context>: New.
<context>: Rename to...
<m_context>: ... this.
* cli/cli-decode.c (set_cmd_context, get_cmd_context): Remove.
* command.h (set_cmd_context, get_cmd_context): Remove, use
cmd_list_element::set_context and cmd_list_element::context
everywhere instead.

Change-Id: I5016b0079014e3f17d1aa449ada7954473bf2b5d

Automatic date update in version.in

gdb: change info sources to group results by objfile

Currently the 'info sources' command lists all of the known source
files together, regardless of their source, e.g. here is a session
debugging a test application that makes use of a shared library:

  (gdb) info sources
  Source files for which symbols have been read in:

  /tmp/info-sources/test.c, /usr/include/stdc-predef.h,
  /tmp/info-sources/header.h, /tmp/info-sources/helper.c

  Source files for which symbols will be read in on demand:

  (gdb)

In this commit I change the format of the 'info sources' results so
that the results are grouped by the object file that uses that source
file.  Here's the same session with the new output format:

  (gdb) info sources
  /tmp/info-sources/test.x:

  /tmp/info-sources/test.c, /usr/include/stdc-predef.h,
  /tmp/info-sources/header.h

  /lib64/ld-linux-x86-64.so.2:
  (Objfile has no debug information.)

  system-supplied DSO at 0x7ffff7fcf000:
  (Objfile has no debug information.)

  /tmp/info-sources/libhelper.so:

  /tmp/info-sources/helper.c, /usr/include/stdc-predef.h,
  /tmp/info-sources/header.h

  /lib64/libc.so.6:
  (Objfile has no debug information.)

  (gdb)

Notice that in the new output some source files are repeated,
e.g. /tmp/info-sources/header.h, as multiple objfiles use this source
file.

Further, some object files are tagged with the message '(Objfile has
no debug information.)', it is also possible to see the message '(Full
debug information has not yet been read for this file.)', which is
printed when some symtabs within an objfile have not yet been
expanded.

All of the existing regular expression based filtering still works.

An original version of this patch added the new format as an option to
'info sources', however, it was felt that the new layout was so much
better than the old style that GDB should just switch to the new
result format completely.

gdb/ChangeLog:

* NEWS: Mention changes to 'info sources'.
* symtab.c (info_sources_filter::print): Delete.
(struct output_source_filename_data) <print_header>: Delete
declaration.  <printed_filename_p>: New member function.
(output_source_filename_data::print_header): Delete.
(info_sources_worker): Update group-by-objfile style output to
make it CLI suitable, simplify non-group-by-objfile now this is
only used from the MI.
(info_sources_command): Make group-by-objfile be the default for
CLI info sources command.
* symtab.h (struct info_sources_filter) <print>: Delete.

gdb/doc/ChangeLog:

* gdb.texinfo (Symbols): Document new output format for 'info
sources'.

gdb/testsuite/ChangeLog:

* gdb.base/info_sources_2-header.h: New file.
* gdb.base/info_sources_2-lib.c: New file.
* gdb.base/info_sources_2-test.c: New file.
* gdb.base/info_sources_2.exp: New file.