Use bool in gprof

* basic_blocks.c: Replace bfd_boolean with bool, FALSE with false,
and TRUE with true throughout.
* basic_blocks.h: Likewise.
* cg_arcs.c: Likewise.
* cg_dfn.c: Likewise.
* cg_print.c: Likewise.
* corefile.c: Likewise.
* gmon_io.c: Likewise.
* gprof.c: Likewise.
* gprof.h: Likewise.
* hist.c: Likewise.
* mips.c: Likewise.
* source.c: Likewise.
* source.h: Likewise.
* sym_ids.c: Likewise.
* sym_ids.h: Likewise.
* symtab.h: Likewise.
* vax.c: Likewise.

Use bool in include

* bfdlink.h: Replace bfd_boolean with bool throughout.
* coff/ecoff.h: Likewise.
* coff/xcoff.h: Likewise.
* dis-asm.h: Likewise.
* elf/mmix.h: Likewise.
* elf/xtensa.h: Likewise.
* opcode/aarch64.h: Likewise, and FALSE with false, TRUE with true.
* opcode/arc.h: Likewise.
* opcode/mips.h: Likewise.
* opcode/tic6x-opcode-table.h: Likewise.
* opcode/tic6x.h: Likewise.

Use stdbool.h

With this in place we can retire bfd_boolean one project at a time.

bfd/
* bfd-in.h: Include stdbool.h.
(bfd_boolean): Define as bool
* bfd-in2.h: Regenerate.

Remove bfd_stdint.h

If we require C99 for binutils then stdint.h is available.

bfd/
* .gitignore: Delete bfd_stdint.h entry.
* Makefile.am (bfdinclude_HEADERS): Delete bfd_stdint.h.
(BUILD_HFILES, LOCAL_H_DEPS): Likewise.
* bfd-in.h: Include stdint.h in place of bfd_stdint.h.
* configure.ac: Don't invoke GCC_HEADER_STDINT.
* configure.com: Don't create bfd_stdint.h.
* Makefile.in: Regenerate.
* aclocal.m4: Regenerate.
* bfd-in2.h: Regenerate.
* config.in: Regenerate.
* configure: Regenerate.
* doc/Makefile.in: Regenerate.
* po/BLD-POTFILES.in: Regenerate.
binutils/
* coffdump.c: Include stdint.h in place of bfd_stdint.h.
* dwarf.c: Likewise.
gas/
* config/tc-aarch64.c: Include stdint.h in place of bfd_stdint.h.
* config/tc-crx.c: Likewise.
* config/tc-nds32.h: Likewise.
include/
* cgen/basic-modes.h: Include stdint.h in place of bfd_stdint.h.
* elf/nfp.h: Likewise.
* opcode/aarch64.h: Likewise.
* opcode/cgen.h: Likewise.
* opcode/nfp.h: Likewise.
* opcode/ppc.h: Likewise.
ld/
* elf-hints-local.h: Include stdint.h in place of bfd_stdint.h.
* emultempl/nds32elf.em: Likewise.
* testsuite/ld-elf/mbind2b.c: Likewise.
* testsuite/ld-elf/pr18718.c: Likewise.
* testsuite/ld-elf/pr18720a.c: Likewise.
* testsuite/ld-elf/pr25749-1.c: Likewise.
* testsuite/ld-elf/pr25749-1a.c: Likewise.
* testsuite/ld-elf/pr25749-1b.c: Likewise.
* testsuite/ld-elf/pr25749-1c.c: Likewise.
* testsuite/ld-elf/pr25749-1d.c: Likewise.
* testsuite/ld-elf/pr25749-2.c: Likewise.
* testsuite/ld-elf/pr25754-1a.c: Likewise.
* testsuite/ld-elf/pr25754-2a.c: Likewise.
* testsuite/ld-elf/pr25754-3a.c: Likewise.
* testsuite/ld-elf/pr25754-4a.c: Likewise.
* testsuite/ld-elf/pr25754-5a.c: Likewise.
* testsuite/ld-elf/pr25754-6a.c: Likewise.
opcodes/
* aarch64-dis.c: Include stdint.h in place of bfd_stdint.h.
* aarch64-dis.h: Likewise.
* aarch64-opc.c: Likewise.
* avr-dis.c: Likewise.
* csky-dis.c: Likewise.
* nds32-asm.c: Likewise.
* nds32-dis.c: Likewise.
* nfp-dis.c: Likewise.
* riscv-dis.c: Likewise.
* s12z-dis.c: Likewise.
* wasm32-dis.c: Likewise.

Include string.h in bfd.h and delete LITMEMCPY, LITSTRCPY

This fixes the issue that startswith depends on strncpy being
declared, and not all projects using bfd.h include string.h before
bfd.h.  I've also deleted some macros that don't find much use
anywhere.

bfd/
* bfd-in.h: Include string.h.
(LITMEMCPY, LITSTRCPY): Delete.
* bfd-in2.h: Regenerate.
binutils/
* prdbg.c (pr_function_type): Replace LITSTTCPY with strcpy.

Automatic date update in version.in

gdb/dwarf: disable per-BFD resource sharing for -readnow objfiles

New in v2:

  - Disable sharing only for -readnow objfiles, not all objfiles.

As described in PR 27541, we hit an internal error when loading a binary
the standard way and then loading it with the -readnow option:

    $ ./gdb -nx -q --data-directory=data-directory ~/a.out -ex "set confirm off" -ex "file -readnow ~/a.out"
    Reading symbols from /home/simark/a.out...
    Reading symbols from ~/a.out...
    /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:8098: internal-error: void create_all_comp_units(dwarf2_per_objfile*): Assertion `per_objfile->per_bfd->all_comp_units.empty ()' failed.

This is a recurring problem that exposes a design issue in the DWARF
per-BFD sharing feature.  Things work well when loading a binary with
the same method (with/without index, with/without readnow) twice in a
row.  But they don't work so well when loading a binary with different
methods.  See this previous fix, for example:

    efb763a5ea35 ("gdb: check for partial symtab presence in dwarf2_initialize_objfile")

That one handled the case where the first load is normal (uses partial
symbols) and the second load uses an index.

The problem is that when loading an objfile with a method A, we create a
dwarf2_per_bfd and some dwarf2_per_cu_data and initialize them with the
data belonging to that method.  When loading another obfile sharing the
same BFD but with a different method B, it's not clear how to re-use the
dwarf2_per_bfd/dwarf2_per_cu_data previously created, because they
contain the data specific to method A.

I think the most sensible fix would be to not share a dwarf2_per_bfd
between two objfiles loaded with different methods.  That means that two
objfiles sharing the same BFD and loaded the same way would share a
dwarf2_per_bfd.  Two objfiles sharing the same BFD but loaded with
different methods would use two different dwarf2_per_bfd structures.

However, this isn't a trivial change.  So to fix the known issue quickly
(including in the gdb 10 branch), this patch just disables all
dwarf2_per_bfd sharing for objfiles using READNOW.

Generalize the gdb.base/index-cache-load-twice.exp test to test all
the possible combinations of loading a file with partial symtabs, index
and readnow.  Move it to gdb.dwarf2, since it really exercises features
of the DWARF reader.

gdb/ChangeLog:

PR gdb/27541
* dwarf2/read.c (dwarf2_has_info): Don't share dwarf2_per_bfd
with objfiles using READNOW.

gdb/testsuite/ChangeLog:

PR gdb/27541
* gdb.base/index-cache-load-twice.exp: Remove.
* gdb.base/index-cache-load-twice.c: Remove.
* gdb.dwarf2/per-bfd-sharing.exp: New.
* gdb.dwarf2/per-bfd-sharing.c: New.

Change-Id: I9ffcf1e136f3e75242f70e4e58e4ba1fd3083389

[gdb/testsuite] Add missing .debug_abbrev terminator in dw2-cu-size.S

Since commit 27012aba8a6 "Remove Irix 6 workaround from DWARF abbrev reader"
we have:
...
(gdb) file dw2-cu-size^M
Reading symbols from dw2-cu-size...^M
DW_FORM_strp pointing outside of .debug_str section [in module dw2-cu-size]^M
(No debugging symbols found in dw2-cu-size)^M
(gdb) ptype noloc^M
No symbol table is loaded.  Use the "file" command.^M
(gdb) FAIL: gdb.dwarf2/dw2-cu-size.exp: ptype noloc
...

The problem is a missing .debug_abbrev terminator in dw2-cu-size.S, which
causes the .debug_abbrev contribution to be merged with the next:
...
 Number TAG (0x9b)
   1      DW_TAG_compile_unit    [has children]
    DW_AT_name         DW_FORM_string
    DW_AT_producer     DW_FORM_string
    DW_AT_language     DW_FORM_data1
    DW_AT value: 0     DW_FORM value: 0
   2      DW_TAG_variable    [no children]
    DW_AT_name         DW_FORM_string
    DW_AT_type         DW_FORM_ref4
    DW_AT_external     DW_FORM_flag
    DW_AT value: 0     DW_FORM value: 0
   3      DW_TAG_base_type    [no children]
    DW_AT_name         DW_FORM_string
    DW_AT_byte_size    DW_FORM_data1
    DW_AT_encoding     DW_FORM_data1
    DW_AT value: 0     DW_FORM value: 0
   4      DW_TAG_const_type    [no children]
    DW_AT_type         DW_FORM_ref_udata
    DW_AT value: 0     DW_FORM value: 0
   1      DW_TAG_compile_unit    [has children]
    DW_AT_producer     DW_FORM_strp
    DW_AT_language     DW_FORM_data1
    DW_AT_name         DW_FORM_strp
    DW_AT_comp_dir     DW_FORM_strp
    DW_AT_low_pc       DW_FORM_addr
    DW_AT_high_pc      DW_FORM_data8
    DW_AT_stmt_list    DW_FORM_sec_offset
    DW_AT value: 0     DW_FORM value: 0
...
and consequently, abbreviation code 1 no longer refers to a unique entry.

The eventually causes us to access the first attribute of this DIE:
...
 <0><124>: Abbrev Number: 1 (DW_TAG_compile_unit)
    <125>   DW_AT_name        : file1.txt
    <12f>   DW_AT_producer    : GNU C 3.3.3
    <13b>   DW_AT_language    : 1       (ANSI C)
...
which has form DW_FORM_string, using DW_FORM_strp.

Fix this by adding the missing .debug_abbrev terminator in dw2-cu-size.S.

gdb/testsuite/ChangeLog:

2021-03-30  Tom de Vries  <tdevries@suse.de>

PR testsuite/27604
* gdb.dwarf2/dw2-cu-size.S: Add missing .debug_abbrev terminator.

Fix inverted logic bug

During reviews, I changed the success/failure variables from int to bool, but
missed updating the code in a couple spots.  Given the logic inversion, the
gdbserver code fails instead of succeeding.

Fixed with the following patch. Seems fairly obvious, so I'll push it soon.

gdbserver/ChangeLog:

2021-03-30  Luis Machado  <luis.machado@linaro.org>

* server.cc (handle_general_set, handle_query): Update variable
to bool and fix verification logic.

x86: drop seg_entry

Use struct reg_entry instead for most purposes, with a separate array
holding just the respective opcode prefix bytes.

x86: drop REGNAM_{AL,AX,EAX}

The former two are unused anyway. And having such constants isn't very
helpful either, when they live in a place where updating the register
table wouldn't even allow noticing the need to adjust these constants.

x86: adjust st(<N>) parsing

st(1) ... st(7) will never be looked up in the hash table, so there's no
point inserting the entries. It's also not really necessary to do a 2nd
hash lookup after parsing the register number, nor is there a real
reason for having both st and st(0) entries. Plus we can easily do away
with the need for st to be first in the table.

x86: integrate rc_op into struct _i386_insn

There's no need for the extra level of indirection and the extra storage
needed for the pointer, pointing from one piece of static data to
another. Key checking of rounding being in effect off of the type field
of the structure instead.

x86: integrate broadcast_op into struct _i386_insn

There's no need for the extra level of indirection and the extra storage
needed for the pointer, pointing from one piece of static data to
another. Key checking of broadcast being in effect off of the type field
of the structure instead.

x86: integrate mask_op into struct _i386_insn

There's no need for the extra level of indirection and the extra storage
needed for the pointer, pointing from one piece of static data to
another. Key checking of masking being in effect off of the register
field of the structure instead.

x86: make swap_2_operands() have unsigned parameters

All callers pass unsigned values (in some cases by virtue of passing
non-negative literal numbers).

This in turn requires struct {Mask,RC,Broadcast}_Operation's "operand"
fields to become unsigned, in turn allowing to reduce the amount of
casting needed (the two new casts that are necessary cast _to_
"unsigned" instead of _from_, as that's the form that'll never case
undefined behavior).

asan: linker.c:2294:8: runtime error: load of value 253

Seen after converting bfd_boolean to bool.
mmix  +FAIL: ld-mmix/zeroehmmo

./ld-new   -L/home/alan/src/binutils-gdb/ld/testsuite/ld-mmix  -m mmo -Ttext 0xa00 -T /home/alan/src/binutils-gdb/ld/testsuite/ld-mmix/zeroeh.ld -o tmpdir/dump tmpdir/x.o tmpdir/y.o
/home/alan/src/binutils-gdb/bfd/linker.c:2294:8: runtime error: load of value 253, which is not a valid value for type '_Bool'

* elflink.c (elf_link_add_object_symbols): Don't set h->indx
unless is_elf_hash_table.

PR27625, powerpc64 gold __tls_get_addr calls

This patch supports linking powerpc64 glibc with gold, specifically
the __tls_get_addr call in elf/dl-sym.c.  That call lacks marker
relocations tying it to the arg setup instructions, but the arg setup
insns are also contructed lacking the usual relocations on a Global
Dynamic TLS code sequence.  So there is no chance that anything in
that sequence might be wrongly edited by the linker.

In fact, the aim of linking glibc could have been supported by simply
omitting the error whenever TLS optimisation is disabled, as it is
when linking a shared library.  The patch goes further than that,
disabling TLS GD and LD sequence optimisation on a per-object basis
for object files lacking marker relocs.

PR gold/27625
* powerpc.cc (Powerpc_relobj): Add no_tls_marker_, tls_marker_,
and tls_opt_error_ variables and accessors.
(Target_powerpc::Scan::local, global): Call set_tls_marker and
set_no_tls_marker for GD and LD code sequence relocations.
(Target_powerpc::Relocate::relocate): Downgrade the "lacks marker
reloc" error to a warning when safe to do so, and omit the error
entirely if not optimising TLS sequences.  Do not optimise GD and
LD sequences for objects lacking marker relocs.
(Target_powerpc::relocate_relocs): Heed no_tls_marker here too.

Automatic date update in version.in

Remove parameter from language_info

I noticed that language_info is only ever called with a value of '1'.
This patch removes the parameter.

2021-03-29  Tom Tromey  <tromey@adacore.com>

* top.c (check_frame_language_change): Update.
* language.c (language_info): Remove parameter.
* language.h (language_info): Remove parameter.

Don't pass empty options to GCC

On aarch64-linux, I noticed the compile command didn't work at all.  It
always gave the following error:

aarch64-linux-gnu-g++: error: : No such file or directory

Turns out we're passing an empty argv entry to GCC (because aarch64 doesn't
have a -m64 option), and GCC's behavior is to think that is a file it needs
to open.  One can reproduce it like so:

gcc "" "" "" ""
gcc: error: : No such file or directory
gcc: error: : No such file or directory
gcc: error: : No such file or directory
gcc: error: : No such file or directory
gcc: fatal error: no input files
compilation terminated.

The solution is to check for an empty string and skip adding that to argv.

Regression tested on aarch64-linux/Ubuntu 18.04/20.04.

gdb/ChangeLog:

2021-03-29  Luis Machado  <luis.machado@linaro.org>

* compile/compile.c (get_args): Don't add empty argv entries.

Fix memory tagging section type

It was reported to me that on Ubuntu 14.04 (fairly old) the documentation
fails to build with the following:

gdb/doc/gdb.texinfo:10888: warning: node `Memory' is up for `Memory Tagging' in sectioning but not in menu
gdb/doc/gdb.texinfo:10693: node `Memory' lacks menu item for `Memory Tagging' despite being its Up target
Makefile:491: recipe for target 'gdb.info' failed
make[3]: *** [gdb.info] Error 1

