Plus a number of fixes to the pr23169 tests.
* testsuite/lib/ld-lib.exp (check_ifunc_available): Pass without
running executable when non-native.
(check_ifunc_attribute_available): Likewise.
* testsuite/ld-ifunc/pr23169a.rd: Remove extraneous lines. Match
st_other strings. Pass when func is an ifunc.
* testsuite/ld-ifunc/pr23169b.rd: Remove extraneous lines. Correct
reloc regexp. Correct match-anything line.
* testsuite/ld-ifunc/pr23169c.rd: Remove extraneous lines. Match
st_other strings.
Add checks to detect SVE tdesc. Easiest way to do this is by checking the
size of the vector registers.
Use the common aarch64 ptrace copy functions for reading/writing registers.
A wrapper is required due to the common functions using reg_buffer_common.
gdbserver/
* linux-aarch64-low.c (is_sve_tdesc): New function.
(aarch64_sve_regs_copy_to_regcache): Likewise.
(aarch64_sve_regs_copy_from_regcache): Likewise.
(aarch64_regs_info): Add SVE checks.
(initialize_low_arch): Initialize SVE.
Add support for reading and writing registers for Aarch64 SVE.
We need to support the cases where the kernel only gives us a
fpsimd structure. This occurs when there is no active SVE state
in the kernel (for example, after starting a new process).
Added checks to make sure the vector length has not changed whilst
the process is running.
gdb/
* aarch64-linux-nat.c (fetch_sveregs_from_thread): New function.
(store_sveregs_to_thread): Likewise.
(aarch64_linux_fetch_inferior_registers): Check for SVE.
(aarch64_linux_store_inferior_registers): Likewise.
* nat/aarch64-sve-linux-ptrace.c (aarch64_sve_get_sveregs): New
function.
(aarch64_sve_regs_copy_to_regcache): Likewise.
(aarch64_sve_regs_copy_from_regcache): Likewise.
* nat/aarch64-sve-linux-ptrace.h (aarch64_sve_get_sveregs): New
declaration.
(aarch64_sve_regs_copy_to_regcache): Likewise.
(aarch64_sve_regs_copy_from_regcache): Likewise.
(sve_context): Structure from Linux headers.
(SVE_SIG_ZREGS_SIZE): Define from Linux headers.
(SVE_SIG_ZREG_SIZE): Likewise.
(SVE_SIG_PREG_SIZE): Likewise.
(SVE_SIG_FFR_SIZE): Likewise.
(SVE_SIG_REGS_OFFSET): Likewise.
(SVE_SIG_ZREGS_OFFSET): Likewise.
(SVE_SIG_ZREG_OFFSET): Likewise.
(SVE_SIG_ZREGS_SIZE): Likewise.
(SVE_SIG_PREGS_OFFSET): Likewise.
(SVE_SIG_PREG_OFFSET): Likewise.
(SVE_SIG_PREGS_SIZE): Likewise.
(SVE_SIG_FFR_OFFSET): Likewise.
(SVE_SIG_REGS_SIZE): Likewise.
(SVE_SIG_CONTEXT_SIZE): Likewise.
(SVE_PT_REGS_MASK): Likewise.
(SVE_PT_REGS_FPSIMD): Likewise.
(SVE_PT_REGS_SVE): Likewise.
(SVE_PT_VL_INHERIT): Likewise.
(SVE_PT_VL_ONEXEC): Likewise.
(SVE_PT_REGS_OFFSET): Likewise.
(SVE_PT_FPSIMD_OFFSET): Likewise.
(SVE_PT_FPSIMD_SIZE): Likewise.
(SVE_PT_SVE_ZREG_SIZE): Likewise.
(SVE_PT_SVE_PREG_SIZE): Likewise.
(SVE_PT_SVE_FFR_SIZE): Likewise.
(SVE_PT_SVE_FPSR_SIZE): Likewise.
(SVE_PT_SVE_FPCR_SIZE): Likewise.
(__SVE_SIG_TO_PT): Likewise.
(SVE_PT_SVE_OFFSET): Likewise.
(SVE_PT_SVE_ZREGS_OFFSET): Likewise.
(SVE_PT_SVE_ZREG_OFFSET): Likewise.
(SVE_PT_SVE_ZREGS_SIZE): Likewise.
(SVE_PT_SVE_PREGS_OFFSET): Likewise.
(SVE_PT_SVE_PREG_OFFSET): Likewise.
(SVE_PT_SVE_PREGS_SIZE): Likewise.
(SVE_PT_SVE_FFR_OFFSET): Likewise.
(SVE_PT_SVE_FPSR_OFFSET): Likewise.
(SVE_PT_SVE_FPCR_OFFSET): Likewise.
(SVE_PT_SVE_SIZE): Likewise.
(SVE_PT_SIZE): Likewise.
(HAS_SVE_STATE): New define.
gdbserver/
* Makefile.in: Add aarch64-sve-linux-ptrace.c.
This header provides compatibility support for SVE allow building
even when the underlying host system lacks support for SVE.
If the binary is then run on an SVE-enabled kernel then support
will automatically be available.
gdb/
* nat/aarch64-sve-linux-sigcontext.h: New file.
* nat/aarch64-sve-linux-ptrace.h (SVE_VQ_BYTES): Move to
new files.
(SVE_VQ_MIN): Likewise.
(SVE_VQ_MAX): Likewise.
(SVE_VL_MIN): Likewise.
(SVE_VL_MAX): Likewise.
(SVE_NUM_ZREGS): Likewise.
(SVE_NUM_PREGS): Likewise.
(sve_vl_valid): Likewise.
(struct user_sve_header): Likewise.
At the moment, bp_inlined_func.exp passes for a combined current gcc and
gdb-binutils repos build but fails for a build with system gcc (7.3.1) and
ld (2.29.1).
It checks for 4 breakpoints on read_small:
...
gdb_test "break read_small" \
"Breakpoint $decimal at $hex: read_small\\. \\(4 locations\\)" \
"set breakpoint at read_small"
...
and fails because it gets 5 breakpoint locations instead:
...
(gdb) break read_small
Breakpoint 2 at 0x401f9a: read_small. (5 locations)
(gdb) FAIL: gdb.ada/bp_inlined_func.exp: set breakpoint at read_small
...
The 4 expected breakpoint locations are inlined versions of read_small, and
the 5th breakpoint location has this address:
...
(gdb) info breakpoint
Num Type Disp Enb Address What
1 breakpoint keep y <MULTIPLE>
1.1 y 0x0000000000401f9a in b.read_small
at bp_inlined_func/b.adb:20
...
which is the read_small function itself:
...
(gdb) x 0x0000000000401f9a
0x401f9a <b__read_small+4>: 0x22f8058b
...
This patch updates the test to allow 5 breakpoint locations.
Tested on the configurations mentioned above, on x86_64.
2018-06-18 Tom de Vries <tdevries@suse.de>
* gdb.ada/bp_inlined_func.exp: Allow 5 breakpoint locations.
This patch fixes an issue where GDB would sometimes hang when
attaching to a multi-threaded process. This issue was especially
likely to trigger if the machine (running the inferior) was under
load.
In summary, the problem is an imbalance between two functions in
linux-nat.c, stop_callback and stop_wait_callback. In stop_callback
we send SIGSTOP to a thread, but _only_ if the thread is not already
stopped, and if it is not signalled, which means it should stop soon.
In stop_wait_callback we wait for the SIGSTOP to arrive, however, we
are aware that the thread might have been signalled for some other
reason, and so if a signal other than SIGSTOP causes the thread to
stop then we stash that signal away so it can be reported back later.
If we get a SIGSTOP then this is discarded, after all, this signal was
sent from stop_callback. Except that this might not be the case, it
could be that SIGSTOP was sent to a thread from elsewhere in GDB, in
which case we would not have sent another SIGSTOP from stop_callback
and the SIGSTOP received in stop_wait_callback should not be ignored.
Below I've laid out the exact sequence of events that I saw that lead
me to track down the above diagnosis.
After attaching to the inferior GDB sends a SIGSTOP to all of the
threads and then returns to the event loop waiting for interesting
things to happen.
Eventually the first target event is detected (this will be the first
SIGSTOP arriving) and GDB calls inferior_event_handler which calls
fetch_inferior_event. Inside fetch_inferior_event GDB calls
do_target_wait which calls target_wait to find a thread with an event.
The target_wait call ends up in linux_nat_wait_1, which first checks
to see if any threads already have stashed stop events to report, and
if there are none then we enter a loop fetching as many events as
possible out of the kernel. This event fetching is non-blocking, and
we give up once the kernel has no more events ready to give us.
All of the events from the kernel are passed through
linux_nat_filter_event which stashes the wait status for all of the
threads that reported a SIGSTOP, these will be returned by future
calls to linux_nat_wait_1.
Lets assume for a moment that we've attached to a multi-threaded
inferior, and that all but one thread has reported its stop during the
initial wait call in linux_nat_wait_1. The other thread will be
reporting a SIGSTOP, but the kernel has not yet managed to deliver
that signal to GDB before GDB gave up waiting and continued handling
the events it already had. GDB selects one of the threads that has
reported a SIGSTOP and passes this thread ID back to
fetch_inferior_event.
To handle the thread's SIGSTOP, GDB calls handle_signal_stop, which
calls stop_all_threads, this calls wait_one, which in turn calls
target_wait.
The first call to target_wait at this point will result in a stashed
wait status being returned, at which point we call setup_inferior.
The call to setup_inferior leads to a call into try_thread_db_load_1
which results in a call to linux_stop_and_wait_all_lwps. This in turn
calls stop_callback on each thread followed by stop_wait_callback on
each thread.
We're now ready to make the mistake. In stop_callback we see that our
problem thread is not stopped, but is signalled, so it should stop
soon. As a result we don't send another SIGSTOP.
We then enter stop_wait_callback, eventually the problem thread stops
with SIGSTOP which we _incorrectly_ assume came from stop_callback,
and we discard.
Once stop_wait_callback has done its damage we return from
linux_stop_and_wait_all_lwps, finish in try_thread_db_load_1, and
eventually unwind back to the call to setup_inferior in
stop_all_threads. GDB now loops around, and performs another
target_wait to get the next event from the inferior.
The target_wait calls causes us to once again reach linux_nat_wait_1,
and we pass through some code that calls resume_stopped_resumed_lwps.
This allows GDB to resume threads that are physically stopped, but
which GDB doesn't see any good reason for the thread to remain
stopped. In our case, the problem thread which had its SIGSTOP
discarded is stopped, but doesn't have a stashed wait status to
report, and so GDB sets the thread going again.
We are now stuck waiting for an event on the problem thread that might
never arrive.
When considering how to write a test for this bug I struggled. The
issue was only spotted _randomly_ when a machine was heavily loaded
with many multi-threaded applications, and GDB was being attached (by
script) to all of these applications in parallel. In one reproducer I
required around 5 applications each of 5 threads per machine core in
order to reproduce the bug 2 out of 3 times.
What we really want to do though is simulate the kernel being slow to
report events through waitpid during the initial attach. The solution
I came up with was to write an LD_PRELOAD library that intercepts
(some) waitpid calls and rate limits them to one per-second. Any more
than that simply return 0 indicating there's no event available.
Obviously this can only be applied to waitpid calls that have the
WNOHANG flag set.
Unfortunately, once you ignore a waitpid call GDB can get a bit stuck.
Usually, once the kernel has made a child status available to waitpid
GDB will be sent a SIGCHLD signal. However, if the kernel makes 5
child statuses available but, due to the preload library we only
collect one of them, then the kernel will not send any further SIGCHLD
signals, and so, when GDB, thinking that the remaining statuses have
not yet arrived sits waiting for a SIGCHLD it will be disappointed.
The solution, implemented within the preload library, is that, when we
hold back a waitpid result from GDB we spawn a new thread. This
thread delays for a short period, and then sends GDB a SIGCHLD. This
causes GDB to retry the waitpid, at which point sufficient time has
passed and our library allows the waitpid call to complete.
gdb/ChangeLog:
* linux-nat.c (stop_wait_callback): Don't discard SIGSTOP if it
was requested by GDB.
gdb/testsuite/ChangeLog:
* gdb.threads/attach-slow-waitpid.c: New file.
* gdb.threads/attach-slow-waitpid.exp: New file.
* gdb.threads/slow-waitpid.c: New file.
I've committed one patch modifying gdb ([gdb/cli] Honour 'print pretty' when
printing result of finish command) and I'm covered by the Novell blanket
copyright assignment. So AFAIU, I qualify for write-after-approval.
This patch adds me to the MAINTAINERS file in the write-after-approval section.
2018-06-15 Tom de Vries <tdevries@suse.de>
* MAINTAINERS (Write After Approval): Add Tom de Vries.
Update the messages printed when the wrong version of autoconf/aclocal
is found to include the expected version too, like we already do for
automake.
gdb/ChangeLog:
* gnulib/update-gnulib.sh: Print expected versions of
autoconf/aclocal.
The type alignment value is returned in 8-bit-bytes instead of target
memory addressable units. For example, on a target with 16-bit-bytes
where sizeof(int) == 1 (one addressable unit), alignof(int) currently
returns 2. After, this patch, it returns 1.
gdb/ChangeLog:
* arch-utils.c (default_type_align): Use type_length_units.
* gdbtypes.c (type_align): Use type_length_units.
GDB build on AIX is broken according to BuildBot:
../../binutils-gdb/gdb/aix-thread.c: In member function 'virtual void aix_thread_target::mourn_inferior()':
../../binutils-gdb/gdb/aix-thread.c:1735:34: error: 'beneath' cannot be used as a function
target_ops *beneath = beneath ();
^
This obvious commit fixes it. There's apparently another issue
breaking the build there, but that's unrelated.
gdb/ChangeLog:
2018-06-14 Sergio Durigan Junior <sergiodj@redhat.com>
* aix-thread.c (aix_thread_target::xfer_partial): Use
"beneath" as a method.
Add support for the Global INValidate Application Specific Extension
for Release 6 of the MIPS Architecture.
[1] "MIPS Architecture for Programmers Volume II-A: The MIPS32
Instruction Set Manual", Imagination Technologies Ltd., Document
Number: MD00086, Revision 6.06, December 15, 2016, Section 3.2
"Alphabetical List of Instructions", pp. 187-191
bfd/
* elfxx-mips.c (print_mips_ases): Add GINV extension.
binutils/
* readelf.c (print_mips_ases): Add GINV extension.
gas/
* NEWS: Mention MIPS Global INValidate ASE support.
* config/tc-mips.c (options): Add OPTION_GINV and OPTION_NO_GINV.
(md_longopts): Likewise.
(mips_ases): Define availability for GINV.
(mips_convert_ase_flags): Map ASE_GINV to AFL_ASE_GINV.
(md_show_usage): Add help for -mginv and -mno-ginv.
* doc/as.texinfo: Document -mginv, -mno-ginv.
* doc/c-mips.texi: Document -mginv, -mno-ginv, .set ginv and
.set noginv.
* testsuite/gas/mips/ase-errors-1.s: Add error checks for GINV
ASE.
* testsuite/gas/mips/ase-errors-2.s: Likewise.
* testsuite/gas/mips/ase-errors-1.l: Likewise.
* testsuite/gas/mips/ase-errors-2.l: Likewise.
* testsuite/gas/mips/ginv.d: New test.
* testsuite/gas/mips/ginv-err.d: New test.
* testsuite/gas/mips/ginv-err.l: New test stderr output.
* testsuite/gas/mips/ginv.s: New test source.
* testsuite/gas/mips/ginv-err.s: New test source.
* testsuite/gas/mips/mips.exp: Run the new tests.
include/
* elf/mips.h (AFL_ASE_GINV, AFL_ASE_RESERVED1): New macros.
(AFL_ASE_MASK): Update to include AFL_ASE_GINV.
* opcode/mips.h: Document "+\" operand format.
(ASE_GINV): New macro.
opcodes/
* mips-dis.c (mips_arch_choices): Add GINV to mips32r6 and
mips64r6 descriptors.
(parse_mips_ase_option): Handle -Mginv option.
(print_mips_disassembler_options): Document -Mginv.
* mips-opc.c (decode_mips_operand) <+\>: New operand format.
(GINV): New macro.
(mips_opcodes): Define ginvi and ginvt.
There is an inconsistency between the doc and the online help.
=> the doc is correct, so fixing/improving the on-line help.
2018-06-14 Philippe Waroquiers <philippe.waroquiers@skynet.be>
* cli/cli-script.c (_initialize_cli_script): Fix online documentation
of 'define' command.
GDB's execution commands have a foreground and background variant: f.i.,
there's 'continue' and 'continue&', and both are listed individually in the
'Command, Variable, and Function Index'. But the '&' is not listed in the
'Concept Index' as being connected with the concept background execution.
This patch adds an '&' in the 'Concept Index':
...
* $_, $__, and value history: Memory. (line 119)
+* &, background execution of commands: Background Execution.
+ (line 16)
* --annotate: Mode Options. (line 121)
...
pointing to this line in 'Background Execution':
...
To specify background execution, add a '&' to the command.
...
Build on x86_64.
2018-06-14 Tom de Vries <tdevries@suse.de>
* gdb.texinfo (Background Execution): Add @cindex for '&'.
Currently, the gdb.base/fork-running-state.exp testcase leaves a few
processes lingering until a 3 minutes alarm kills them:
pedro 28308 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
pedro 28340 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
pedro 28372 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
pedro 28400 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
pedro 28431 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
pedro 28463 1 0 13:55 ? 00:00:00 /home/pedro/gdb/binutils-gdb/build/gdb/testsuite/outputs/gdb.base/fork-running-state/fork-running-state
Those processes used to kill themselves, but that was changed by
commit f50d8a2eae ("Fix gdb.base/fork-running-state.exp race").
This commit restores the self-killing, but only in the cases gdb won't
try killing the processes, thus avoiding the old race.
(The restored code in fork_parent isn't exactly the same as it was.
In this version, we're exiting immediately when 'wait' returns
success, while in the old version we'd loop again and end up in the
perror call. The output from that perror call is not expected by the
"kill inferior" tests, and would result in a test FAIL.)
gdb/testsuite/ChangeLog:
2018-06-14 Pedro Alves <palves@redhat.com>
* gdb.base/fork-running-state.c: Include <errno.h>.
(exit_if_relative_exits): New.
(fork_child): If 'exit_if_relative_exits' is true, exit if the parent
exits.
(fork_parent): If 'exit_if_relative_exits' is true, exit if the
child exits.
Consider this testcase:
...
struct s {
int a;
int b;
};
struct s foo ()
{
struct s r;
r.a = 1;
r.b = 2;
return r;
}
int
main (void)
{
struct s v;
v = foo ();
return v.a + v.b;
}
...
When we compile it with -g, load the exec with gdb, and run till the end of foo,
we can print r:
...
(gdb) p r
$1 = {a = 1, b = 2}
...
and by setting pretty printing to on, we can get the fields of r printed each
on its own line:
...
(gdb) set print pretty
(gdb) p r
$2 = {
a = 1,
b = 2
}
...
However, when we finish foo, the printed function result value is not using
the pretty printing setting:
...
(gdb) finish
Run till exit from #0 foo () at test.c:11
0x00000000004004c1 in main () at test.c:18
18 v = foo ();
Value returned is $3 = {a = 1, b = 2}
...
This patch fixes that by using get_user_print_options instead of
get_no_prettyformat_print_options in print_return_value_1, which gives us:
...
(gdb) finish
Run till exit from #0 foo () at test.c:11
0x00000000004004c1 in main () at test.c:18
18 v = foo ();
Value returned is $2 = {
a = 1,
b = 2
}
...
Build & reg-tested on x86_64.
2018-06-14 Tom de Vries <tdevries@suse.de>
PR cli/22573
* infcmd.c (print_return_value_1): Use get_user_print_options instead of
get_no_prettyformat_print_options.
* gdb.base/finish-pretty.c: New test.
* gdb.base/finish-pretty.exp: New file.
Check VER_FLG_BASE instead of assuming that the first symbol version is
base version.
bfd/
PR binutils/23267
* elf.c (_bfd_elf_get_symbol_version_string): Check if the first
symbol version is base version.
binutils/
PR binutils/23267
* readelf.c (get_symbol_version_string): Check if the first
symbol version is base version.
This regex had to be touched at least twice these past few days. Use
multi_line to make it more readable.
Note this also tightens the regex a little bit in some spots.
gdb/testsuite/ChangeLog:
2018-06-14 Pedro Alves <palves@redhat.com>
* gdb.gdb/selftest.exp (test_with_self): Use multi_line to build
gdb's expected startup output.
gdb/ChangeLog:
yyyy-mm-dd Pedro Alves <palves@redhat.com>
* inline-frame.c (stopped_by_user_bp_inline_frame): Replace PC
parameter with a block parameter. Compare location's block symbol
with the frame's block instead of addresses.
(skip_inline_frames): Pass the current block instead of the
frame's address. Break out as soon as we determine the frame
should not be skipped.
gdb/testsuite/ChangeLog:
yyyy-mm-dd Pedro Alves <palves@redhat.com>
* gdb.opt/inline-break.c (func_callee, func_caller): New.
(main): Call func_caller.
Before commit 70ee000084 ("[gdb] Allow function arguments in bp
print match in selftest_setup"), this pattern in selftest_setup:
-re "Starting program.*Breakpoint \[0-9\]+,.* at .*main.c:.*$function.*$gdb_prompt $" {
# $function may be inlined, so the program stops at the line
# calling $function.
pass "$description"
}
happened to match if captured_main_1 was inlined and captured_main was
not, because captured_main calls captured_main_1 first thing, which
coincidentally matches "$function.*":
Breakpoint 1, captured_main (data=<optimized out>) at src/gdb/main.c:1147
1147 captured_main_1 (context);
That would probably be better "$function .*", with a space, but I
think that even better is to remove the "may be inlined" case too now,
because since ddfe970e6b ("Don't elide all inlined frames") GDB
presents the stop at the inline function instead of at the caller.
gdb/testsuite/ChangeLog:
2018-06-14 Pedro Alves <palves@redhat.com>
* lib/selftest-support.exp (selftest_setup): Remove inlined
function handling.
Many ELF targets arrange to emit a number of section symbols in
.dynsym for use by dynamic relocations. This happens before the
dynamic relocations are output, and the need for those symbols
determined. In most cases they are not needed. A proper analysis of
the need for dynamic section symbols is target specific and tedious,
so this patch just excludes them in the obvious case when no
dynamic relocations are present.
The patch also runs the new pr23161 and pr23162 tests on more targets.
bfd/
* elf-bfd.h (struct elf_link_hash_table): Add "dynamic_relocs".
* elflink.c (_bfd_elf_init_2_index_sections): Comment fix.
(_bfd_elf_add_dynamic_entry): Set "dynamic_relocs".
(_bfd_elf_link_renumber_dynsyms): Exclude all section symbols when
"dynamic_relocs" is not set.
* elfxx-mips.c (count_section_dynsyms): Likewise.
ld/
* testsuite/ld-elf/readelf.exp: Delete DUMP and selection of
variant ver_def.vd.
* testsuite/ld-elf/ver_def-tic6x.vd: Delete.
* testsuite/ld-elf/shared.exp: Run most pr23161 and pr23162 tests for
linux, nacl and gnu targets.
* testsuite/ld-mips-elf/mips-elf.exp: Set base_syms to 1.
* testsuite/ld-elf/pr23161a.rd: Don't check reloc type. Allow any
order of __bss_start, _edata and _end.
* testsuite/ld-elf/pr23161b.rd: Don't check plt and dyn relocs.
Allow and order of __bss_start, _edata and _end.
* testsuite/ld-elf/pr23162.rd: Fail if __bss_start, _edata or _end
relocs are present rather than testing for no relocations.
* testsuite/ld-aarch64/gc-plt-relocs.d,
* testsuite/ld-aarch64/ifunc-1-local.d,
* testsuite/ld-aarch64/ifunc-1.d,
* testsuite/ld-aarch64/ifunc-2-local.d,
* testsuite/ld-aarch64/ifunc-2.d,
* testsuite/ld-aarch64/ifunc-21.d,
* testsuite/ld-aarch64/ifunc-3a.d,
* testsuite/ld-arm/farcall-mixed-lib-v4t.d,
* testsuite/ld-arm/farcall-mixed-lib.d,
* testsuite/ld-arm/gc-hidden-1.d,
* testsuite/ld-arm/tls-gdesc-got.d,
* testsuite/ld-arm/tls-lib-loc.d,
* testsuite/ld-arm/tls-longplt-lib.d,
* testsuite/ld-arm/tls-thumb1.d,
* testsuite/ld-cris/libdso-10.d,
* testsuite/ld-cris/libdso-11.d,
* testsuite/ld-cris/libdso-13b.d,
* testsuite/ld-cris/libdso-14.d,
* testsuite/ld-cris/libdso-15.d,
* testsuite/ld-cris/pic-gc-72.d,
* testsuite/ld-cris/pic-gc-73.d,
* testsuite/ld-cris/tls-gc-71.d,
* testsuite/ld-mips-elf/mips16-pic-4a.nd,
* testsuite/ld-mips-elf/pic-and-nonpic-3a.dd,
* testsuite/ld-mips-elf/pie-n32.d,
* testsuite/ld-mips-elf/pie-n64.d,
* testsuite/ld-mips-elf/pie-o32.d: Update for removed dynamic
section symbols.
Cross-compiling for sparc64 bumped into a few issues, fixed by this
patch.
1. Include target.h in sparc-nat.h fixes:
/home/emaisin/src/binutils-gdb/gdb/sparc-nat.h:45:8: error: ‘target_xfer_status’ does not name a type
extern target_xfer_status sparc_xfer_wcookie (enum target_object object,
2. Remove extra semi-colon at sparc64-linux-nat.c:40 fixes:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c:41:3: error: expected unqualified-id before ‘{’ token
{ sparc_store_inferior_registers (this, regcache, regnum); }
3. Remove "this" argument fixes:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c: In member function ‘virtual void sparc64_linux_nat_target::fetch_registers(regcache*, int)’:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c:38:59: error: cannot convert ‘sparc64_linux_nat_target*’ to ‘regcache*’ for argument ‘1’ to ‘void sparc_fetch_inferior_registers(regcache*, int)’
{ sparc_fetch_inferior_registers (this, regcache, regnum); }
^
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c: In member function ‘virtual void sparc64_linux_nat_target::store_registers(regcache*, int)’:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c:41:59: error: cannot convert ‘sparc64_linux_nat_target*’ to ‘regcache*’ for argument ‘1’ to ‘void sparc_store_inferior_registers(regcache*, int)’
{ sparc_store_inferior_registers (this, regcache, regnum); }
^
4. Use sparc64_forget_process instead of sparc_forget_process fixes:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c: In member function ‘virtual void sparc64_linux_nat_target::low_forget_process(pid_t)’:
/home/emaisin/src/binutils-gdb/gdb/sparc64-linux-nat.c:47:30: error: ‘sparc_forget_process’ was not declared in this scope
{ sparc_forget_process (pid); }
^
gdb/ChangeLog:
* sparc-nat.h: Include target.h.
* sparc64-linux-nat.c (class sparc64_linux_nat_target)
<fetch_registers>: Remove this argument in function call.
<store_registers>: Remove this argument in function call, remove
extra semicolon.
<low_forget_process>: Call sparc64_forget_process instead of
sparc_forget_process.
Add support for the CRC Application Specific Extension for Release 6 of
the MIPS Architecture.
[1] "MIPS Architecture for Programmers Volume II-A: The MIPS32
Instruction Set Manual", Imagination Technologies Ltd., Document
Number: MD00086, Revision 6.06, December 15, 2016, Section 3.2
"Alphabetical List of Instructions", pp. 143-148
[2] "MIPS Architecture for Programmers Volume II-A: The MIPS64
Instruction Set Manual", Imagination Technologies Ltd., Document
Number: MD00087, Revision 6.06, December 15, 2016, Section 3.2
"Alphabetical List of Instructions", pp. 165-170
ChangeLog:
bfd/
2018-06-13 Scott Egerton <scott.egerton@imgtec.com>
Faraz Shahbazker <Faraz.Shahbazker@mips.com>
* elfxx-mips.c (print_mips_ases): Add CRC.
binutils/
2018-06-13 Scott Egerton <scott.egerton@imgtec.com>
Faraz Shahbazker <Faraz.Shahbazker@mips.com>
* readelf.c (print_mips_ases): Add CRC.
gas/
2018-06-13 Scott Egerton <scott.egerton@imgtec.com>
Faraz Shahbazker <Faraz.Shahbazker@mips.com>
Maciej W. Rozycki <macro@mips.com>
* config/tc-mips.c (options): Add OPTION_CRC and OPTION_NO_CRC.
(md_longopts): Likewise.
(md_show_usage): Add help for -mcrc and -mno-crc.
(mips_ases): Define availability for CRC and CRC64.
(mips_convert_ase_flags): Map ASE_CRC to AFL_ASE_CRC.
* doc/as.texinfo: Document -mcrc, -mno-crc.
* doc/c-mips.texi: Document -mcrc, -mno-crc, .set crc and
.set no-crc.
* testsuite/gas/mips/ase-errors-1.l: Add error checks for CRC
ASE.
* testsuite/gas/mips/ase-errors-2.l: Likewise.
* testsuite/gas/mips/ase-errors-1.s: Likewise.
* testsuite/gas/mips/ase-errors-2.s: Likewise.
* testsuite/gas/mips/crc.d: New test.
* testsuite/gas/mips/crc64.d: New test.
* testsuite/gas/mips/crc-err.d: New test.
* testsuite/gas/mips/crc64-err.d: New test.
* testsuite/gas/mips/crc-err.l: New test stderr output.
* testsuite/gas/mips/crc64-err.l: New test stderr output.
* testsuite/gas/mips/crc.s: New test source.
* testsuite/gas/mips/crc64.s: New test source.
* testsuite/gas/mips/crc-err.s: New test source.
* testsuite/gas/mips/crc64-err.s: New test source.
* testsuite/gas/mips/mips.exp: Run the new tests.
include/
2018-06-13 Scott Egerton <scott.egerton@imgtec.com>
Faraz Shahbazker <Faraz.Shahbazker@mips.com>
* elf/mips.h (AFL_ASE_CRC): New macro.
(AFL_ASE_MASK): Update to include AFL_ASE_CRC.
* opcode/mips.h (ASE_CRC): New macro.
* opcode/mips.h (ASE_CRC64): Likewise.
opcodes/
2018-06-13 Scott Egerton <scott.egerton@imgtec.com>
Faraz Shahbazker <Faraz.Shahbazker@mips.com>
* mips-dis.c (mips_arch_choices): Add CRC and CRC64 ASEs.
* mips-opc.c (CRC, CRC64): New macros.
(mips_builtin_opcodes): Define crc32b, crc32h, crc32w,
crc32cb, crc32ch and crc32cw for CRC. Define crc32d and
crc32cd for CRC64.
When I run make check:
...
$ cd build/gdb
$ make check 2>&1 | tee ../CHECKLOG.gdb
...
I see after ~30m the summary of the test run printed, but make still hangs.
This seems to be due to some sleeping processes:
...
$ ps fx | grep fork-run
6475 ? S 0:00 gdb.base/fork-running-state/fork-running-state
6451 ? S 0:00 gdb.base/fork-running-state/fork-running-state
6427 ? S 0:00 gdb.base/fork-running-state/fork-running-state
...
Killing the sleeping processes like this:
...
kill -9 $(ps -A | grep fork-running-st | awk '{print $1}')
...
allows make to finish.
If I isolate one debug session from fork-running-state.exp that causes one of
these sleeping processes, we get:
...
(gdb) set non-stop on
(gdb) break main
Breakpoint 1 at 0x400665: file src/gdb/testsuite/gdb.base/fork-running-state.c,
line 52.
(gdb) run
Starting program: build/gdb/testsuite/outputs/gdb.base/fork-running-state/
fork-running-state
Breakpoint 1, main () at src/gdb/testsuite/gdb.base/fork-running-state.c:52
52 save_parent = getpid ();
(gdb) set detach-on-fork on
(gdb) set follow-fork parent
(gdb) continue &
Continuing.
[Detaching after fork from child process 18797]
(gdb) info threads
Id Target Id Frame
* 1 process 18793 "fork-running-st" (running)
(gdb) set print inferior-events off
(gdb) kill inferior 1
...
So, AFAIU, the hanging process is the child process that gdb detaches from.
There's an alarm set in main before the fork, but alarms are not preserved in
the fork child:
...
$ man alarm
...
NOTES
Alarms created by alarm() are preserved across execve(2) and are not
inherited by children created via fork(2).
...
So, AFAIU, once the parent is killed, there's no alarm to terminate the child.
The patch fixes this by moving the setting of the alarm into the
fork_main/fork_child functions, making sure that an alarm will trigger for
the child.
Tested with make check on x86_64.
2018-06-13 Tom de Vries <tdevries@suse.de>
PR testsuite/23269
* gdb.base/fork-running-state.c (main): Move setting of alarm ...
(fork_child): ... here, and ...
(fork_parent): ... here.
Atm selftest.exp fails for me.
One of the reasons is that in c61b06a19a (Remove
some text from --version output) an eol was added after "There is NO
WARRANTY, to the extent permitted by law".
This patch updates the matching of the gdb startup message in selftest.exp
accordingly.
Tested selftest.exp (with two other selftest.exp related fixes applied).
2018-06-12 Tom de Vries <tdevries@suse.de>
* gdb.gdb/selftest.exp (test_with_self): Update gdb startup text.
procfs.c currently doesn't compile on Solaris:
/vol/src/gnu/gdb/gdb/local/gdb/procfs.c: In function `void _initialize_procfs()':
/vol/src/gnu/gdb/gdb/local/gdb/procfs.c:3734:15: error: invalid initialization of reference of type `const target_info&' from expression of type `procfs_target*'
add_target (&the_procfs_target);
^~~~~~~~~~~~~~~~~~
In file included from /vol/src/gnu/gdb/gdb/local/gdb/inferior.h:40,
from /vol/src/gnu/gdb/gdb/local/gdb/procfs.c:24:
/vol/src/gnu/gdb/gdb/local/gdb/target.h:2305:13: note: in passing argument 1 of `void add_target(const target_info&, void (*)(const char*, int), void (*)(cmd_list_element*, completion_tracker&, const char*, const char*))'
extern void add_target (const target_info &info,
^~~~~~~~~~
/vol/src/gnu/gdb/gdb/local/gdb/procfs.c: In member function `virtual char* procfs_target::make_corefile_notes(bfd*, int*)':
/vol/src/gnu/gdb/gdb/local/gdb/procfs.c:3898:16: error: too many arguments to function `gdb::optional<std::vector<unsigned char, gdb::default_init_allocator<unsigned char, std::allocator<unsigned char> > > > target_read_alloc(target_ops*, target_object, const char*)'
NULL, &auxv);
^
In file included from /vol/src/gnu/gdb/gdb/local/gdb/inferior.h:40,
from /vol/src/gnu/gdb/gdb/local/gdb/procfs.c:24:
/vol/src/gnu/gdb/gdb/local/gdb/target.h:341:40: note: declared here
extern gdb::optional<gdb::byte_vector> target_read_alloc
^~~~~~~~~~~~~~~~~
/vol/src/gnu/gdb/gdb/local/gdb/procfs.c:3898:16: error: cannot convert `gdb::optional<std::vector<unsigned char, gdb::default_init_allocator<unsigned char, std::allocator<unsigned char> > > >' to `int' in assignment
NULL, &auxv);
^
Fixed as follows. Built and ran make check on 64-bit Solaris 11.5/x86
(amd64-pc-solaris2.11) only.
* procfs.c (_initialize_procfs): Use add_inf_child_target.
(procfs_target::make_corefile_notes): Adjust to new
target_read_alloc return type.
When making an inferior call, and non-stop mode is off, then, once the
inferior call is complete all threads will be stopped, and we should
run the INF_EXEC_COMPLETE handler. This will result in a call to
'target_async(0)' to remove the event handlers for the target.
This was discussed by Yao Qi in this mailing list thread:
https://sourceware.org/ml/gdb/2017-10/msg00032.html
Without this then the target event handlers are left in place even
when the target is stopped, which is different to what happens during
a standard stop proceedure (for example when one thread hits a
breakpoint).
gdb/ChangeLog:
PR gdb/22882
* infrun.c (fetch_inferior_event): If GDB is not proceeding then
run INF_EXEC_COMPLETE handler, even when not calling normal_stop.
Move should_notify_stop local into more inner scope.
In PR22882 inferior functions are called on different threads while
scheduler-locking is turned on. This results in a hang. This was
discussed in this mailing list thread:
https://sourceware.org/ml/gdb/2017-10/msg00032.html
The problem is that when the thread is set running in order to execute
the inferior call, a call to target_async is made. If the target is
not already registered as 'target_async' then this will install the
async event handler, AND unconditionally mark the handler as having an
event pending.
However, if the target is already registered as target_async then the
event handler is not installed (its already installed) and the
handler is NOT marked as having an event pending.
If we try to set running a thread that already has a pending event,
then we do want to set target_async, however, there will not be an
external event incoming (the thread is already stopped) so we rely on
manually marking the event handler as having a pending event in order
to see the threads pending stop event. This is fine, if, at the point
where we call target_async, the target is not already marked as async.
But, if it is, then the event handler will not be marked as ready, and
the threads pending stop event will never be processed.
A similar pattern of code can be seen in linux_nat_target::resume,
where, when a thread has a pending event, the call to target_async is
followed by a call to async_file_mark to ensure that the pending
thread event will be processed, even if target_async was already set.
gdb/ChangeLog:
PR gdb/22882
* infrun.c (resume_1): Add call to mark_async_event_handler.
gdb/testsuite/ChangeLog:
* gdb.threads/multiple-successive-infcall.exp: Remove kfail case,
rewrite test to describe action performed, rather than possible
failure.
Run the test gdb.threads/multiple-successive-infcall.exp by hand, if
you turn on 'debug infrun 1', you'll see that the debug line fixed in
this commit is printed and contains the wrong $pc value. Fixed in
this commit.
gdb/ChangeLog:
* infrun.c (do_target_wait): Change old version of $pc printed.
See email thread starting here for more details:
https://sourceware.org/ml/binutils/2018-06/msg00036.html
PR 22983
* testsuite/ld-plugin/lto.exp: Use individual tests to check for
the presence of each expected symbol.
* testsuite/ld-plugin/pr22983.1.d: New file.
* testsuite/ld-plugin/pr22983.2.d: New file.
* testsuite/ld-plugin/pr22983.3.d: New file.
* testsuite/ld-plugin/pr22983.4.d: New file.
Since we now have two index formats, DWARF5/debug_names and gdb_index, I
wanted to rename some functions to make it clear that they deal with the
gdb_index format specifically.
gdb/ChangeLog:
* dwarf2read.c (read_index_from_section): Rename to...
(read_gdb_index_from_section): ... this, update all callers.
(dwarf2_read_index): Rename to...
(dwarf2_read_gdb_index): ... this, update all callers.