This doesn't seem to happen on Ubuntu 18.04/20.04, but it does make sense.

Fix this by turning @subsection into a @section and adding the
"Memory Tagging" entry to the menu.

gdb/doc/ChangeLog:

2021-03-29  Luis Machado  <luis.machado@linaro.org>

* gdb.textinfo (Memory Tagging): Make it a @section.

testsuite, mi: avoid a clang bug in 'user-selected-context-sync.exp'

This test causes several timeouts for Clang, taking too long time to
finish.  The reason is, for an infinite loop of the form

   while(1); /* suppose this is line 30.  */

Clang generates code that looks like

   0x00000000004004d4 <+4>:     jmp    0x4004d9 <loop+9>
   0x00000000004004d9 <+9>:     jmp    0x4004d9 <loop+9>

So, the real loop is the instruction at address 0x4004d9.  But a
breakpoint that's defined at the loop line (assume line 30 in this
case) is inserted at address 0x4004d4.

  (gdb) break 30
  Breakpoint 1 at 0x4004d4: file test.c, line 30.

Therefore, continuing a thread that was spinning on the loop does not hit
the breakpoint.  The bug is reported at

  https://bugs.llvm.org/show_bug.cgi?id=49614

Tweak the infinite loop to spin on a variable to avoid this bug.  The
test is unrelated to the bug.

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

* gdb.mi/user-selected-context-sync.exp: Spin on a variable in
the infinite loop to avoid a Clang bug.

Restore procfs.c compilation

Since c8fbd44a018a9923f906bfd2be5489caa87b602a (gdb: remove
target_is_pushed free function), procfs.c compilation is broken, which
went unnoticed for lack of functioning buildbots:

/vol/src/gnu/gdb/hg/master/dist/gdb/procfs.c: In member function 'virtual void procfs_target::attach(const char*, int)':
/vol/src/gnu/gdb/hg/master/dist/gdb/procfs.c:1772:8: error: 'inf' was not declared in this scope; did you mean 'info'?
 1772 |   if (!inf->target_is_pushed (this))
      |        ^~~
      |        info
/vol/src/gnu/gdb/hg/master/dist/gdb/procfs.c: In member function 'virtual void procfs_target::create_inferior(const char*, const string&, char**, int)':
/vol/src/gnu/gdb/hg/master/dist/gdb/procfs.c:2865:8: error: 'inf' was not declared in this scope; did you mean 'info'?
 2865 |   if (!inf->target_is_pushed (this))
      |        ^~~
      |        info

Fixed by defining inf.  Tested on amd64-pc-solaris2.11 and
sparcv9-sun-solaris2.11.

2021-03-29  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>

gdb:
* procfs.c (procfs_target::attach): Define inf.
Use it.
(procfs_target::create_inferior): Likewise.

x86: move some opcode table entries

For a long time there hasn't been a need anymore to keep together all
templates with identical mnemonics. Move the MOVQ and MOVABS ones next
to their MOV counterparts. Move the string forms of CMPSD and MOVSD next
to their CMPS / MOVS counterparts. Re-arrange what so fgar was the SSE3
section.

This makes reasonably obvious that MONITOR/MWAIT aren't suitable to
cover by CpuSSE3, but adjusting this is left for another time.

x86: VPSADBW's source operands are also commutative

In commit 79dec6b7baa2 ("x86-64: optimize certain commutative
VEX-encoded insns") I missed the fact that there being subtraction
involved here doesn't matter, as absolute differences get summed up.

x86: fold SSE2AVX and their base MMX/SSE templates

This way not only the overall (source) table size shrinks by quite a
bit and the risk of related templates going out of sync with one another
gets lowered, but also (dis)similarities between neighboring templates
become easier to spot.

Note that for certain SSE2AVX templates this results in benign attribute
changes:
- LDMXCSR and STMXCSR: NoAVX gets set,
- MOVMSKPS, PMOVMSKB, PEXTR{B,W} (register destination), and PINSR{B,W}
  (register source): IgnoreSize and NoRex64 get set,
- CVT{DQ,PS}2PD, CVTSD2SS, MOVMSKPD, MOVDDUP, PMOV{S,Z}X{BW,WD,DQ}, and
  ROUNDSD: NoRex64 gets set,
- CVTSS2SD, INSERTPS, PEXTRW (memory destination), PINSRW (memory
  source), and PMOV{S,Z}X{BD,WQ,BQ}: IgnoreSize gets set.
Similarly the "normal" (non-SSE2AVX)
- non-64-bit CVTS{I,S}2SD forms get NoRex64 set,
- CMP{EQ,ORD,NEQ,UNORD}{P,S}{S,D} forms get C set,
all again in a benign way.

The remaining differences in the generated table are due to re-ordering
of entries in the course of being folded into templates.

x86: undo Prefix_0X<nn> use in opcode table

The table entries are more natural to read (and slightly shorter) when
the prefixes, like is the case for VEX/XOP/EVEX-encoded entries, are
specified as part of the opcode. This is particularly noticable for
side-by-side legacy and SSE2AVX entries.

An implication is that we now need to use "unsigned long long" for the
initially parsed opcode in i386-gen. I don't expect this to be an issue.

x86: shrink some struct insn_template fields

Now that all base opcodes are only at most 2 bytes in size, shrink its
template field to just as much. By also shrinking extension_opcode and
operands to just what they really need, we can free up an entire 32-bit
slot (plus 4 left bits past the bitfields themselves).

At present this alters sizeof(struct insn_template) only for 32-bit
builds. In 64-bit builds it instead leaves a padding hole that will
allow to buffer future growth of other fields (opcode_modifier,
cpu_flags, operand_types[]).

x86: derive opcode encoding space attribute from base opcode

Just like is already done for VEX/XOP/EVEX encoded insns, record the
encoding space information in the respective opcode modifier field. Do
this again without changing the source table, but rather by deriving the
values from their existing source representation.

TRUE/FALSE simplification

There is really no need to write code like "foo != 0 ? TRUE : FALSE"
unless we had stupidly defined FALSE as something other than 0 or TRUE
as something other than 1.  The simpler "foo != 0" does just as well.
Similarly "(condition == TRUE)" or "(condition == FALSE) can be
simplified to "(condition)" and "(!condition)" respectively.

I'll note that there is reason to use "integer_expression != 0" when
assigning a bfd_boolean rather than the simpler "integer_expression",
if you expect the variable to have 0 or 1 value.  It's probably even a
good idea to not rely on implicit conversion if bfd_boolean were _Bool.

bfd/
* aoutx.h (aout_link_write_symbols): Don't cast boolean expression
to bfd_boolean.
* elf32-or1k.c (or1k_set_got_and_rela_sizes): Dont compare booleans
against FALSE.
* elf32-arc.c (name_for_global_symbol): Don't compare boolean to TRUE.
(is_reloc_PC_relative): Don't use "boolean_condition ? TRUE : FALSE".
(is_reloc_SDA_relative, is_reloc_for_GOT): Likewise.
(is_reloc_for_PLT, is_reloc_for_TLS): Likewise.
* elf32-arm.c (stm32l4xx_need_create_replacing_stub): Likewise.
* elf32-nds32.c (insert_nds32_elf_blank): Likewise.
* elf32-rx.c (rx_set_section_contents): Likewise.
* elfnn-aarch64.c (elfNN_aarch64_final_link_relocate): Likewise.
* elfxx-mips.c (_bfd_mips_elf_ignore_undef_symbol): Likewise.
* mach-o.c (bfd_mach_o_read_command): Likewise.
* targets.c (bfd_get_target_info): Likewise.
binutils/
* dlltool.c (main): Don't use "boolean_condition ? TRUE : FALSE".
* dwarf.c (read_and_display_attr_value): Likewise.
(display_debug_str_offsets): Likewise.
* objdump.c (dump_bfd): Likewise.
* readelf.c (dump_section_as_strings): Likewise.
(dump_section_as_bytes): Likewise.
gas/
* atof-generic.c (FALSE, TRUE): Don't define.
* config/obj-elf.h (FALSE, TRUE): Don't define.
* config/obj-som.h (FALSE, TRUE): Don't define.
* config/tc-hppa.h (FALSE, TRUE): Don't define.
* config/tc-pdp11.c (FALSE, TRUE): Don't define.
* config/tc-iq2000.h (obj_fix_adjustable): Delete.
* config/tc-m32r.h (TC_FIX_ADJUSTABLE): Delete.
* config/tc-mt.h (obj_fix_adjustable): Delete.
* config/tc-nds32.h (TC_FIX_ADJUSTABLE): Delete.
* config/tc-arc.c (parse_opcode_flags): Simplify boolean expression.
(relaxable_flag, relaxable_operand, assemble_insn): Likewise.
(tokenize_extregister): Likewise.
* config/tc-csky.c (parse_opcode, get_operand_value): Likewise.
(parse_operands_op, parse_operands, md_assemble): Likewise.
* config/tc-d10v.c (build_insn): Likewise.
* config/tc-score.c (s3_gen_insn_frag): Likewise.
* config/tc-score7.c (s7_gen_insn_frag, s7_relax_frag): Likewise.
* config/tc-tic6x.c (tic6x_update_features, md_assemble): Likewise.
* config/tc-z80.c (emit_byte): Likewise.
include/
* opcode/aarch64.h (alias_opcode_p): Simplify boolean expression.
(opcode_has_alias, pseudo_opcode_p, optional_operand_p): Likewise.
(opcode_has_special_coder): Likewise.
ld/
* emultempl/aix.em (gld${EMULATION_NAME}_before_allocation): Simplify
boolean expression.
* lexsup.c (parse_args): Likewise.
* pe-dll.c (pe_dll_id_target): Likewise.
opcodes/
* aarch64-opc.c (vector_qualifier_p): Simplify boolean expression.
(fp_qualifier_p, get_data_pattern): Likewise.
(aarch64_get_operand_modifier_from_value): Likewise.
(aarch64_extend_operator_p, aarch64_shift_operator_p): Likewise.
(operand_variant_qualifier_p): Likewise.
(qualifier_value_in_range_constraint_p): Likewise.
(aarch64_get_qualifier_esize): Likewise.
(aarch64_get_qualifier_nelem): Likewise.
(aarch64_get_qualifier_standard_value): Likewise.
(get_lower_bound, get_upper_bound): Likewise.
(aarch64_find_best_match, match_operands_qualifier): Likewise.
(aarch64_print_operand): Likewise.
* aarch64-opc.h (operand_has_inserter, operand_has_extractor): Likewise.
(operand_need_sign_extension, operand_need_shift_by_two): Likewise.
(operand_need_shift_by_four, operand_maybe_stack_pointer): Likewise.
* arm-dis.c (print_insn_mve, print_insn_thumb32): Likewise.
* tic6x-dis.c (tic6x_check_fetch_packet_header): Likewise.
(print_insn_tic6x): Likewise.

gas int vs bfd_boolean fixes

* config/tc-arm.c (struct arm_long_option_table <func>): Return
bfd_boolean.
* config/tc-arm.h (arm_optimize_expr, arm_data_in_code): Likewise.
* config/tc-metag.c (parse_mov_port): Replace unsigned int variable
with bfd_boolean.
(parse_mmov, parse_mov_ct, parse_alu, parse_shift, parse_bitop),
(parse_cmp, parse_fmmov, parse_fmov_data, parse_fearith),
(parse_dget_set, parse_dalu): Likewise, ensuring assignment from
logical expressions.
(struct metag_long_option <func>): Return bfd_boolean.
(metag_parse_cpu, metag_parse_fpu, metag_parse_dsp): Likewise.
* config/tc-msp430.c (msp430_dstoperand): Correct dummy type.
* config/tc-s12z.c (parse_operand_func): Return bfd_boolean.
(no_operands, lex_force_match, lex_reg_list): Likewise.
(size_from_suffix): Return int.
(s12z_relax_frag, md_estimate_size_before_relax): Return 0.
* config/tc-s12z.h (tc_s12z_fix_adjustable): Likewise.

binutils int vs bfd_boolean fixes

* objdump.c (process_links): Use type int.
* readelf.c (request_dump): Don't increment do_dump, set it.
* windint.h (target_is_bigendian): Use type bfd_boolean.
* windmc.c (target_is_bigendian): Likewise.
* windres.c (target_is_bigendian): Likewise.

opcodes int vs bfd_boolean fixes

cpu/
* frv.opc (frv_is_branch_major, frv_is_float_major),
(frv_is_media_major, frv_is_branch_insn, frv_is_float_insn),
(frv_is_media_insn, spr_valid): Correct prototypes.
include/
* opcode/aarch64.h (aarch64_opcode_encode): Correct prototype.
opcodes/
* arc-dis.c (extract_operand_value): Correct NULL cast.
* frv-opc.h: Regenerate.

Miscellaneous BFD int vs bfd_boolean fixes

nds32 hyper_relax takes values of 0, 1 and 2.  vms_write_data_block
return TRUE/FALSE not positive/negative.

* coff-z80.c (z80_is_local_label_name): Return bfd_boolean.
* elf32-z80.c (z80_is_local_label_name): Likewise.
* elf32-spu.c (spu_elf_modify_headers): Likewise.
* elf32-nds32.h (struct elf_nds32_link_hash_table <hyper_relax>):
Change type to int.
* vms-lib.c (_bfd_vms_lib_write_archive_contents): Correct test
for error return from vms_write_data_block.

hash table iterator callback functions int vs. bfd_boolean

Correct return type of callbacks invoked by htab_traverse and other
hashtab.h functions to int, and one case of a callback invoked by
elf_link_hash_traverse to bfd_boolean.

* elf32-i386.c (elf_i386_finish_local_dynamic_symbol): Return int.
* elf64-ia64-vms.c (elf64_ia64_local_dyn_info_free): Likewise.
(elf64_ia64_local_dyn_sym_thunk): Likewise.
* elf64-x86-64.c (elf_x86_64_finish_local_dynamic_symbol): Likewise.
* elfnn-aarch64.c (elfNN_aarch64_allocate_local_ifunc_dynrelocs),
(elfNN_aarch64_finish_local_dynamic_symbol): Likewise.
* elfnn-ia64.c (elfNN_ia64_local_dyn_info_free): Likewise.
(elfNN_ia64_local_dyn_sym_thunk): Likewise.
* elfnn-riscv.c (allocate_local_ifunc_dynrelocs): Likewise.
(riscv_pcrel_reloc_eq): Likewise.
(riscv_elf_finish_local_dynamic_symbol): Likewise.
* elfxx-sparc.c (allocate_local_dynrelocs): Likewise.
(finish_local_dynamic_symbol): Likewise.
* elfxx-x86.c (elf_x86_allocate_local_dynreloc): Likewise.
* elfxx-mips.c (mips_elf_resolve_got_page_ref): Likewise.
(mips_elf_count_got_symbols): Change return type to bfd_boolean.

ELF output symbol hooks int vs. bfd_boolean

elf_backend_link_output_symbol_hook and elf_link_output_symstrtab may
return 2 when a symbol is to be discarded.  Update places that use
bfd_boolean rather than int for these functions.

* elflink.c (elf_link_output_symstrtab): Make flinfo parameter
a void pointer.
(bfd_elf_final_link): Delete out_sym_func typedef and don't cast
elf_link_output_symstrtab when calling output_arch_syms and
output_arch_local_syms.
* elf-bfd.h (struct elf_backend_data <elf_backend_output_arch_syms,
elf_backend_output_arch_local_syms>): Change return type of func
arg to match elf_link_output_symstrtab.
* elf-vxworks.h (elf_vxworks_link_output_symbol_hook): Correct
return type.
* elf32-nds32.c (nds32_elf_output_symbol_hook): Correct return type.
(nds32_elf_output_arch_syms): Correct func return type.

elf_backend_relocate_section int vs. bfd_boolean

This functions was changed to return an int in commit ece5ef60797f but
since bfd_boolean was an int typedef I lazily left all the ELF
relocate_section functions as returning bfd_boolean, except the SPU
one.  In order to use _Bool or bool in place of bfd_boolean we need to
be fussy about the return types.

* elf-m10200.c (mn10200_elf_relocate_section): Return int.
* elf-m10300.c (mn10300_elf_relocate_section): Likewise.
* elf32-arc.c (elf_arc_relocate_section): Likewise.
* elf32-arm.c (elf32_arm_relocate_section): Likewise.
* elf32-avr.c (elf32_avr_relocate_section): Likewise.
* elf32-bfin.c (bfin_relocate_section): Likewise.
(bfinfdpic_relocate_section): Likewise.
* elf32-cr16.c (elf32_cr16_relocate_section): Likewise.
* elf32-cris.c (cris_elf_relocate_section): Likewise.
* elf32-crx.c (elf32_crx_relocate_section): Likewise.
* elf32-csky.c (csky_elf_relocate_section): Likewise.
* elf32-d10v.c (elf32_d10v_relocate_section): Likewise.
* elf32-epiphany.c (epiphany_elf_relocate_section): Likewise.
* elf32-fr30.c (fr30_elf_relocate_section): Likewise.
* elf32-frv.c (elf32_frv_relocate_section): Likewise.
* elf32-ft32.c (ft32_elf_relocate_section): Likewise.
* elf32-h8300.c (elf32_h8_relocate_section): Likewise.
* elf32-hppa.c (elf32_hppa_relocate_section): Likewise.
* elf32-i386.c (elf_i386_relocate_section): Likewise.
* elf32-ip2k.c (ip2k_elf_relocate_section): Likewise.
* elf32-iq2000.c (iq2000_elf_relocate_section): Likewise.
* elf32-lm32.c (lm32_elf_relocate_section): Likewise.
* elf32-m32c.c (m32c_elf_relocate_section): Likewise.
* elf32-m32r.c (m32r_elf_relocate_section): Likewise.
* elf32-m68hc1x.c (elf32_m68hc11_relocate_section): Likewise.
* elf32-m68hc1x.h (elf32_m68hc11_relocate_section): Likewise.
* elf32-m68k.c (elf_m68k_relocate_section): Likewise.
* elf32-mcore.c (mcore_elf_relocate_section): Likewise.
* elf32-mep.c (mep_elf_relocate_section): Likewise.
* elf32-metag.c (elf_metag_relocate_section): Likewise.
* elf32-microblaze.c (microblaze_elf_relocate_section): Likewise.
* elf32-moxie.c (moxie_elf_relocate_section): Likewise.
* elf32-msp430.c (elf32_msp430_relocate_section): Likewise.
* elf32-mt.c (mt_elf_relocate_section): Likewise.
* elf32-nds32.c (nds32_elf_relocate_section): Likewise.
* elf32-nios2.c (nios2_elf32_relocate_section): Likewise.
* elf32-or1k.c (or1k_elf_relocate_section): Likewise.
* elf32-ppc.c (ppc_elf_relocate_section): Likewise.
* elf32-pru.c (pru_elf32_relocate_section): Likewise.
* elf32-rl78.c (rl78_elf_relocate_section): Likewise.
* elf32-rx.c (rx_elf_relocate_section): Likewise.
* elf32-s390.c (elf_s390_relocate_section): Likewise.
* elf32-score.c (s3_bfd_score_elf_relocate_section): Likewise.
(_bfd_score_elf_relocate_section): Likewise.
* elf32-score.h (s7_bfd_score_elf_relocate_section): Likewise.
* elf32-score7.c (s7_bfd_score_elf_relocate_section): Likewise.
* elf32-sh.c (sh_elf_relocate_section): Likewise.
* elf32-tic6x.c (elf32_tic6x_relocate_section): Likewise.
* elf32-tilepro.c (tilepro_elf_relocate_section): Likewise.
* elf32-v850.c (v850_elf_relocate_section): Likewise.
* elf32-vax.c (elf_vax_relocate_section): Likewise.
* elf32-visium.c (visium_elf_relocate_section): Likewise.
* elf32-xc16x.c (elf32_xc16x_relocate_section): Likewise.
* elf32-xstormy16.c (xstormy16_elf_relocate_section): Likewise.
* elf32-xtensa.c (elf_xtensa_relocate_section): Likewise.
* elf32-z80.c (z80_elf_relocate_section): Likewise.
* elf64-alpha.c (elf64_alpha_relocate_section_r): Likewise.
(elf64_alpha_relocate_section): Likewise.
* elf64-bpf.c (bpf_elf_relocate_section): Likewise.
* elf64-hppa.c (elf64_hppa_relocate_section): Likewise.
* elf64-ia64-vms.c (elf64_ia64_relocate_section): Likewise.
* elf64-mmix.c (mmix_elf_relocate_section): Likewise.
* elf64-ppc.c (ppc64_elf_relocate_section): Likewise.
* elf64-s390.c (elf_s390_relocate_section): Likewise.
* elf64-x86-64.c (elf_x86_64_relocate_section): Likewise.
* elfnn-aarch64.c (elfNN_aarch64_relocate_section): Likewise.
* elfnn-ia64.c (elfNN_ia64_relocate_section): Likewise.
* elfnn-riscv.c (riscv_elf_relocate_section): Likewise.
* elfxx-mips.c (_bfd_mips_elf_relocate_section): Likewise.
* elfxx-mips.h (_bfd_mips_elf_relocate_section): Likewise.
* elfxx-sparc.c (_bfd_sparc_elf_relocate_section): Likewise.
* elfxx-sparc.h (_bfd_sparc_elf_relocate_section): Likewise.
* elfxx-tilegx.c (tilegx_elf_relocate_section): Likewise.
* elfxx-tilegx.h (tilegx_elf_relocate_section): Likewise.

Automatic date update in version.in

Simplify DWARF reader initialization

Now that the quick functions are separate from the object file format,
there's no need to have elfread.c push a new entry on the objfile 'qf'
list.  Instead, this detail can be pushed into the DWARF reader.  That
is what this patch implements.

I wasn't sure whether lazy reading still makes sense or not.  It's
still only used by ELF, and only in certain situations (like vfork, I
think).  It may not be carrying its weight, so we may want to consider
removing this in the future.

Also, I'm unclear on why the various indices are only used for ELF.
This seems sub-optimal.  However, I haven't tried to address that
here.

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

* elfread.c (can_lazily_read_symbols): Move to dwarf2/read.c.
(elf_symfile_read): Simplify.
* dwarf2/read.c (struct lazy_dwarf_reader): Move from elfread.c.
(make_lazy_dwarf_reader): New function.
(make_dwarf_gdb_index, make_dwarf_debug_names): Now static.
(dwarf2_initialize_objfile): Return void.  Remove index_kind
parameter.  Push on 'qf' list.
* dwarf2/public.h (dwarf2_initialize_objfile): Change return
type.  Remove 'index_kind' parameter.
(make_dwarf_gdb_index, make_dwarf_debug_names): Don't declare.

Automatic date update in version.in

Don't declare elf_sym_fns_lazy_psyms

An earlier patch neglected to delete a forward declaration of
elf_sym_fns_lazy_psyms.  This is no longer defined.  This patch
removes it.

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

* elfread.c (elf_sym_fns_lazy_psyms): Don't declare.

Don't clear 'qf' in elf_symfile_read

I noticed that I forgot to make a change in my series to make it
possible to attach multiple debug readers to an objfile.  In one spot,
elf_symfile_read still clears the 'qf' list.  However, this should
have been removed toward the end of that series.

This patch fixes the offending spot.  Tested on x86-64 Fedora 32.

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

* elfread.c (elf_symfile_read): Don't clear 'qf'.

gdb/testsuite: make some test names unique in gdb.arch/powerpc-*.exp

Resolve some duplicate test name warnings in gdb.arch/powerpc-*.exp
tests by either extending the existing test names, or providing a new
test name.

gdb/testsuite/ChangeLog:

* gdb.arch/powerpc-disassembler-options.exp: Extend some test
names for uniqueness.
* gdb.arch/powerpc-fpscr-gcore.exp: Add more test names for
uniqueness.

Automatic date update in version.in

gdb-add-index.sh: Remove use of non posix 'local'

While working on gdb-add-index.sh, it appeared that it uses the non
POSIX 'local' keyword.  Instead of using local to allow variable
shadowing, I rename the local one to avoid name conflicts altogether.

This commit gets rid of the following shellcheck warning:

    In gdb-add-index.sh line 63:
        local file="$1"
        ^--------^ SC2039: In POSIX sh, 'local' is undefined.

gdb/ChangeLog:

* contrib/gdb-add-index.sh: Avoid variable shadowing and get
rid of 'local'.

Use function view in quick_symbol_functions::map_symbol_filenames

This changes quick_symbol_functions::map_symbol_filenames to use a
function_view, and updates all the uses.  It also changes the final
parameter to 'bool'.  A couple of spots are further updated to use
operator() rather than a lambda.

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

* symtab.c (struct output_source_filename_data): Add 'output'
method and operator().
(output_source_filename_data::output): Rename from
output_source_filename.
(output_partial_symbol_filename): Remove.
(info_sources_command): Update.
(struct add_partial_filename_data): Add operator().
(add_partial_filename_data::operator()): Rename from
maybe_add_partial_symtab_filename.
(make_source_files_completion_list): Update.
* symfile.c (quick_symbol_functions): Update.
* symfile-debug.c (objfile::map_symbol_filenames): Update.
* quick-symbol.h (symbol_filename_ftype): Change type of 'fun' and
'need_fullname'.  Remove 'data' parameter.
(struct quick_symbol_functions) <map_symbol_filenames>: Likewise.
* psymtab.c (psymbol_functions::map_symbol_filenames): Update.
* psympriv.h (struct psymbol_functions) <map_symbol_filenames>:
Change type of 'fun' and 'need_fullname'.  Remove 'data'
parameter.
* objfiles.h (struct objfile) <map_symbol_filenames>: Change type
of 'fun' and 'need_fullname'.  Remove 'data' parameter.
* mi/mi-cmd-file.c (print_partial_file_name): Remove 'ignore'
parameter.
(mi_cmd_file_list_exec_source_files): Update.
* dwarf2/read.c
(dwarf2_base_index_functions::map_symbol_filenames): Update.

Simplify use of map_matching_symbols in ada-lang.c

I noticed that ada-lang.c creates a lambda to call
aux_add_nonlocal_symbols.  However, this code can be simplified a bit
by changing match_data to implement operator(), and then simply
passing the object as the callback.  That is what this patch
implements.

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

* ada-lang.c (struct match_data): Add operator().
(match_data::operator()): Rename from aux_add_nonlocal_symbols.
(callback): Remove 'callback'.

Simplify psymbol_functions::expand_symtabs_matching

I noticed that psymbol_functions::expand_symtabs_matching calls
make_ignore_params once per psymtab that is matched.  This seems
possibly expensive, so this patch hoists the call out of the loop.

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

* psymtab.c (psymbol_functions::expand_symtabs_matching): Only
call make_ignore_params once.

Allow expand_symtabs_matching to examine imported psymtabs

Currently the psymtab variant of expand_symtabs_matching has this
check:

      /* We skip shared psymtabs because file-matching doesn't apply
 to them; but we search them later in the loop.  */
      if (ps->user != NULL)
continue;

In a larger series I'm working on, it's convenient to remove this
check.  And, I noticed that a similar check is not done for
expand_symtabs_with_fullname.  So, it made sense to me to remove the
check here as well.

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

* psymtab.c (psymbol_functions::expand_symtabs_matching): Remove
"user" check.

Save/restore file offset while reading notes in core file

A recent bug (RH BZ 1931344) has exposed a bug in the core file
build-ID support that I introduced a while ago. It is pretty
easy to demonstate the problem following a simplified procedure
outlined in that bug:

[shell1]
shell1$ /usr/libexec/qemu-kvm

[shell2]
shell2$ pkill -SEGV -x qemu-kvm

[shell1]
Segmentation fault (core dumped)

Load this core file into GDB without specifying an executable
(an unfortunate Fedora/RHEL-ism), and GDB will inform the user
to install debuginfo for the "missing" executable:

$ gdb -nx -q core.12345
...
Missing separate debuginfo for the main executable file
Try: dnf --enablerepo='*debug*' install /usr/lib/debug/.build-id/e2/e9c66d3117fb2bbb5b2be122f04f2664e5df54
Core was generated by `/usr/libexec/qemu-kvm'.
Program terminated with signal SIGSEGV, Segmentation fault.
...

The suggested build-ID is actaully for gmp not qemu-kvm. The problem
lies in _bfd_elf_core_find_build_id, where we loop over program headers
looking for note segments:

  /* Read in program headers and parse notes.  */
  for (i = 0; i < i_ehdr.e_phnum; ++i, ++i_phdr)
    {
      Elf_External_Phdr x_phdr;

      if (bfd_bread (&x_phdr, sizeof (x_phdr), abfd) != sizeof (x_phdr))
        goto fail;
      elf_swap_phdr_in (abfd, &x_phdr, i_phdr);

      if (i_phdr->p_type == PT_NOTE && i_phdr->p_filesz > 0)
        {
          elf_read_notes (abfd, offset + i_phdr->p_offset,
                          i_phdr->p_filesz, i_phdr->p_align);

          if (abfd->build_id != NULL)
            return TRUE;
        }

elf_read_notes uses bfd_seek to forward the stream to the location of
the note segment. When control returns to _bfd_elf_core_fild_build_id,
the stream is no longer in the location looking at program headers, and
all subsequent reads will read from the wrong file offset.

To fix this, this patch marks the stream location and ensures
that it is restored after elf_read_notes is called.

bfd/ChangeLog
2021-03-26  Keith Seitz  <keiths@redhat.com>

* elfcore.h (_bfd_elf_core_find_build_id): Seek file
offset of program headers after calling elf_read_notes.

gdb/testsuite: more testing of pretty printer 'array' display_hint

This commit adds a couple of tests to the python pretty printer
testing.

I've added a test for the 'array' display hint.  This display hint is
tested by gdb.python/py-mi.exp, however, the MI testing is done via
the varobj interface, and this code makes its own direct calls to the
Python pretty printers from gdb/varobj.c.  What this means is that the
interface to the pretty printers in gdb/python/py-prettyprint.c is not
tested for the 'array' display hint path.

I also added a test for what happens when the display_hint method
raises an exception.  There wasn't a bug that inspired this test, just
while adding the previous test I thought, I wonder what happens if...

The current behaviour of GDB seems reasonable, GDB displays the Python
exception, and then continues printing the value as if display_hint
had returned None.  I added a test to lock in this behaviour.

gdb/testsuite/ChangeLog:

* gdb.python/py-prettyprint.c (struct container): Add 'is_array_p'
member.
(make_container): Initialise is_array_p.
* gdb.python/py-prettyprint.exp: Add new tests.
* gdb.python/py-prettyprint.py (ContainerPrinter.display_hint):
Check is_array_p and possibly return 'array'.

gdb: defer commit resume until all available events are consumed

Rationale
---------

Let's say you have multiple threads hitting a conditional breakpoint
at the same time, and all of these are going to evaluate to false.
All these threads will need to be resumed.

Currently, GDB fetches one target event (one SIGTRAP representing the
breakpoint hit) and decides that the thread should be resumed.  It
calls resume and commit_resume immediately.  It then fetches the
second target event, and does the same, until it went through all
threads.

The result is therefore something like:

  - consume event for thread A
  - resume thread A
  - commit resume (affects thread A)
  - consume event for thread B
  - resume thread B
  - commit resume (affects thread B)
  - consume event for thread C
  - resume thread C
  - commit resume (affects thread C)

For targets where it's beneficial to group resumptions requests (most
likely those that implement target_ops::commit_resume), it would be
much better to have:

  - consume event for thread A
  - resume thread A
  - consume event for thread B
  - resume thread B
  - consume event for thread C
  - resume thread C
  - commit resume (affects threads A, B and C)

Implementation details
----------------------

To achieve this, this patch adds another check in
maybe_set_commit_resumed_all_targets to avoid setting the
commit-resumed flag of targets that readily have events to provide to
infrun.

To determine if a target has events readily available to report, this
patch adds an `has_pending_events` target_ops method.  The method
returns a simple bool to say whether or not it has pending events to
report.

Testing
=======

To test this, I start GDBserver with a program that spawns multiple
threads:

 $ ../gdbserver/gdbserver --once :1234 ~/src/many-threads-stepping-over-breakpoints/many-threads-stepping-over-breakpoints

I then connect with GDB and install a conditional breakpoint that always
evaluates to false (and force the evaluation to be done by GDB):

 $ ./gdb -nx --data-directory=data-directory \
     /home/simark/src/many-threads-stepping-over-breakpoints/many-threads-stepping-over-breakpoints \
     -ex "set breakpoint condition-evaluation host" \
     -ex "set pag off" \
     -ex "set confirm off" \
     -ex "maint set target-non-stop on" \
     -ex "tar rem :1234" \
     -ex "tb main" \
     -ex "b 13 if 0" \
     -ex c \
     -ex "set debug infrun" \
     -ex "set debug remote 1" \
     -ex "set debug displaced"

I then do "continue" and look at the log.

The remote target receives a bunch of stop notifications for all
threads that have hit the breakpoint.  infrun consumes and processes
one event, decides it should not cause a stop, prepares a displaced
step, after which we should see:

 [infrun] maybe_set_commit_resumed_all_process_targets: not requesting commit-resumed for target remote, target has pending events

Same for a second thread (since we have 2 displaced step buffers).
For the following threads, their displaced step is deferred since
there are no more buffers available.

After consuming the last event the remote target has to offer, we get:

 [infrun] maybe_set_commit_resumed_all_process_targets: enabling commit-resumed for target remote
 [infrun] maybe_call_commit_resumed_all_process_targets: calling commit_resumed for target remote
 [remote] Sending packet: $vCont;s:p14d16b.14d1b1;s:p14d16b.14d1b2#55
 [remote] Packet received: OK

Without the patch, there would have been one vCont;s just after each
prepared displaced step.

gdb/ChangeLog:
yyyy-mm-dd  Simon Marchi  <simon.marchi@efficios.com>
    Pedro Alves  <pedro@palves.net>

* async-event.c (async_event_handler_marked): New.
* async-event.h (async_event_handler_marked): Declare.
* infrun.c (maybe_set_commit_resumed_all_targets): Switch to
inferior before calling target method.  Don't commit-resumed if
target_has_pending_events is true.
* remote.c (remote_target::has_pending_events): New.
* target-delegates.c: Regenerate.
* target.c (target_has_pending_events): New.
* target.h (target_ops::has_pending_events): New target method.
(target_has_pending_events): New.

Change-Id: I18112ba19a1ff4986530c660f530d847bb4a1f1d

gdb: generalize commit_resume, avoid commit-resuming when threads have pending statuses

The rationale for this patch comes from the ROCm port [1], the goal
being to reduce the number of back and forths between GDB and the
target when doing successive operations.  I'll start with explaining
the rationale and then go over the implementation.  In the ROCm / GPU
world, the term "wave" is somewhat equivalent to a "thread" in GDB.
So if you read if from a GPU stand point, just s/thread/wave/.

ROCdbgapi, the library used by GDB [2] to communicate with the GPU
target, gives the illusion that it's possible for the debugger to
control (start and stop) individual threads.  But in reality, this is
not how it works.  Under the hood, all threads of a queue are
controlled as a group.  To stop one thread in a group of running ones,
the state of all threads is retrieved from the GPU, all threads are
destroyed, and all threads but the one we want to stop are re-created
from the saved state.  The net result, from the point of view of GDB,
is that the library stopped one thread.  The same thing goes if we
want to resume one thread while others are running: the state of all
running threads is retrieved from the GPU, they are all destroyed, and
they are all re-created, including the thread we want to resume.

This leads to some inefficiencies when combined with how GDB works,
here are two examples:

 - Stopping all threads: because the target operates in non-stop mode,
   when the user interface mode is all-stop, GDB must stop all threads
   individually when presenting a stop.  Let's suppose we have 1000
   threads and the user does ^C.  GDB asks the target to stop one
   thread.  Behind the scenes, the library retrieves 1000 thread
   states and restores the 999 others still running ones.  GDB asks
   the target to stop another one.  The target retrieves 999 thread
   states and restores the 998 remaining ones.  That means that to
   stop 1000 threads, we did 1000 back and forths with the GPU.  It
   would have been much better to just retrieve the states once and
   stop there.

 - Resuming with pending events: suppose the 1000 threads hit a
   breakpoint at the same time.  The breakpoint is conditional and
   evaluates to true for the first thread, to false for all others.
   GDB pulls one event (for the first thread) from the target, decides
   that it should present a stop, so stops all threads using
   stop_all_threads.  All these other threads have a breakpoint event
   to report, which is saved in `thread_info::suspend::waitstatus` for
   later.  When the user does "continue", GDB resumes that one thread
   that did hit the breakpoint.  It then processes the pending events
   one by one as if they just arrived.  It picks one, evaluates the
   condition to false, and resumes the thread.  It picks another one,
   evaluates the condition to false, and resumes the thread.  And so
   on.  In between each resumption, there is a full state retrieval
   and re-creation.  It would be much nicer if we could wait a little
   bit before sending those threads on the GPU, until it processed all
   those pending events.

To address this kind of performance issue, ROCdbgapi has a concept
called "forward progress required", which is a boolean state that
allows its user (i.e. GDB) to say "I'm doing a bunch of operations,
you can hold off putting the threads on the GPU until I'm done" (the
"forward progress not required" state).  Turning forward progress back
on indicates to the library that all threads that are supposed to be
running should now be really running on the GPU.

It turns out that GDB has a similar concept, though not as general,
commit_resume.  One difference is that commit_resume is not stateful:
the target can't look up "does the core need me to schedule resumed
threads for execution right now".  It is also specifically linked to
the resume method, it is not used in other contexts.  The target
accumulates resumption requests through target_ops::resume calls, and
then commits those resumptions when target_ops::commit_resume is
called.  The target has no way to check if it's ok to leave resumed
threads stopped in other target methods.

To bridge the gap, this patch generalizes the commit_resume concept in
GDB to match the forward progress concept of ROCdbgapi.  The current
name (commit_resume) can be interpreted as "commit the previous resume
calls".  I renamed the concept to "commit_resumed", as in "commit the
threads that are resumed".

In the new version, we have two things:

 - the commit_resumed_state field in process_stratum_target: indicates
   whether GDB requires target stacks using this target to have
   resumed threads committed to the execution target/device.  If
   false, an execution target is allowed to leave resumed threads
   un-committed at the end of whatever method it is executing.

 - the commit_resumed target method: called when commit_resumed_state
   transitions from false to true.  While commit_resumed_state was
   false, the target may have left some resumed threads un-committed.
   This method being called tells it that it should commit them back
   to the execution device.

Let's take the "Stopping all threads" scenario from above and see how
it would work with the ROCm target with this change.  Before stopping
all threads, GDB would set the target's commit_resumed_state field to
false.  It would then ask the target to stop the first thread.  The
target would retrieve all threads' state from the GPU and mark that
one as stopped.  Since commit_resumed_state is false, it leaves all
the other threads (still resumed) stopped.  GDB would then proceed to
call target_stop for all the other threads.  Since resumed threads are
not committed, this doesn't do any back and forth with the GPU.

To simplify the implementation of targets, this patch makes it so that
when calling certain target methods, the contract between the core and
the targets guarantees that commit_resumed_state is false.  This way,
the target doesn't need two paths, one for commit_resumed_state ==
true and one for commit_resumed_state == false.  It can just assert
that commit_resumed_state is false and work with that assumption.
This also helps catch places where we forgot to disable
commit_resumed_state before calling the method, which represents a
probable optimization opportunity.  The commit adds assertions in the
target method wrappers (target_resume and friends) to have some
confidence that this contract between the core and the targets is
respected.

The scoped_disable_commit_resumed type is used to disable the commit
resumed state of all process targets on construction, and selectively
re-enable it on destruction (see below for criteria).  Note that it
only sets the process_stratum_target::commit_resumed_state flag.  A
subsequent call to maybe_call_commit_resumed_all_targets is necessary
to call the commit_resumed method on all target stacks with process
targets that got their commit_resumed_state flag turned back on.  This
separation is because we don't want to call the commit_resumed methods
in scoped_disable_commit_resumed's destructor, as they may throw.

On destruction, commit-resumed is not re-enabled for a given target
if:

 1. this target has no threads resumed, or

 2. this target has at least one resumed thread with a pending status
    known to the core (saved in thread_info::suspend::waitstatus).

The first point is not technically necessary, because a proper
commit_resumed implementation would be a no-op if the target has no
resumed threads.  But since we have a flag do to a quick check, it
shouldn't hurt.

The second point is more important: together with the
scoped_disable_commit_resumed instance added in fetch_inferior_event,
it makes it so the "Resuming with pending events" described above is
handled efficiently.  Here's what happens in that case:

 1. The user types "continue".

 2. Upon destruction, the scoped_disable_commit_resumed in the
    `proceed` function does not enable commit-resumed, as it sees some
    threads have pending statuses.

 3. fetch_inferior_event is called to handle another event, the
    breakpoint hit evaluates to false, and that thread is resumed.
    Because there are still more threads with pending statuses, the
    destructor of scoped_disable_commit_resumed in
    fetch_inferior_event still doesn't enable commit-resumed.

 4. Rinse and repeat step 3, until the last pending status is handled
    by fetch_inferior_event.  In that case,
    scoped_disable_commit_resumed's destructor sees there are no more
    threads with pending statues, so it asks the target to commit
    resumed threads.

This allows us to avoid all unnecessary back and forths, there is a
single commit_resumed call once all pending statuses are processed.

This change required remote_target::remote_stop_ns to learn how to
handle stopping threads that were resumed but pending vCont.  The
simplest example where that happens is when using the remote target in
all-stop, but with "maint set target-non-stop on", to force it to
operate in non-stop mode under the hood.  If two threads hit a
breakpoint at the same time, GDB will receive two stop replies.  It
will present the stop for one thread and save the other one in
thread_info::suspend::waitstatus.

Before this patch, when doing "continue", GDB first resumes the thread
without a pending status:

    Sending packet: $vCont;c:p172651.172676#f3

It then consumes the pending status in the next fetch_inferior_event
call:

    [infrun] do_target_wait_1: Using pending wait status status->kind = stopped, signal = GDB_SIGNAL_TRAP for Thread 1517137.1517137.
    [infrun] target_wait (-1.0.0, status) =
    [infrun]   1517137.1517137.0 [Thread 1517137.1517137],
    [infrun]   status->kind = stopped, signal = GDB_SIGNAL_TRAP

It then realizes it needs to stop all threads to present the stop, so
stops the thread it just resumed:

    [infrun] stop_all_threads:   Thread 1517137.1517137 not executing
    [infrun] stop_all_threads:   Thread 1517137.1517174 executing, need stop
    remote_stop called
    Sending packet: $vCont;t:p172651.172676#04

This is an unnecessary resume/stop.  With this patch, we don't commit
resumed threads after proceeding, because of the pending status:

    [infrun] maybe_commit_resumed_all_process_targets: not requesting commit-resumed for target extended-remote, a thread has a pending waitstatus

When GDB handles the pending status and stop_all_threads runs, we stop a
resumed but pending vCont thread:

    remote_stop_ns: Enqueueing phony stop reply for thread pending vCont-resume (1520940, 1520976, 0)

That thread was never actually resumed on the remote stub / gdbserver,
so we shouldn't send a packet to the remote side asking to stop the
thread.

Note that there are paths that resume the target and then do a
synchronous blocking wait, in sort of nested event loop, via
wait_sync_command_done.  For example, inferior function calls, or any
run control command issued from a breakpoint command list.  We handle
that making wait_sync_command_one a "sync" point -- force forward
progress, or IOW, force-enable commit-resumed state.

gdb/ChangeLog:
yyyy-mm-dd  Simon Marchi  <simon.marchi@efficios.com>
    Pedro Alves  <pedro@palves.net>

* infcmd.c (run_command_1, attach_command, detach_command)
(interrupt_target_1): Use scoped_disable_commit_resumed.
* infrun.c (do_target_resume): Remove
target_commit_resume call.
(commit_resume_all_targets): Remove.
(maybe_set_commit_resumed_all_targets): New.
(maybe_call_commit_resumed_all_targets): New.
(enable_commit_resumed): New.
(scoped_disable_commit_resumed::scoped_disable_commit_resumed)
(scoped_disable_commit_resumed::~scoped_disable_commit_resumed)
(scoped_disable_commit_resumed::reset)
(scoped_disable_commit_resumed::reset_and_commit)
(scoped_enable_commit_resumed::scoped_enable_commit_resumed)
(scoped_enable_commit_resumed::~scoped_enable_commit_resumed):
New.
(proceed): Use scoped_disable_commit_resumed and
maybe_call_commit_resumed_all_targets.
(fetch_inferior_event): Use scoped_disable_commit_resumed.
* infrun.h (struct scoped_disable_commit_resumed): New.
(maybe_call_commit_resumed_all_process_targets): New.
(struct scoped_enable_commit_resumed): New.
* mi/mi-main.c (exec_continue): Use scoped_disable_commit_resumed.
* process-stratum-target.h (class process_stratum_target):
<commit_resumed_state>: New.
* record-full.c (record_full_wait_1): Change commit_resumed_state
around calling commit_resumed.
* remote.c (class remote_target) <commit_resume>: Rename to...
<commit_resumed>: ... this.
(struct stop_reply): Move up.
(remote_target::commit_resume): Rename to...
(remote_target::commit_resumed): ... this.  Check if there is any
thread pending vCont resume.
(remote_target::remote_stop_ns): Generate stop replies for resumed
but pending vCont threads.
(remote_target::wait_ns): Add gdb_assert.
* target-delegates.c: Regenerate.
* target.c (target_wait, target_resume): Assert that the current
process_stratum target isn't in commit-resumed state.
(defer_target_commit_resume): Remove.
(target_commit_resume): Remove.
(target_commit_resumed): New.
(make_scoped_defer_target_commit_resume): Remove.
(target_stop): Assert that the current process_stratum target
isn't in commit-resumed state.
* target.h (struct target_ops) <commit_resume>: Rename to ...
 <commit_resumed>: ... this.
(target_commit_resume): Remove.
(target_commit_resumed): New.
(make_scoped_defer_target_commit_resume): Remove.
* top.c (wait_sync_command_done): Use
scoped_enable_commit_resumed.

[1] https://github.com/ROCm-Developer-Tools/ROCgdb/
[2] https://github.com/ROCm-Developer-Tools/ROCdbgapi

Change-Id: I836135531a29214b21695736deb0a81acf8cf566

target_is_non_stop_p and sync targets

gdb.base/maint-target-async-off.exp fails if you test against
gdbserver with "maint set target-non-stop on" forced.

  (gdb) run
  Starting program: build/gdb/testsuite/outputs/gdb.base/maint-target-async-off/maint-target-async-off

  Breakpoint 1, main () at src/gdb/testsuite/gdb.base/maint-target-async-off.c:21
  21        return 0;
  (gdb) FAIL: gdb.base/maint-target-async-off.exp: continue until exit (timeout)

Above, GDB just stopped listening to stdin.

Basically, GDB assumes that a target working in non-stop mode
operation also supports async mode; it's a requirement.  GDB
misbehaves badly otherwise, and even hits failed assertions.

Fix this by making target_is_non_stop_p return false if async is off.

gdb/ChangeLog:

* target.c (target_always_non_stop_p): Also check whether the
target can async.

Change-Id: I7e52e1061396a5b9b02ada462f68a14b76d68974

Avoid some pointer chasing in DWARF reader

I noticed a spot in the DWARF reader using "per_objfile->per_bfd",
where a local per_bfd variable had already been created.  Looking
through the file, I found a number of such spots.  This patch changes
them to use the already-existing local, avoiding a bit of excess
pointer chasing.

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

* dwarf2/read.c (dwarf2_read_debug_names)
(dwarf2_build_psymtabs_hard, create_addrmap_from_aranges)
(dw2_debug_names_iterator::next, create_type_unit_group):
Simplify.

gdb/testsuite: resolve remaining duplicate test names in gdb.cp/*.exp

This commit resolves the remaining duplicate test names in
gdb.cp/*.exp.  These are all the easy duplicates, I'm either giving
tests a new, unique name, extending an existing name to make it
unique, or changing an existing name to better reflect what the test
is actually doing, and thus, making this test name unique.

There should be no change in what is tested after this commit.

gdb/testsuite/ChangeLog:

* gdb.cp/breakpoint.exp: Extend test names to make them unique.
* gdb.cp/casts.exp: Give tests unique names.
* gdb.cp/filename.exp: Likewise.
* gdb.cp/gdb2495.exp: Likewise.
* gdb.cp/mb-ctor.exp: Extend test names to make them unique.
* gdb.cp/misc.exp: Rename test to make it unique.
* gdb.cp/nsnested.exp: Give tests unique names.
* gdb.cp/ovldbreak.exp: Likewise.
* gdb.cp/pr17494.exp: Rename test to reflect what is actually
being tested.  This also removes the duplicate test name.
* gdb.cp/ref-types.exp: Likewise.
* gdb.cp/temargs.exp: Likewise.

gdb/testsuite: resolve duplicate test name in gdb.cp/cplusfuncs.exp

While resolving duplicate test names I spotted that a test in
gdb.cp/cplusfuncs.exp included an unescaped '[]'.  In TCL square
brackets enclose expressions to evaluate, and so in this case, where
there is no enclosed expression, this just evaluates to the empty
string.

This clearly was not what the test intended, so in this commit I have
escaped the square brackets.  This has extended the test coverage.

gdb/testsuite/ChangeLog:

* gdb.cp/cplusfuncs.exp (test_paddr_operator_functions): Escape
square brackets in test.

gdb/testsuite: remove duplicate test from gdb.cp/maint.exp

I wanted to remove the duplicate test name from gdb.cp/maint.exp.  In
this test we run some checks against different operator names.  For
one operator we test with a variable number of spaces.  However, we
were accidentally testing the one space version twice, and the zero
space version not at all, leading to a duplicate test name.

I could have just changed the duplicate one space version into the
missing zero space version, but I thought it would be neater to wrap
multiple tests in a loop, and check all operators with either zero,
one, or two spaces.

These tests are super quick so take almost no extra time, and this
gives marginally more test coverage.

gdb/testsuite/ChangeLog:

* gdb.cp/maint.exp (test_first_component): Run more tests with a
variable number of spaces, this removes the duplicate testing of
'operator ->' which existed before.

gdb/testsuite: remove duplicate test names from gdb.cp/gdb2384.exp

The test gdb.cp/gdb2384.exp contains some duplicate test names, and
also some test names with a string inside parentheses at the end.  In
order to resolve the duplicates the obvious choice would be to add yet
more strings inside parentheses at the end of names, however, this is
discouraged in our test naming scheme.

The string in parentheses originates from a comment in the test source
code, which naturally leads to including this comment in the test
name.

In this commit I have changed the comment in the test source to remove
the string in parentheses, I then rename the tests in the .exp script
to match, making sure that all test names are unique.

There should be no change in test coverage after this commit.

gdb/testsuite/ChangeLog:

* gdb.cp/gdb2384.cc (main): Change comments used for breakpoints.
* gdb.cp/gdb2384.exp: Change and extend test names to avoid
duplicates, and also to avoid having a string inside parentheses
at the end of test names.

gdb/testsuite: remove duplicate test names for gdb.cp/nsusing.exp

In trying to resolve the duplicate test names for the
gdb.cp/nsusing.exp script, I ended up giving the test script a serious
spring clean.

This reverts some of the changes introduced in commit df83a9bf8b0d,
but I don't think that we have lost any testing.

The test program is made of many functions, the test script wants to
stop in different functions and check which symbols are in scope.

Previously the test script would either restart GDB completely in
order to "progress" to the next function, or the script would restart
the test program using 'runto'.

In this commit I have reordered the steps of the test to correspond to
program order, I then progress through the test program once by just
placing a breakpoint and then continuing.  As I said, the test is
checking which symbols are in scope at each location, so the exact
order of the tests doesn't matter, so long as we check the correct
symbols at each location.

I have also given the comments capital letters and full stops, and
re-wrapped them to a more sensible line length.

There was a duplicate test block introduced in the df83a9bf8b0d
commit which I have removed in this commit, this duplicate code was
responsible for one of the duplicate test names.

The other duplicate test name was due to the same command being run at
different locations, in this case I just gave the two tests explicit,
unique, names.

gdb/testsuite/ChangeLog:

* gdb.cp/nsusing.exp: Rewrite test, remove a duplicate test block.
Avoid repeated uses of 'runto', and instread just progress once
through the test stopping at different breakpoints.  Give comments
a capital letter and full stop.  Give duplicate tests unique names.

x86-64: don't accept supposedly disabled MOVQ forms

While all of MMX, SSE, and SSE2 are included in "generic64", they can be
individually disabled. There are two MOVQ forms lacking respective
attributes. While the MMX one would get refused anyway (due to MMX
registers not recognized with .nommx), the assembler did happily accept
the SSE2 form. Add respective CPU settings to both, paralleling what the
MOVD counterparts have.

Automatic date update in version.in

Fix bkpt-other-inferior.exp race

When testing with "maint set target-non-stop on",
gdb.server/bkpt-other-inferior.exp sometimes fails like so:

 (gdb) inferior 2
 [Switching to inferior 2 [process 368191] (<noexec>)]
 [Switching to thread 2.1 (Thread 368191.368191)]
 [remote] Sending packet: $m7ffff7fd0100,1#5b
 [remote] Packet received: 48
 [remote] Sending packet: $m7ffff7fd0100,1#5b
 [remote] Packet received: 48
 [remote] Sending packet: $m7ffff7fd0100,9#63
 [remote] Packet received: 4889e7e8e80c000049
 #0  0x00007ffff7fd0100 in ?? ()
 (gdb) PASS: gdb.server/bkpt-other-inferior.exp: inf 2: switch to inferior
 break -q main
 Breakpoint 2 at 0x1138: file /home/pedro/gdb/binutils-gdb/src/gdb/testsuite/gdb.server/server.c, line 21.
 (gdb) PASS: gdb.server/bkpt-other-inferior.exp: inf 2: set breakpoint
 delete breakpoints
 Delete all breakpoints? (y or n) y
 (gdb) [remote] wait: enter
 [remote] wait: exit
 FAIL: gdb.server/bkpt-other-inferior.exp: inf 2: delete all breakpoints in delete_breakpoints (timeout)
 ERROR: breakpoints not deleted
 Remote debugging from host ::1, port 55876
 monitor exit

The problem is here:

 (gdb) [remote] wait: enter

The testcase isn't expecting any output after the prompt.

Why is that "[remote] wait" output?  What happens is that "delete
breakpoints" queries the user, and `query` disables/reenables target
async, which results in the remote target's async event handler ending
up marked:

 (top-gdb) bt
 #0  mark_async_event_handler (async_handler_ptr=0x556bffffffff) at ../../src/gdb/async-event.c:295
 #1  0x0000556bf71b711f in infrun_async (enable=1) at ../../src/gdb/infrun.c:119
 #2  0x0000556bf7471387 in target_async (enable=1) at ../../src/gdb/target.c:3684
 #3  0x0000556bf748a0bd in gdb_readline_wrapper_cleanup::~gdb_readline_wrapper_cleanup (this=0x7ffe3cf30eb0, __in_chrg=<optimized out>) at ../../src/gdb/top.c:1074
 #4  0x0000556bf74874e2 in gdb_readline_wrapper (prompt=0x556bfa17da60 "Delete all breakpoints? (y or n) ") at ../../src/gdb/top.c:1096
 #5  0x0000556bf75111c5 in defaulted_query(const char *, char, typedef __va_list_tag __va_list_tag *) (ctlstr=0x556bf7717f34 "Delete all breakpoints? ", defchar=0 '\000', args=0x7ffe3cf31020) at ../../src/gdb/utils.c:893
 #6  0x0000556bf751166f in query (ctlstr=0x556bf7717f34 "Delete all breakpoints? ") at ../../src/gdb/utils.c:985
 #7  0x0000556bf6f11404 in delete_command (arg=0x0, from_tty=1) at ../../src/gdb/breakpoint.c:13500
 ...

... which then later results in a target_wait call:

 (top-gdb) bt
 #0  remote_target::wait_ns (this=0x7ffe3cf30f80, ptid=..., status=0xde530314f0802800, options=...) at ../../src/gdb/remote.c:7937
 #1  0x0000556bf7369dcb in remote_target::wait (this=0x556bfa0b2180, ptid=..., status=0x7ffe3cf31568, options=...) at ../../src/gdb/remote.c:8173
 #2  0x0000556bf745e527 in target_wait (ptid=..., status=0x7ffe3cf31568, options=...) at ../../src/gdb/target.c:2000
 #3  0x0000556bf71be686 in do_target_wait_1 (inf=0x556bfa1573d0, ptid=..., status=0x7ffe3cf31568, options=...) at ../../src/gdb/infrun.c:3463
 #4  0x0000556bf71be88b in <lambda(inferior*)>::operator()(inferior *) const (__closure=0x7ffe3cf31320, inf=0x556bfa1573d0) at ../../src/gdb/infrun.c:3526
 #5  0x0000556bf71bebcd in do_target_wait (wait_ptid=..., ecs=0x7ffe3cf31540, options=...) at ../../src/gdb/infrun.c:3539
 #6  0x0000556bf71bf97b in fetch_inferior_event () at ../../src/gdb/infrun.c:3879
 #7  0x0000556bf71a27f8 in inferior_event_handler (event_type=INF_REG_EVENT) at ../../src/gdb/inf-loop.c:42
 #8  0x0000556bf71cc8b7 in infrun_async_inferior_event_handler (data=0x0) at ../../src/gdb/infrun.c:9220
 #9  0x0000556bf6ecb80f in check_async_event_handlers () at ../../src/gdb/async-event.c:327
 #10 0x0000556bf76b011a in gdb_do_one_event () at ../../src/gdbsupport/event-loop.cc:216
 ...

... which returns TARGET_WAITKIND_IGNORE.

Fix this by only enabling remote output around setting the breakpoint.

gdb/testsuite/ChangeLog:

* gdb.server/bkpt-other-inferior.exp: Only enable remote output
around setting the breakpoint.

Change-Id: I2fd152fd9c46b1c5e7fa678cc4d4054dac0b2bd4

Fix problem exposed by gdb.server/stop-reply-no-thread-multi.exp

Running gdb.server/stop-reply-no-thread-multi.exp with "maint set
target-non-stop on" occasionally hit an internal error like this:

  ...
  continue
  Continuing.
  warning: multi-threaded target stopped without sending a thread-id, using first non-exited thread
  /home/pedro/gdb/binutils-gdb/src/gdb/inferior.c:291: internal-error: inferior* find_inferior_pid(process_stratum_target*, int): Assertion `pid != 0' failed.
  A problem internal to GDB has been detected,
  further debugging may prove unreliable.

  This is a bug, please report it.
  FAIL: gdb.server/stop-reply-no-thread-multi.exp: to_disable=Tthread: continue until exit (GDB internal error)

The backtrace looks like this:

 ...
 #5  0x0000560357b0879c in internal_error (file=0x560357be6c18 "/home/pedro/gdb/binutils-gdb/src/gdb/inferior.c", line=291, fmt=0x560357be6b21 "%s: Assertion `%s' failed.") at /home/pedro/gdb/binutils-gdb/src/gdbsupport/errors.cc:55
 #6  0x000056035762061b in find_inferior_pid (targ=0x5603596e9560, pid=0) at /home/pedro/gdb/binutils-gdb/src/gdb/inferior.c:291
 #7  0x00005603576206e6 in find_inferior_ptid (targ=0x5603596e9560, ptid=...) at /home/pedro/gdb/binutils-gdb/src/gdb/inferior.c:305
 #8  0x00005603577d43ed in remote_target::check_pending_events_prevent_wildcard_vcont (this=0x5603596e9560, may_global_wildcard=0x7fff84fb05f0) at /home/pedro/gdb/binutils-gdb/src/gdb/remote.c:7215
 #9  0x00005603577d2a9c in remote_target::commit_resumed (this=0x5603596e9560) at /home/pedro/gdb/binutils-gdb/src/gdb/remote.c:6680
 ...

pid is 0 in this case because the queued event is a process exit event
with no pid associated:

 (top-gdb) p event->ws
 During symbol reading: .debug_line address at offset 0x563c9a is 0 [in module /home/pedro/gdb/binutils-gdb/build/gdb/gdb]
 $1 = {kind = TARGET_WAITKIND_EXITED, value = {integer = 0, sig = GDB_SIGNAL_0, related_pid = {m_pid = 0, m_lwp = 0, m_tid = 0}, execd_pathname = 0x0, syscall_number = 0}}
 (top-gdb)

This fixes it, and adds a "maint set target-non-stop on/off" axis to the testcase.

gdb/ChangeLog:

* remote.c
(remote_target::check_pending_events_prevent_wildcard_vcont):
Check whether the event's ptid is not null_ptid before looking up
the corresponding inferior.

gdb/testsuite/ChangeLog:

* gdb.server/stop-reply-no-thread-multi.exp (run_test): Add
"target_non_stop" parameter and use it.
(top level): Add "maint set target-non-stop on/off" testing axis.

Change-Id: Ia30cf275305ee4dcbbd33f731534cd71d1550eaa

ld: do not rely on the exact size of the CTF symtypetabs in test results

The data object and function info sections (collectively "symtypetabs")
usually (i.e. if non-indexed) have sizes defined by the size of the ELF
dynamic symbol table in the object they are linked to.  This means test
results should not depend on the exact sizes of these sections, because
adding entirely irrelevant symbols to the dynsym can cause spurious test
failures.  (This also means we should not match the offset of sections
that follow them, since those too depend on the exact size of the
symtypetab sections.)

Spotted by turning the sanitizer on, which introduced new dynsym entries
and expanded the symtypetab sizes to match.

ld/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

* testsuite/ld-ctf/array.d: Only check that the data object
section is nonempty: do not check its exact size.
* testsuite/ld-ctf/diag-parlabel.d: Likewise.
* testsuite/ld-ctf/slice.d: Likewise.
* testsuite/ld-ctf/data-func-conflicted.d: Likewise, and for the
func info section too.
* testsuite/ld-ctf/function.d: Likewise, for the func info section.

libctf: fix ELF-in-BFD checks in the presence of ASAN

The address sanitizer contains a redirector that captures dlopen calls,
so checks for dlopen with AC_SEARCH_LIBS will always conclude that
dlopen is present when the sanitizer is on.  This means it won't add
-ldl to LIBS even if needed, and the immediately-following attempt to
actually link with -lbfd will fail because libbfd also needs dlsym,
which ASAN does *not* contain a redirector for.

If we check for dlsym instead of dlopen, the check works whether ASAN is
on or off.  (bfd uses both in close proximity: if it needs one, it will
always need the other.)

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

* configure.ac: Check for dlsym, not dlopen.
* configure: Regenerate.

libctf: fix memory leak in a test

Harmless, but causes noise that makes it harder to spot other leaks.

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

* testsuite/libctf-writable/symtypetab-nonlinker-writeout.c: Don't
leak buf.

libctf: don't dereference out-of-bounds locations in the qualifier hashtab

isqualifier, which is used by ctf_lookup_by_name to figure out if a
given word in a type name is a qualifier, takes the address of a
possibly out-of-bounds location before checking its bounds.

In any reasonable compiler this will just lead to a harmless address
computation that is then discarded if out-of-bounds, but it's still
undefined behaviour and the sanitizer rightly complains.

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

PR libctf/27628
* ctf-lookup.c (isqualifier): Don't dereference out-of-bounds
qhash values.

libctf: make ctf_bfdopen_ctfsect a debugger entry point

This makes it possible to use LIBCTF_DEBUG to debug things that happen
before the ctf_bfdopen_internal call that ctf_bfdopen_ctfsect eventually
thunks down to (symtab/strtab lookup, archive opening, etc).

This is not important for ctf_open callers, since ctf_fdopen already
calls libctf_init_debug, but ctf_bfdopen_ctfsect is a public entry point
that can be called directly (e.g. objdump and readelf both do so).

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

* ctf-open-bfd.c (ctf_bfdopen_ctfsect): Initialize debugging.

libctf, serialize: functions with no args have a NULL dtd_vlen

Every place that accesses a function's dtd_vlen accesses it only if the
number of args is nonzero, except the serializer, which always tries to
memcpy it.  The number of bytes it memcpys in this case is zero, but it
is still undefined behaviour to copy zero bytes from a null pointer.
So check for this case explicitly.

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

PR libctf/27628
* ctf-serialize.c (ctf_emit_type_sect): Allow for a NULL vlen in
CTF_K_FUNCTION types.

include: always do unsigned left-shift in CTF_SET_STID

This turns into a signed left shift by 31 bits, otherwise.  This is an
offset and is always treated as unsigned in any case, so add an
appropriate cast.

include/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

PR libctf/27628
* ctf-api.h: Fix some indentation.
(CTF_SET_STID): Always do an unsigned shift, even if STID is
signed.

libctf, dump: do not emit size or alignment if it would error

When we dump normal types, we emit their size and/or alignment:
but size and alignment dumping can return errors if the type is
part of a chain that terminates in a forward.

Emitting 0xffffffff as a size or alignment is unhelpful, so simply
skip emitting this info for any type for which size or alignment
checks return an error, no matter what the error is.

libctf/ChangeLog
2021-03-25  Nick Alcock  <nick.alcock@oracle.com>

* ctf-dump.c (ctf_dump_format_type): Don't emit size or alignment
on error.

gdb/testsuite: use -wrap with gdb_test_multiple in lib/ada.exp

I ran into a new failure in gdb.base/gdb-caching-proc.exp:

  FAIL: gdb.base/gdb-caching-proc.exp: supports_memtag: initial: memory-tag check

This is a failure from the `supports_memtag` proc added recently (this
new proc is in lib/gdb.exp).

The problem here is that `supports_memtag` is hitting one of the
default error cases in gdb_test_multiple, specifically it is finding a
$gdb_prompt left unmatched from an earlier call to gdb_test_multiple.

Looking back through the test output I found that the problem is the
proc `gnat_runtime_has_debug_info` in lib/ada.exp.  This proc is not
matching the trailing $gdb_prompt.  This leaves the prompt in the
expect buffer, then when we run `supports_memtag` it sees the prompt
and thinks that the test completed with no output.

Fixed by making use of `-wrap` in `gnat_runtime_has_debug_info` to
ensure the trailing prompt gets matched.

gdb/testsuite/ChangeLog:

* lib/ada.exp (gnat_runtime_has_debug_info): Use -wrap with
gdb_test_multiple.

gdb/riscv: fix creating breakpoints at invalid addresses

To allow breakpoints to be created at invalid addresses,
target_read_code is used instead of read_code.  This was fixed in
commit:

  commit c01660c625766e848195285cc20581b9ed7ecfe2
  Date:   Wed Apr 17 00:31:43 2019 +0100

      gdb/riscv: Allow breakpoints to be created at invalid addresses

Unfortunately, the call to read_code was left in by mistake.  The
result is that GDB will fail when trying to create the breakpoint,
rather than when trying to install the breakpoint (as is the case with
other targets).

This commit fixes this mistake and removes the offending call to
read_code.

gdb/ChangeLog:

* riscv-tdep.c (riscv_breakpoint_kind_from_pc): Remove call to
read_code.

[NIOS2] Fix disassembly of br.n instruction.

The code was checking wrong bit for sign extension. It caused it
to zero-extend instead of sign-extend the immediate value.

2021-03-25  Abid Qadeer  <abidh@codesourcery.com>

opcodes/
* nios2-dis.c (nios2_print_insn_arg): Fix sign extension of
immediate in br.n instruction.

gas/
* testsuite/gas/nios2/brn.s: New.
* testsuite/gas/nios2/brn.d: New.

x86: fix CMPXCHG8B special case when disallowing q suffix outside of 64-bit mode

In match_template() i.tm hasn't been filled yet, so it is necessarily t
which needs checking. This is only a latent issue as no other templates
with the same base_opcode have an extension_opcode of 1.

x86: flag bad S/G insn operand combinations

For VEX-encoded ones, all three involved vector registers have to be
distinct. For EVEX-encoded ones an actual mask register has to be in use
and zeroing-masking cannot be used (violation of either will #UD).
Additionally both involved vector registers have to be distinct for
EVEX-encoded gathers.

x86: flag as bad AVX512 insns with EVEX.z set but EVEX.aaa clear

This combination makes no sense and is documented to cause #UD.

x86: fix AMD Zen3 insns

For INVLPGB the operand count was wrong (besides %edx there's also %ecx
which is an input to the insn). In this case I see little sense in
retaining the bogus 2-operand template. Plus swapping of the operands
wasn't properly suppressed for Intel syntax.

For PVALIDATE, RMPADJUST, and RMPUPDATE bogus single operand templates
were specified. These get retained, as the address operand is the only
one really needed to expressed non-default address size, but only for
compatibility reasons. Proper multi-operand insn get introduced and the
testcases get adjusted / extended accordingly.

While at it also drop the redundant definition of __amd64__ - we already
have x86_64 defined (or not) to distinguish 64-bit and non-64-bit cases.

x86-64: limit breakage from gcc movdir64b et al workaround

This is only a partial fix for PR/gas 27419, in that it limits the bad
behavior of accepting mismatched operands to just x32 mode. The full fix
would be to revert commits 27f134698ac5 and b3a3496f83a1, and to address
the issue in gcc instead.

PR27647 PowerPC extended conditional branch mnemonics

opcodes/
PR 27647
* ppc-opc.c (XLOCB_MASK): Delete.
(XLBOBB_MASK, XLBOBIBB_MASK, XLBOCBBB_MASK): Define using
XLBH_MASK.
(powerpc_opcodes): Accept a BH field on all extended forms of
bclr, bclrl, bcctr, bcctrl, bctar, bctarl.
gas/
PR 27647
* testsuite/gas/ppc/a2.d: Update expected output.
* testsuite/gas/ppc/power8.d: Likewise.

Automatic date update in version.in

gnulib: import gitlog-to-changelog

This is going to be used to generate ChangeLog files.

gdb: remove current_top_target function

The current_top_target function is a hidden dependency on the current
inferior.  Since I'd like to slowly move towards reducing our dependency
on the global current state, remove this function and make callers use

  current_inferior ()->top_target ()

There is no expected change in behavior, but this one step towards
making those callers use the inferior from their context, rather than
refer to the global current inferior.

gdb/ChangeLog:

* target.h (current_top_target): Remove, make callers use the
current inferior instead.
* target.c (current_top_target): Remove.

Change-Id: Iccd457036f84466cdaa3865aa3f9339a24ea001d

gdb: move all "current target" wrapper implementations to target.c

The following patch removes the current_top_target function, replacing
uses with `current_inferior ()->top_target ()`.  This is a problem for
uses in target.h, because they don't have access to the current_inferior
function and the inferior structure: target.h can't include inferior.h,
otherwise that would make a cyclic inclusion.

Avoid this by moving all implementations of the wrappers that call
target methods with the current target to target.c.  Many of them are
changed from a macro to a function, which is an improvement for
readability and debuggability, IMO.

target_shortname and target_longname were not function-like macros, so a
few adjustments are needed.

gdb/ChangeLog:

* target.h (target_shortname): Change to function declaration.
(target_longname): Likewise.
(target_attach_no_wait): Likewise.
(target_post_attach): Likewise.
(target_prepare_to_store): Likewise.
(target_supports_enable_disable_tracepoint): Likewise.
(target_supports_string_tracing): Likewise.
(target_supports_evaluation_of_breakpoint_conditions): Likewise.
(target_supports_dumpcore): Likewise.
(target_dumpcore): Likewise.
(target_can_run_breakpoint_commands): Likewise.
(target_files_info): Likewise.
(target_post_startup_inferior): Likewise.
(target_insert_fork_catchpoint): Likewise.
(target_remove_fork_catchpoint): Likewise.
(target_insert_vfork_catchpoint): Likewise.
(target_remove_vfork_catchpoint): Likewise.
(target_insert_exec_catchpoint): Likewise.
(target_remove_exec_catchpoint): Likewise.
(target_set_syscall_catchpoint): Likewise.
(target_rcmd): Likewise.
(target_can_lock_scheduler): Likewise.
(target_can_async_p): Likewise.
(target_is_async_p): Likewise.
(target_execution_direction): Likewise.
(target_extra_thread_info): Likewise.
(target_pid_to_exec_file): Likewise.
(target_thread_architecture): Likewise.
(target_find_memory_regions): Likewise.
(target_make_corefile_notes): Likewise.
(target_get_bookmark): Likewise.
(target_goto_bookmark): Likewise.
(target_stopped_by_watchpoint): Likewise.
(target_stopped_by_sw_breakpoint): Likewise.
(target_supports_stopped_by_sw_breakpoint): Likewise.
(target_stopped_by_hw_breakpoint): Likewise.
(target_supports_stopped_by_hw_breakpoint): Likewise.
(target_have_steppable_watchpoint): Likewise.
(target_can_use_hardware_watchpoint): Likewise.
(target_region_ok_for_hw_watchpoint): Likewise.
(target_can_do_single_step): Likewise.
(target_insert_watchpoint): Likewise.
(target_remove_watchpoint): Likewise.
(target_insert_hw_breakpoint): Likewise.
(target_remove_hw_breakpoint): Likewise.
(target_can_accel_watchpoint_condition): Likewise.
(target_can_execute_reverse): Likewise.
(target_get_ada_task_ptid): Likewise.
(target_filesystem_is_local): Likewise.
(target_trace_init): Likewise.
(target_download_tracepoint): Likewise.
(target_can_download_tracepoint): Likewise.
(target_download_trace_state_variable): Likewise.
(target_enable_tracepoint): Likewise.
(target_disable_tracepoint): Likewise.
(target_trace_start): Likewise.
(target_trace_set_readonly_regions): Likewise.
(target_get_trace_status): Likewise.
(target_get_tracepoint_status): Likewise.
(target_trace_stop): Likewise.
(target_trace_find): Likewise.
(target_get_trace_state_variable_value): Likewise.
(target_save_trace_data): Likewise.
(target_upload_tracepoints): Likewise.
(target_upload_trace_state_variables): Likewise.
(target_get_raw_trace_data): Likewise.
(target_get_min_fast_tracepoint_insn_len): Likewise.
(target_set_disconnected_tracing): Likewise.
(target_set_circular_trace_buffer): Likewise.
(target_set_trace_buffer_size): Likewise.
(target_set_trace_notes): Likewise.
(target_get_tib_address): Likewise.
(target_set_permissions): Likewise.
(target_static_tracepoint_marker_at): Likewise.
(target_static_tracepoint_markers_by_strid): Likewise.
(target_traceframe_info): Likewise.
(target_use_agent): Likewise.
(target_can_use_agent): Likewise.
(target_augmented_libraries_svr4_read): Likewise.
(target_log_command): Likewise.
* target.c (target_shortname): New.
(target_longname): New.
(target_attach_no_wait): New.
(target_post_attach): New.
(target_prepare_to_store): New.
(target_supports_enable_disable_tracepoint): New.
(target_supports_string_tracing): New.
(target_supports_evaluation_of_breakpoint_conditions): New.
(target_supports_dumpcore): New.
(target_dumpcore): New.
(target_can_run_breakpoint_commands): New.
(target_files_info): New.
(target_post_startup_inferior): New.
(target_insert_fork_catchpoint): New.
(target_remove_fork_catchpoint): New.
(target_insert_vfork_catchpoint): New.
(target_remove_vfork_catchpoint): New.
(target_insert_exec_catchpoint): New.
(target_remove_exec_catchpoint): New.
(target_set_syscall_catchpoint): New.
(target_rcmd): New.
(target_can_lock_scheduler): New.
(target_can_async_p): New.
(target_is_async_p): New.
(target_execution_direction): New.
(target_extra_thread_info): New.
(target_pid_to_exec_file): New.
(target_thread_architecture): New.
(target_find_memory_regions): New.
(target_make_corefile_notes): New.
(target_get_bookmark): New.
(target_goto_bookmark): New.
(target_stopped_by_watchpoint): New.
(target_stopped_by_sw_breakpoint): New.
(target_supports_stopped_by_sw_breakpoint): New.
(target_stopped_by_hw_breakpoint): New.
(target_supports_stopped_by_hw_breakpoint): New.
(target_have_steppable_watchpoint): New.
(target_can_use_hardware_watchpoint): New.
(target_region_ok_for_hw_watchpoint): New.
(target_can_do_single_step): New.
(target_insert_watchpoint): New.
(target_remove_watchpoint): New.
(target_insert_hw_breakpoint): New.
(target_remove_hw_breakpoint): New.
(target_can_accel_watchpoint_condition): New.
(target_can_execute_reverse): New.
(target_get_ada_task_ptid): New.
(target_filesystem_is_local): New.
(target_trace_init): New.
(target_download_tracepoint): New.
(target_can_download_tracepoint): New.
(target_download_trace_state_variable): New.
(target_enable_tracepoint): New.
(target_disable_tracepoint): New.
(target_trace_start): New.
(target_trace_set_readonly_regions): New.
(target_get_trace_status): New.
(target_get_tracepoint_status): New.
(target_trace_stop): New.
(target_trace_find): New.
(target_get_trace_state_variable_value): New.
(target_save_trace_data): New.
(target_upload_tracepoints): New.
(target_upload_trace_state_variables): New.
(target_get_raw_trace_data): New.
(target_get_min_fast_tracepoint_insn_len): New.
(target_set_disconnected_tracing): New.
(target_set_circular_trace_buffer): New.
(target_set_trace_buffer_size): New.
(target_set_trace_notes): New.
(target_get_tib_address): New.
(target_set_permissions): New.
(target_static_tracepoint_marker_at): New.
(target_static_tracepoint_markers_by_strid): New.
(target_traceframe_info): New.
(target_use_agent): New.
(target_can_use_agent): New.
(target_augmented_libraries_svr4_read): New.
(target_log_command): New.
* bfin-tdep.c (bfin_sw_breakpoint_from_kind): Adjust.
* infrun.c (set_schedlock_func): Adjust.
* mi/mi-main.c (exec_reverse_continue): Adjust.
* reverse.c (exec_reverse_once): Adjust.
* sh-tdep.c (sh_sw_breakpoint_from_kind): Adjust.
* tui/tui-stack.c (tui_locator_window::make_status_line): Adjust.
* remote-sim.c (gdbsim_target::detach): Adjust.
(gdbsim_target::files_info): Adjust.

Change-Id: I72ef56e9a25adeb0b91f1ad05e34c89f77ebeaa8

Remove 'kind' parameter from dw2_map_matching_symbols

I noticed that dw2_map_matching_symbols does not use its 'kind'
parameter.  This patch removes it.  Tested by rebuilding.

2021-03-24  Tom Tromey  <tom@tromey.com>

* dwarf2/read.c (dw2_map_matching_symbols): Update.
(dw2_expand_symtabs_matching_symbol): Remove 'kind' parameter.
(check_match, dw2_expand_symtabs_matching)
(dwarf2_debug_names_index::map_matching_symbols)
(dwarf2_debug_names_index::expand_symtabs_matching): Update.

Fix TYPE_DECLARED_CLASS thinko

Simon pointed out an error that I made in
compile_cplus_conver_struct_or_union in my original C++ compile submission:

  if (type->code () == TYPE_CODE_STRUCT)
    {
      const char *what = TYPE_DECLARED_CLASS (type) ? "struct" : "class";

      resuld = instance->plugin ().build_decl
        (what, name.get (), (GCC_CP_SYMBOL_CLASS | nested_access
                             | (TYPE_DECLARED_CLASS (type)
                                ? GCC_CP_FLAG_CLASS_NOFLAG
                                : GCC_CP_FLAG_CLASS_IS_STRUCT)),
         0, nullptr, 0, filename, line);
    }

Notice that WHAT will contain "struct" for TYPE_DECLARED_CLASS. Whoops.

Fortunately this first parameter of build_decl is only used for
debugging.

gdb/ChangeLog
2021-03-24  Keith Seitz  <keiths@redhat.com>

* compile/compile-cplus-types.c
(compile_cplus_convert_struct_or_union): Fix TYPE_DECLARED_CLASS
thinko.

gdb: make gdbarch_data_registry static

This variable was made static in:

  6bd434d6caa4 ("gdb: make some variables static")

But I modified gdbarch.c instead of gdbarch.sh, so the change was
later reverted when gdbarch.c was re-generated.

Do it right this time.

gdb/ChangeLog:

* gdbarch.sh (gdbarch_data_registry): Make static.
* gdbarch.c: Re-generate.

Change-Id: I4048ba99a0cf47acd9da050934965db222fbd159

Add memory tagging testcases

Add an AArch64-specific test and a more generic memory tagging test that
other architectures can run.

Even though architectures not supporting memory tagging can run the memory
tagging tests, the runtime check will make the tests bail out early, as it
would make no sense to proceed without proper support.

It is also tricky to do any further runtime tests for memory tagging, given
we'd need to deal with tags, and those are arch-specific.  Therefore the
test in gdb.base is more of a smoke test.

If an architecture wants to implement memory tagging, then it makes sense to
have tests within gdb.arch instead.

gdb/testsuite/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* gdb.arch/aarch64-mte.c: New file.
* gdb.arch/aarch64-mte.exp: New test.
* gdb.base/memtag.c: New file.
* gdb.base/memtag.exp: New test.
* lib/gdb.exp (supports_memtag): New function.

Add NEWS entry.

Mention the new packets and memory tagging features.

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* NEWS: Mention memory tagging changes.

Document new "x" and "print" memory tagging extensions

Document the changes to the "print" and "x" commands to support memory
tagging.

gdb/doc/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* gdb.texinfo (Data): Document memory tagging changes to the "print"
command.
(Examining Memory): Document memory tagging changes to the "x"
command.
(Memory Tagging): Update with more information on changes to the "x"
and "print" commands.

Extend "x" and "print" commands to support memory tagging

Extend the "x" and "print" commands to make use of memory tagging
functionality, if supported by the architecture.

The "print" command will point out any possible tag mismatches it finds
when dealing with pointers, in case such a pointer is tagged.  No additional
modifiers are needed.

Suppose we have a pointer "p" with value 0x1234 (logical tag 0x0) and that we
have an allocation tag of 0x1 for that particular area of memory. This is the
expected output:

(gdb) p/x p
Logical tag (0x0) does not match the allocation tag (0x1).
$1 = 0x1234

The "x" command has a new 'm' modifier that will enable displaying of
allocation tags alongside the data dump.  It will display one allocation
tag per line.

AArch64 has a tag granule of 16 bytes, which means we can have one tag for
every 16 bytes of memory. In this case, this is what the "x" command will
display with the new 'm' modifier:

(gdb) x/32bxm p
<Allocation Tag 0x1 for range [0x1230,0x1240)>
0x1234: 0x01 0x02 0x00 0x00 0x00 0x00 0x00 0x00
0x123c: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
<Allocation Tag 0x1 for range [0x1240,0x1250)>
0x1244: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x124c: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

(gdb) x/4gxm a
<Allocation Tag 0x1 for range [0x1230,0x1240)>
0x1234: 0x0000000000000201 0x0000000000000000
<Allocation Tag 0x1 for range [0x1240,0x1250)>
0x1244: 0x0000000000000000 0x0000000000000000

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* printcmd.c (decode_format): Handle the 'm' modifier.
(do_examine): Display allocation tags when required/supported.
(should_validate_memtags): New function.
(print_command_1): Display memory tag mismatches.
* valprint.c (show_memory_tag_violations): New function.
(value_print_option_defs): Add new option "memory-tag-violations".
(user_print_options) <memory_tag_violations>: Initialize to 1.
* valprint.h (struct format_data) <print_tags>: New field.
(value_print_options) <memory_tag_violations>: New field.

gdb/testsuite/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* gdb.base/options.exp: Adjust for new print options.
* gdb.base/with.exp: Likewise.

Documentation for the new mtag commands

Document the new "memory-tag" command prefix and all of its subcommands.

gdb/doc/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* gdb.texinfo (Memory Tagging): New subsection and node.
(AArch64 Memory Tagging Extension): New subsection.

New memory-tag commands

Add new commands under the "memory-tag" prefix to allow users to inspect,
modify and check memory tags in different ways.

The available subcommands are the following:

- memory-tag print-logical-tag <expression>: Prints the logical tag for a
  particular address.

- memory-tag withltag <expression> <tag>: Prints the address tagged with the
  logical tag <tag>.

- memory-tag print-allocation-tag <expression>: Prints the allocation tag for
  a particular address.

- memory-tag setatag <expression> <length> <tags>: Sets one or more allocation
  tags to the specified tags.

- memory-tag check <expression>: Checks if the logical tag in <address>
  matches its allocation tag.

These commands make use of the memory tagging gdbarch methods, and are still
available, but disabled, when memory tagging is not supported by the
architecture.

I've pondered about a way to make these commands invisible when memory tagging
is not available, but given the check is at runtime (and support may come and go
based on a process' configuration), that is a bit too late in the process to
either not include the commands or get rid of them.

Ideas are welcome.

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* printcmd.c: Include gdbsupport/rsp-low.h.
(memory_tag_list): New static global.
(process_print_command_args): Factored out of
print_command_1.
(print_command_1): Use process_print_command_args.
(show_addr_not_tagged, show_memory_tagging_unsupported)
(memory_tag_command, memory_tag_print_tag_command)
(memory_tag_print_logical_tag_command)
(memory_tag_print_allocation_tag_command, parse_with_logical_tag_input)
(memory_tag_with_logical_tag_command, parse_set_allocation_tag_input)
(memory_tag_set_allocation_tag_command, memory_tag_check_command): New
functions.
(_initialize_printcmd): Add "memory-tag" prefix and subcommands.

gdbsupport/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* rsp-low.cc (fromhex, hex2bin): Move to ...
* common-utils.cc: ... here.
(fromhex) Change error message text to not be RSP-specific.
* rsp-low.h (fromhex, hex2bin): Move to ...
* common-utils.h: ... here.

AArch64: Add MTE register set support for core files

This patch handles the tagged_addr_ctrl register that is exported when
generating a core file.

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c
(aarch64_linux_iterate_over_regset_sections): Handle MTE register set.
* aarch64-linux-tdep.h (AARCH64_LINUX_SIZEOF_MTE_REGSET): Define.

AArch64: Add gdbserver MTE support

Adds the AArch64-specific memory tagging support (MTE) by implementing the
required hooks and checks for GDBserver.

gdbserver/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* Makefile.in (SFILES): Add /../gdb/nat/aarch64-mte-linux-ptrace.c.
* configure.srv (aarch64*-*-linux*): Add arch/aarch64-mte-linux.o and
nat/aarch64-mte-linux-ptrace.o.
* linux-aarch64-low.cc: Include nat/aarch64-mte-linux-ptrace.h.
(class aarch64_target) <supports_memory_tagging>
<fetch_memtags, store_memtags>: New method overrides.
(aarch64_target::supports_memory_tagging)
(aarch64_target::fetch_memtags)
(aarch64_target::store_memtags): New methods.

AArch64: Report tag violation error information

Whenever a memory tag violation occurs, we get a SIGSEGV. Additional
information can be obtained through the siginfo data structure.

For AArch64 the Linux kernel may expose the fault address and tag
information, if we have a synchronous event. Otherwise there is
no fault address available.

The synchronous event looks like this:

--
(gdb) continue
Continuing.

Program received signal SIGSEGV, Segmentation fault
Memory tag violation while accessing address 0x0500fffff7ff8000
Allocation tag 0x1.
Logical tag 0x5
--

The asynchronous event looks like this:

--
(gdb) continue
Continuing.

Program received signal SIGSEGV, Segmentation fault
Memory tag violation
Fault address unavailable.
--

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c
(aarch64_linux_report_signal_info): New function.
(aarch64_linux_init_abi): Register
aarch64_linux_report_signal_info as the report_signal_info hook.
* arch/aarch64-linux.h (SEGV_MTEAERR): Define.
(SEGV_MTESERR): Define.

AArch64: Add unit testing for logical tag set/get operations

Add some unit testing to exercise setting/getting logical tags in the
AArch64 implementation.

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c: Include gdbsupport/selftest.h.
(aarch64_linux_ltag_tests): New function.
(_initialize_aarch64_linux_tdep): Register aarch64_linux_ltag_tests.

AArch64: Implement the memory tagging gdbarch hooks

This patch implements the memory tagging gdbarch hooks for AArch64, for
the MTE feature.

gdb/ChangeLog:

2021-03-24  Luis Machado  <luis.machado@linaro.org>

* aarch64-linux-tdep.c: Include target.h, arch-utils.h, value.h.
(aarch64_mte_get_atag, aarch64_linux_tagged_address_p)
(aarch64_linux_memtag_mismatch_p, aarch64_linux_set_memtags)
(aarch64_linux_get_memtag, aarch64_linux_memtag_to_string): New
functions.
(aarch64_linux_init_abi): Initialize MTE-related gdbarch hooks.
* arch/aarch64-mte-linux.c (aarch64_mte_make_ltag_bits)
(aarch64_mte_make_ltag, aarch64_linux_set_ltag)
(aarch64_linux_get_ltag): New functions.
* arch/aarch64-mte-linux.h (AARCH64_MTE_LOGICAL_TAG_START_BIT)
(AARCH64_MTE_LOGICAL_MAX_VALUE): Define.
(aarch64_mte_make_ltag_bits, aarch64_mte_make_ltag)
(aarch64_mte_set_ltag, aarch64_mte_get_ltag): New prototypes.