Age | Commit message (Collapse) | Author | Files | Lines |
|
This commit is the result of the following actions:
- Running gdb/copyright.py to update all of the copyright headers to
include 2024,
- Manually updating a few files the copyright.py script told me to
update, these files had copyright headers embedded within the
file,
- Regenerating gdbsupport/Makefile.in to refresh it's copyright
date,
- Using grep to find other files that still mentioned 2023. If
these files were updated last year from 2022 to 2023 then I've
updated them this year to 2024.
I'm sure I've probably missed some dates. Feel free to fix them up as
you spot them.
|
|
Normally, if the last resumed thread on the target exits, the server
sends a no-resumed event to GDB. If however, GDB enables the
GDB_THREAD_OPTION_EXIT option on a thread, and, that thread exits, the
server sends a thread exit event for that thread instead.
In all-stop RSP mode, since events can only be forwarded to GDB one at
a time, and the whole target stops whenever an event is reported, GDB
resumes the target again after getting a THREAD_EXITED event, and then
the server finally reports back a no-resumed event if/when
appropriate.
For non-stop RSP though, events are asynchronous, and if the server
sends a thread-exit event for the last resumed thread, the no-resumed
event is never sent. This patch makes sure that in non-stop mode, the
server queues a no-resumed event after the thread-exit event if it was
the last resumed thread that exited.
Without this, we'd see failures in step-over-thread-exit testcases
added later in the series, like so:
continue
Continuing.
- No unwaited-for children left.
- (gdb) PASS: gdb.threads/step-over-thread-exit.exp: displaced-stepping=off: non-stop=on: target-non-stop=on: schedlock=off: ns_stop_all=1: continue stops when thread exits
+ FAIL: gdb.threads/step-over-thread-exit.exp: displaced-stepping=off: non-stop=on: target-non-stop=on: schedlock=off: ns_stop_all=1: continue stops when thread exits (timeout)
(and other similar ones)
Reviewed-By: Andrew Burgess <aburgess@redhat.com>
Change-Id: I927d78b30f88236dbd5634b051a716f72420e7c7
|
|
This commit extends the logic added by these two commits from a while
ago:
#1 7b961964f866 (gdbserver: hide fork child threads from GDB),
#2 df5ad102009c (gdb, gdbserver: detach fork child when detaching from fork parent)
... to handle thread clone events, which are very similar to (v)fork
events.
For #1, we want to hide clone children as well, so just update the
comments.
For #2, unlike (v)fork children, pending clone children aren't full
processes, they're just threads, so don't detach them in
handle_detach. linux-low.cc will take care of detaching them along
with all other threads of the process, there's nothing special that
needs to be done.
Reviewed-By: Andrew Burgess <aburgess@redhat.com>
Change-Id: I7f5901d07efda576a2522d03e183994e071b8ffc
|
|
A previous patch taught GDB about a new TARGET_WAITKIND_THREAD_CLONED
event kind, and made the Linux target report clone events.
A following patch will teach Linux GDBserver to do the same thing.
However, for remote debugging, it wouldn't be ideal for GDBserver to
report every clone event to GDB, when GDB only cares about such events
in some specific situations. Reporting clone events all the time
would be potentially chatty. We don't enable thread create/exit
events all the time for the same reason. Instead we have the
QThreadEvents packet. QThreadEvents is target-wide, though.
This patch makes GDB instead explicitly request that the target
reports clone events or not, on a per-thread basis.
In order to be able to do that with GDBserver, we need a new remote
protocol feature. Since a following patch will want to enable thread
exit events on per-thread basis too, the packet introduced here is
more generic than just for clone events. It lets you enable/disable a
set of options at once, modelled on Linux ptrace's PTRACE_SETOPTIONS.
IOW, this commit introduces a new QThreadOptions packet, that lets you
specify a set of per-thread event options you want to enable. The
packet accepts a list of options/thread-id pairs, similarly to vCont,
processed left to right, with the options field being a number
interpreted as a bit mask of options. The only option defined in this
commit is GDB_THREAD_OPTION_CLONE (0x1), which ask the remote target
to report clone events. Another patch later in the series will
introduce another option.
For example, this packet sets option "1" (clone events) on thread
p1000.2345:
QThreadOptions;1:p1000.2345
and this clears options for all threads of process 1000, and then sets
option "1" (clone events) on thread p1000.2345:
QThreadOptions;0:p1000.-1;1:p1000.2345
This clears options of all threads of all processes:
QThreadOptions;0
The target reports the set of supported options by including
"QThreadOptions=<supported options>" in its qSupported response.
infrun is then tweaked to enable GDB_THREAD_OPTION_CLONE when stepping
over a breakpoint.
Unlike PTRACE_SETOPTIONS, fork/vfork/clone children do NOT inherit
their parent's thread options. This is so that GDB can send e.g.,
"QThreadOptions;0;1:TID" without worrying about threads it doesn't
know about yet.
Documentation for this new remote protocol feature is included in a
documentation patch later in the series.
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=19675
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=27830
Reviewed-By: Andrew Burgess <aburgess@redhat.com>
Change-Id: Ie41e5093b2573f14cf6ac41b0b5804eba75be37e
|
|
I noticed a comment by an include and remembered that I think these
don't really provide much value -- sometimes they are just editorial,
and sometimes they are obsolete. I think it's better to just remove
them. Tested by rebuilding.
Approved-By: Andrew Burgess <aburgess@redhat.com>
|
|
This changes handle_qxfer_btrace and handle_qxfer_btrace_conf, in
gdbserver, to use std::string rather than struct buffer.
|
|
This patch doesn't change gdbserver behaviour, but after later changes are
made it avoids a null pointer dereference when HWCAP needs to be obtained
for a specific process while current_thread is nullptr.
Fixing linux_read_auxv, linux_get_hwcap and linux_get_hwcap2 to take a PID
parameter seems more correct than setting current_thread in one particular
code path.
Changes are propagated to allow passing the new parameter through the call
chain.
Approved-By: Simon Marchi <simon.marchi@efficios.com>
|
|
Just adding some comments to the gdbserver read_inferior_memory
function. No actual code changes.
|
|
This commit is the result of running the gdb/copyright.py script,
which automated the update of the copyright year range for all
source files managed by the GDB project to be updated to include
year 2023.
|
|
Gdbserver unconditionally reports support for btrace packets. Do not
report the support, if the underlying target does not say it supports
it. Otherwise GDB would query the server with btrace-related packets
unnecessarily.
|
|
The recent commit 421490af33bf ("gdbserver/linux: Access memory even
if threads are running") caused a regression in
gdb.threads/access-mem-running-thread-exit.exp with gdbserver, which I
somehow missed. Like so:
(gdb) print global_var
Cannot access memory at address 0x555555558010
(gdb) FAIL: gdb.threads/access-mem-running-thread-exit.exp: non-stop: access mem (print global_var after writing, inf=2, iter=1)
The problem starts with GDB telling GDBserver to select a thread, via
the Hg packet, which GDBserver complies with, then that thread exits,
and GDB, without knowing the thread is gone, tries to write to memory,
through the context of the previously selected Hg thread.
GDBserver's GDB-facing memory access routines, gdb_read_memory and
gdb_write_memory, call set_desired_thread to make GDBserver re-select
the thread that GDB has selected with the Hg packet. Since the thread
is gone, set_desired_thread returns false, and the memory access
fails.
Now, to access memory, it doesn't really matter which thread is
selected. All we should need is the target process. Even if the
thread that GDB previously selected is gone, and GDB does not yet know
about that exit, it shouldn't matter, GDBserver should still know
which process that thread belonged to.
Fix this by making GDBserver track the current process separately,
like GDB also does. Add a new set_desired_process routine that is
similar to set_desired_thread, but just sets the current process,
leaving the current thread as NULL. Use it in the GDB-facing memory
read and write routines, to avoid failing if the selected thread is
gone, but the process is still around.
Change-Id: I4ff97cb6f42558efbed224b30d5c71f6112d44cd
|
|
Given:
- The prepare_to_access_memory machinery was added for non-stop mode.
- Only Linux supports non-stop.
- Linux no longer needs the prepare_to_access_memory machinery. In
fact, after the previous patch,
linux_process_target::prepare_to_access_memory became a nop.
Thus, prepare_to_access_memory can go away, simplifying core GDBserver
code.
Change-Id: I93ac8bfe66bd61c3d1c4a0e7d419335163120ecf
|
|
The enable_btrace target method takes a ptid_t to identify the thread on
which tracing shall be enabled.
Change this to thread_info * to avoid translating back and forth between
the two. This will be used in a subsequent patch.
|
|
This commit brings all the changes made by running gdb/copyright.py
as per GDB's Start of New Year Procedure.
For the avoidance of doubt, all changes in this commits were
performed by the script.
|
|
While working with pending fork events, I wondered what would happen if
the user detached an inferior while a thread of that inferior had a
pending fork event. What happens with the fork child, which is
ptrace-attached by the GDB process (or by GDBserver), but not known to
the core? Sure enough, neither the core of GDB or the target detach the
child process, so GDB (or GDBserver) just stays ptrace-attached to the
process. The result is that the fork child process is stuck, while you
would expect it to be detached and run.
Make GDBserver detach of fork children it knows about. That is done in
the generic handle_detach function. Since a process_info already exists
for the child, we can simply call detach_inferior on it.
GDB-side, make the linux-nat and remote targets detach of fork children
known because of pending fork events. These pending fork events can be
stored in:
- thread_info::pending_waitstatus, if the core has consumed the event
but then saved it for later (for example, because it got the event
while stopping all threads, to present an all-stop stop on top of a
non-stop target)
- thread_info::pending_follow: if we ran to a "catch fork" and we
detach at that moment
Additionally, pending fork events can be in target-specific fields:
- For linux-nat, they can be in lwp_info::status and
lwp_info::waitstatus.
- For the remote target, they could be stored as pending stop replies,
saved in `remote_state::notif_state::pending_event`, if not
acknowledged yet, or in `remote_state::stop_reply_queue`, if
acknowledged. I followed the model of remove_new_fork_children for
this: call remote_notif_get_pending_events to process /
acknowledge any unacknowledged notification, then look through
stop_reply_queue.
Update the gdb.threads/pending-fork-event.exp test (and rename it to
gdb.threads/pending-fork-event-detach.exp) to try to detach the process
while it is stopped with a pending fork event. In order to verify that
the fork child process is correctly detached and resumes execution
outside of GDB's control, make that process create a file in the test
output directory, and make the test wait $timeout seconds for that file
to appear (it happens instantly if everything goes well).
This test catches a bug in linux-nat.c, also reported as PR 28512
("waitstatus.h:300: internal-error: gdb_signal target_waitstatus::sig()
const: Assertion `m_kind == TARGET_WAITKIND_STOPPED || m_kind ==
TARGET_WAITKIND_SIGNALLED' failed.). When detaching a thread with a
pending event, get_detach_signal unconditionally fetches the signal
stored in the waitstatus (`tp->pending_waitstatus ().sig ()`). However,
that is only valid if the pending event is of type
TARGET_WAITKIND_STOPPED, and this is now enforced using assertions (iit
would also be valid for TARGET_WAITKIND_SIGNALLED, but that would mean
the thread does not exist anymore, so we wouldn't be detaching it). Add
a condition in get_detach_signal to access the signal number only if the
wait status is of kind TARGET_WAITKIND_STOPPED, and use GDB_SIGNAL_0
instead (since the thread was not stopped with a signal to begin with).
Add another test, gdb.threads/pending-fork-event-ns.exp, specifically to
verify that we consider events in pending stop replies in the remote
target. This test has many threads constantly forking, and we detach
from the program while the program is executing. That gives us some
chance that we detach while a fork stop reply is stored in the remote
target. To verify that we correctly detach all fork children, we ask
the parent to exit by sending it a SIGUSR1 signal and have it write a
file to the filesystem before exiting. Because the parent's main thread
joins the forking threads, and the forking threads wait for their fork
children to exit, if some fork child is not detach by GDB, the parent
will not write the file, and the test will time out. If I remove the
new remote_detach_pid calls in remote.c, the test fails eventually if I
run it in a loop.
There is a known limitation: we don't remove breakpoints from the
children before detaching it. So the children, could hit a trap
instruction after being detached and crash. I know this is wrong, and
it should be fixed, but I would like to handle that later. The current
patch doesn't fix everything, but it's a step in the right direction.
Change-Id: I6d811a56f520e3cb92d5ea563ad38976f92e93dd
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=28512
|
|
This patch aims at fixing a bug where an inferior is unexpectedly
created when a fork happens at the same time as another event, and that
other event is reported to GDB first (and the fork event stays pending
in GDBserver). This happens for example when we step a thread and
another thread forks at the same time. The bug looks like (if I
reproduce the included test by hand):
(gdb) show detach-on-fork
Whether gdb will detach the child of a fork is on.
(gdb) show follow-fork-mode
Debugger response to a program call of fork or vfork is "parent".
(gdb) si
[New inferior 2]
Reading /home/simark/build/binutils-gdb/gdb/testsuite/outputs/gdb.threads/step-while-fork-in-other-thread/step-while-fork-in-other-thread from remote target...
Reading /home/simark/build/binutils-gdb/gdb/testsuite/outputs/gdb.threads/step-while-fork-in-other-thread/step-while-fork-in-other-thread from remote target...
Reading symbols from target:/home/simark/build/binutils-gdb/gdb/testsuite/outputs/gdb.threads/step-while-fork-in-other-thread/step-while-fork-in-other-thread...
[New Thread 965190.965190]
[Switching to Thread 965190.965190]
Remote 'g' packet reply is too long (expected 560 bytes, got 816 bytes): ... <long series of bytes>
The sequence of events leading to the problem is:
- We are using the all-stop user-visible mode as well as the
synchronous / all-stop variant of the remote protocol
- We have two threads, thread A that we single-step and thread B that
calls fork at the same time
- GDBserver's linux_process_target::wait pulls the "single step
complete SIGTRAP" and the "fork" events from the kernel. It
arbitrarily choses one event to report, it happens to be the
single-step SIGTRAP. The fork stays pending in the thread_info.
- GDBserver send that SIGTRAP as a stop reply to GDB
- While in stop_all_threads, GDB calls update_thread_list, which ends
up querying the remote thread list using qXfer:threads:read.
- In the reply, GDBserver includes the fork child created as a result
of thread B's fork.
- GDB-side, the remote target sees the new PID, calls
remote_notice_new_inferior, which ends up unexpectedly creating a new
inferior, and things go downhill from there.
The problem here is that as long as GDB did not process the fork event,
it should pretend the fork child does not exist. Ultimately, this event
will be reported, we'll go through follow_fork, and that process will be
detached.
The remote target (GDB-side), has some code to remove from the reported
thread list the threads that are the result of forks not processed by
GDB yet. But that only works for fork events that have made their way
to the remote target (GDB-side), but haven't been consumed by the core
yet, so are still lingering as pending stop replies in the remote target
(see remove_new_fork_children in remote.c). But in our case, the fork
event hasn't made its way to the GDB-side remote target. We need to
implement the same kind of logic GDBserver-side: if there exists a
thread / inferior that is the result of a fork event GDBserver hasn't
reported yet, it should exclude that thread / inferior from the reported
thread list.
This was actually discussed a while ago, but not implemented AFAIK:
https://pi.simark.ca/gdb-patches/1ad9f5a8-d00e-9a26-b0c9-3f4066af5142@redhat.com/#t
https://sourceware.org/pipermail/gdb-patches/2016-June/133906.html
Implementation details-wise, the fix for this is all in GDBserver. The
Linux layer of GDBserver already tracks unreported fork parent / child
relationships using the lwp_info::fork_relative, in order to avoid
wildcard actions resuming fork childs unknown to GDB. This information
needs to be made available to the handle_qxfer_threads_worker function,
so it can filter the reported threads. Add a new thread_pending_parent
target function that allows the Linux target to return the parent of an
eventual fork child.
Testing-wise, the test replicates pretty-much the sequence of events
shown above. The setup of the test makes it such that the main thread
is about to fork. We stepi the other thread, so that the step completes
very quickly, in a single event. Meanwhile, the main thread is resumed,
so very likely has time to call fork. This means that the bug may not
reproduce every time (if the main thread does not have time to call
fork), but it will reproduce more often than not. The test fails
without the fix applied on the native-gdbserver and
native-extended-gdbserver boards.
At some point I suspected that which thread called fork and which thread
did the step influenced the order in which the events were reported, and
therefore the reproducibility of the bug. So I made the test try both
combinations: main thread forks while other thread steps, and vice
versa. I'm not sure this is still necessary, but I left it there
anyway. It doesn't hurt to test a few more combinations.
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=28288
Change-Id: I2158d5732fc7d7ca06b0eb01f88cf27bf527b990
|
|
I wanted to write a warning that included two target_pid_to_str calls,
like this:
warning (_("Blabla %s, blabla %s"),
target_pid_to_str (ptid1),
target_pid_to_str (ptid2));
This doesn't work, because target_pid_to_str stores its result in a
static buffer, so my message would show twice the same ptid. Change
target_pid_to_str to return an std::string to avoid this. I don't think
we save much by using a static buffer, but it is more error-prone.
Change-Id: Ie3f649627686b84930529cc5c7c691ccf5d36dc2
|
|
Now that the WinCE port is gone, all ports map host I/O errors from
errno, so this abstraction is no longer necessary.
Basically undoes:
https://sourceware.org/pipermail/gdb-patches/2008-January/055511.html
https://sourceware.org/pipermail/gdb-patches/attachments/20080131/f44e7012/attachment.bin
gdbserver/ChangeLog:
* Makefile.in (SFILES): Remove hostio-errno.cc.
* configure: Regenerate.
* configure.ac (GDBSERVER_DEPFILES): No longer add
$srv_hostio_err_objs.
* configure.srv (srv_hostio_err_objs): Delete.
* hostio-errno.cc: Delete.
* hostio.cc (hostio_error): Inline hostio_last_error_from_errno
here.
* hostio.h (hostio_last_error_from_errno): Delete.
* target.cc (process_stratum_target::hostio_last_error): Delete.
* target.h (class process_stratum_target) <hostio_last_error>:
Delete.
|
|
gdbserver/ChangeLog:
2021-04-12 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
* target.h (class process_stratum_target) <pid_to_exec_file>:
Constify the return type. Update the definition/references below.
* target.cc (process_stratum_target::pid_to_exec_file)
* linux-low.h (class linux_process_target) <pid_to_exec_file>
* linux-low.cc (linux_process_target::pid_to_exec_file)
* netbsd-low.h (class netbsd_process_target) <pid_to_exec_file>
* netbsd-low.cc (netbsd_process_target::pid_to_exec_file)
* server.cc (handle_qxfer_exec_file)
|
|
This patch adds the generic remote bits to gdbserver so it can check for memory
tagging support and handle fetch tags and store tags requests.
gdbserver/ChangeLog:
2021-03-24 Luis Machado <luis.machado@linaro.org>
* remote-utils.cc (decode_m_packet_params): Renamed from ...
(decode_m_packet): ... this, which now calls decode_m_packet_params.
Make char * param/return const char *.
(decode_M_packet): Use decode_m_packet_params and make char * param
const char *.
* remote-utils.h (decode_m_packet_params): New prototype.
(decode_m_packet): Constify char pointers.
(decode_M_packet): Likewise.
* server.cc (create_fetch_memtags_reply)
(parse_store_memtags_request): New
functions.
(handle_general_set): Handle the QMemTags packet.
(parse_fetch_memtags_request): New function.
(handle_query): Handle the qMemTags packet and advertise memory
tagging support.
(captured_main): Initialize memory tagging flag.
* server.h (struct client_state): Initialize memory tagging flag.
* target.cc (process_stratum_target::supports_memory_tagging)
(process_stratum_target::fetch_memtags)
(process_stratum_target::store_memtags): New methods.
* target.h: Include gdbsupport/byte-vector.h.
(class process_stratum_target) <supports_memory_tagging>
<fetch_memtags, store_memtags>: New class virtual methods.
(target_supports_memory_tagging): Define.
|
|
This commits the result of running gdb/copyright.py as per our Start
of New Year procedure...
gdb/ChangeLog
Update copyright year range in copyright header of all GDB files.
|
|
This changes TARGET_WNOHANG to be a member of an enum, rather than a
define, and also adds a DEF_ENUM_FLAGS_TYPE for this type. Then, it
changes target_wait and the various target wait methods to use this
type rather than "int".
This didn't catch any bugs, but it seems like a decent cleanup
nevertheless.
I did not change deprecated_target_wait_hook, since that's only used
out-of-tree (by Insight), and there didn't seem to be a need.
I can't build some of these targets, so I modified them on a
best-effort basis. I don't think this patch should go in before the
release branch is made.
gdb/ChangeLog
2020-09-18 Tom Tromey <tromey@adacore.com>
* windows-nat.c (struct windows_nat_target) <wait>: Update.
(windows_nat_target::wait): Update.
* target/wait.h (enum target_wait_flag): New. Use
DEF_ENUM_FLAGS_TYPE.
* target/target.h (target_wait): Change type of options.
* target.h (target_options_to_string, default_target_wait):
Update.
(struct target_ops) <wait>: Change type of options.
* target.c (target_wait, default_target_wait, do_option): Change
type of "options".
(target_options_to_string): Likewise.
* target-delegates.c: Rebuild.
* target-debug.h (target_debug_print_target_wait_flags): Rename
from target_debug_print_options.
* sol-thread.c (class sol_thread_target) <wait>: Update.
(sol_thread_target::wait): Update.
* rs6000-nat.c (class rs6000_nat_target) <wait>: Update.
(rs6000_nat_target::wait): Update.
* remote.c (class remote_target) <wait, wait_ns, wait_as>:
Update.
(remote_target::wait_ns, remote_target::wait_as): Change type of
"options".
(remote_target::wait): Update.
* remote-sim.c (struct gdbsim_target) <wait>: Update.
(gdbsim_target::wait): Update.
* record-full.c (class record_full_base_target) <wait>: Update.
(record_full_wait_1): Change type of "options".
(record_full_base_target::wait): Update.
* record-btrace.c (class record_btrace_target) <wait>: Update.
(record_btrace_target::wait): Update.
* ravenscar-thread.c (struct ravenscar_thread_target) <wait>:
Update.
(ravenscar_thread_target::wait): Update.
* procfs.c (class procfs_target) <wait>: Update.
(procfs_target::wait): Update.
* obsd-nat.h (class obsd_nat_target) <wait>: Update.
* obsd-nat.c (obsd_nat_target::wait): Update.
* nto-procfs.c (struct nto_procfs_target) <wait>: Update.
(nto_procfs_target::wait): Update.
* nbsd-nat.h (struct nbsd_nat_target) <wait>: Update.
* nbsd-nat.c (nbsd_wait): Change type of "options".
(nbsd_nat_target::wait): Update.
* linux-thread-db.c (class thread_db_target) <wait>: Update.
(thread_db_target::wait): Update.
* linux-nat.h (class linux_nat_target) <wait>: Update.
* linux-nat.c (linux_nat_target::wait): Update.
(linux_nat_wait_1): Update.
* infrun.c (do_target_wait_1, do_target_wait): Change type of
"options".
* inf-ptrace.h (struct inf_ptrace_target) <wait>: Update.
* inf-ptrace.c (inf_ptrace_target::wait): Update.
* go32-nat.c (struct go32_nat_target) <wait>: Update.
(go32_nat_target::wait): Update.
* gnu-nat.h (struct gnu_nat_target) <wait>: Update.
* gnu-nat.c (gnu_nat_target::wait): Update.
* fbsd-nat.h (class fbsd_nat_target) <wait>: Update.
* fbsd-nat.c (fbsd_nat_target::wait): Update.
* darwin-nat.h (class darwin_nat_target) <wait>: Update.
* darwin-nat.c (darwin_nat_target::wait): Update.
* bsd-uthread.c (struct bsd_uthread_target) <wait>: Update.
(bsd_uthread_target::wait): Update.
* aix-thread.c (class aix_thread_target) <wait>: Update.
(aix_thread_target::wait): Update.
gdbserver/ChangeLog
2020-09-18 Tom Tromey <tromey@adacore.com>
* netbsd-low.h (class netbsd_process_target) <wait>: Update.
* netbsd-low.cc (netbsd_waitpid, netbsd_wait)
(netbsd_process_target::wait): Change type of target_options.
* win32-low.h (class win32_process_target) <wait>: Update.
* win32-low.cc (win32_process_target::wait): Update.
* target.h (class process_stratum_target) <wait>: Update.
(mywait): Update.
* target.cc (mywait, target_wait): Change type of "options".
* linux-low.h (class linux_process_target) <wait, wait_1>:
Update.
* linux-low.cc (linux_process_target::wait)
(linux_process_target::wait_1): Update.
|
|
When building gdbserver with AddressSanitizer, I get this annoying
little leak when gdbserver exits:
==307817==ERROR: LeakSanitizer: detected memory leaks
Direct leak of 14 byte(s) in 1 object(s) allocated from:
#0 0x7f7fd4256459 in __interceptor_malloc /build/gcc/src/gcc/libsanitizer/asan/asan_malloc_linux.cpp:145
#1 0x563bef981b80 in xmalloc /home/simark/src/binutils-gdb/gdbserver/../gdb/alloc.c:60
#2 0x563befb53301 in xstrdup /home/simark/src/binutils-gdb/libiberty/xstrdup.c:34
#3 0x563bef9d742b in handle_query /home/simark/src/binutils-gdb/gdbserver/server.cc:2286
#4 0x563bef9ed0b7 in process_serial_event /home/simark/src/binutils-gdb/gdbserver/server.cc:4061
#5 0x563bef9f1d9e in handle_serial_event(int, void*) /home/simark/src/binutils-gdb/gdbserver/server.cc:4402
#6 0x563befb0ec65 in handle_file_event /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:548
#7 0x563befb0f49f in gdb_wait_for_event /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:673
#8 0x563befb0d4a1 in gdb_do_one_event() /home/simark/src/binutils-gdb/gdbsupport/event-loop.cc:215
#9 0x563bef9e721a in start_event_loop /home/simark/src/binutils-gdb/gdbserver/server.cc:3484
#10 0x563bef9eb90a in captured_main /home/simark/src/binutils-gdb/gdbserver/server.cc:3875
#11 0x563bef9ec2c7 in main /home/simark/src/binutils-gdb/gdbserver/server.cc:3961
#12 0x7f7fd3330001 in __libc_start_main (/usr/lib/libc.so.6+0x27001)
SUMMARY: AddressSanitizer: 14 byte(s) leaked in 1 allocation(s).
This is due to the handling of unknown qsupported features in
handle_query. The `qsupported` vector is built, containing all the
feature names received from GDB. As we iterate on them, when we
encounter unknown ones, we move them at the beginning of the vector, in
preparation of passing this vector of unknown features down to the
target (which may know about them).
When moving these unknown features to other slots in the vector, we
overwrite other pointers without freeing them, which therefore leak.
An easy fix would be to add a `free` when doing the move. However, I
think this is a good opportunity to sprinkle a bit of automatic memory
management in this code.
So, use a vector of std::string which owns all the entries. And use a
separate vector (that doesn't own the entries) for the unknown ones,
which is then passed to target_process_qsupported.
Given that the `c_str` method of std::string returns a `const char *`,
it follows that process_stratum_target::process_qsupported must accept a
`const char **` instead of a `char **`. And while at it, change the
pointer + size paramters to use an array_view instead.
gdbserver/ChangeLog:
* server.cc (handle_query): Use std::vector of
std::string for `qsupported` vector. Use separate
vector for unknowns.
* target.h (class process_stratum_target) <process_qsupported>:
Change parameters to array_view of const char *.
(target_process_qsupported): Remove `count` parameter.
* target.cc (process_stratum_target::process_qsupported): Change
parameters to array_view of const char *.
* linux-x86-low.cc (class x86_target) <process_qsupported>:
Likewise.
Change-Id: I97f133825faa6d7abbf83a58504eb0ba77462812
|
|
Now that 'process_stratum_target' has a single field left, namely 'pt'
of type 'process_target', and that all the requests to a
'process_stratum_target' are forwarded to 'pt', meld the
'process_target' class into 'process_stratum_target'.
This essentially means
1. All the references of the form 'the_target->pt' become 'the_target'.
2. All the uses of the name 'process_target' become
'process_stratum_target'.
3. The platform-specific target op vectors (e.g. linux_target_ops) are
removed and instances of their "process target" classes are used
instead.
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
* target.h (struct process_stratum_target): Remove.
(class process_target): Rename to ...
(class process_stratum_target): ... this.
* linux-low.h (class linux_process_target): Derive from
'process_stratum_target'.
* linux-low.cc (linux_target_ops): Remove.
(initialize_low): Set the_target to the singleton instance of
linux_process_target.
* lynx-low.h (class lynx_process_target): Derive from
'process_stratum_target'.
* lynx-low.cc (lynx_target_ops): Remove.
(initialize_low): Set the_target to the singleton instance of
lynx_process_target.
* nto-low.h (class nto_process_target): Derive from
'process_stratum_target'.
* nto-low.cc (nto_target_ops): Remove.
(initialize_low): Set the_target to the singleton instance of
nto_process_target.
* win32-low.h (class win32_process_target): Derive from
'process_stratum_target'.
* win32-low.cc (win32_target_ops): Remove.
(initialize_low): Set the_target to the singleton instance of
win32_process_target.
Replace 'the_target->pt' with 'the_target' in the uses below.
* hostio.cc (hostio_error)
(handle_setfs)
(handle_open)
(handle_unlink)
(handle_readlink)
* linux-aarch32-low.cc (arm_breakpoint_at)
* linux-aarch64-low.cc (aarch64_breakpoint_at)
* linux-arm-low.cc (arm_sigreturn_next_pc)
(arm_get_hwcap)
(arm_get_syscall_trapinfo)
* linux-cris-low.cc (cris_breakpoint_at)
* linux-crisv32-low.cc (cris_breakpoint_at)
* linux-low.cc (handle_extended_wait)
(linux_wait_1)
(linux_read_memory)
(linux_process_target::breakpoint_kind_from_pc)
(linux_get_auxv)
* linux-m32r-low.cc (m32r_breakpoint_at)
* linux-mips-low.cc (mips_breakpoint_at)
* linux-nios2-low.cc (nios2_breakpoint_at)
* linux-ppc-low.cc (ppc_breakpoint_at)
* linux-s390-low.cc (s390_get_hwcap)
* linux-sh-low.cc (sh_breakpoint_at)
* linux-sparc-low.cc (sparc_fill_gregset_to_stack)
(sparc_store_gregset_from_stack)
(sparc_breakpoint_at)
* linux-tic6x-low.cc (tic6x_breakpoint_at)
* linux-tile-low.cc (tile_breakpoint_at)
* linux-x86-low.cc (x86_breakpoint_at)
* linux-xtensa-low.cc (xtensa_breakpoint_at)
* mem-break.cc (bp_size)
(bp_opcode)
(insert_memory_breakpoint)
(set_raw_breakpoint_at)
(delete_raw_breakpoint)
(z_type_supported)
(uninsert_raw_breakpoint)
(reinsert_raw_breakpoint)
(validate_inserted_breakpoint)
* regcache.cc (regcache_read_pc)
(regcache_write_pc)
* remote-utils.cc (putpkt_binary_1)
(input_interrupt)
(getpkt)
(prepare_resume_reply)
* server.cc (handle_general_set)
(handle_detach)
(handle_qxfer_auxv)
(handle_qxfer_exec_file)
(handle_qxfer_libraries_svr4)
(handle_qxfer_osdata)
(handle_qxfer_siginfo)
(handle_qxfer_fdpic)
(handle_query)
(resume)
(handle_v_requests)
(queue_stop_reply_callback)
(captured_main)
* target.cc (prepare_to_access_memory)
(done_accessing_memory)
(read_inferior_memory)
(target_write_memory)
(target_stop_and_wait)
(target_wait)
(target_mourn_inferior)
(target_continue_no_signal)
(target_continue)
(target_supports_multi_process)
(kill_inferior)
* target.h
(target_create_inferior)
(target_post_create_inferior)
(myattach)
(target_supports_fork_events)
(target_supports_vfork_events)
(target_supports_exec_events)
(target_handle_new_gdb_connection)
(detach_inferior)
(mythread_alive)
(fetch_inferior_registers)
(store_inferior_registers)
(join_inferior)
(target_supports_non_stop)
(target_async)
(target_process_qsupported)
(target_supports_catch_syscall)
(target_get_ipa_tdesc_idx)
(target_supports_tracepoints)
(target_supports_fast_tracepoints)
(target_get_min_fast_tracepoint_insn_len)
(target_thread_stopped)
(target_pause_all)
(target_unpause_all)
(target_stabilize_threads)
(target_install_fast_tracepoint_jump_pad)
(target_emit_ops)
(target_supports_disable_randomization)
(target_supports_agent)
(target_enable_btrace)
(target_disable_btrace)
(target_read_btrace)
(target_read_btrace_conf)
(target_supports_range_stepping)
(target_supports_stopped_by_sw_breakpoint)
(target_stopped_by_sw_breakpoint)
(target_supports_stopped_by_hw_breakpoint)
(target_supports_hardware_single_step)
(target_stopped_by_hw_breakpoint)
(target_breakpoint_kind_from_pc)
(target_breakpoint_kind_from_current_state)
(target_supports_software_single_step)
(target_core_of_thread)
(target_thread_name)
(target_thread_handle)
* win32-low.cc (do_initial_child_stuff)
Rename target op default definitions listed below.
* target.cc (process_target::post_create_inferior): Rename as ...
(process_stratum_target::post_create_inferior): ... this.
(process_target::prepare_to_access_memory): Rename as ...
(process_stratum_target::prepare_to_access_memory): ... this.
(process_target::done_accessing_memory): Rename as ...
(process_stratum_target::done_accessing_memory): ... this.
(process_target::look_up_symbols): Rename as ...
(process_stratum_target::look_up_symbols): ... this.
(process_target::supports_read_auxv): Rename as ...
(process_stratum_target::supports_read_auxv): ... this.
(process_target::read_auxv): Rename as ...
(process_stratum_target::read_auxv): ... this.
(process_target::supports_z_point_type): Rename as ...
(process_stratum_target::supports_z_point_type): ... this.
(process_target::insert_point): Rename as ...
(process_stratum_target::insert_point): ... this.
(process_target::remove_point): Rename as ...
(process_stratum_target::remove_point): ... this.
(process_target::stopped_by_sw_breakpoint): Rename as ...
(process_stratum_target::stopped_by_sw_breakpoint): ... this.
(process_target::supports_stopped_by_sw_breakpoint): Rename as ...
(process_stratum_target::supports_stopped_by_sw_breakpoint): ... this.
(process_target::stopped_by_hw_breakpoint): Rename as ...
(process_stratum_target::stopped_by_hw_breakpoint): ... this.
(process_target::supports_stopped_by_hw_breakpoint): Rename as ...
(process_stratum_target::supports_stopped_by_hw_breakpoint): ... this.
(process_target::supports_hardware_single_step): Rename as ...
(process_stratum_target::supports_hardware_single_step): ... this.
(process_target::stopped_by_watchpoint): Rename as ...
(process_stratum_target::stopped_by_watchpoint): ... this.
(process_target::stopped_data_address): Rename as ...
(process_stratum_target::stopped_data_address): ... this.
(process_target::supports_read_offsets): Rename as ...
(process_stratum_target::supports_read_offsets): ... this.
(process_target::read_offsets): Rename as ...
(process_stratum_target::read_offsets): ... this.
(process_target::supports_get_tls_address): Rename as ...
(process_stratum_target::supports_get_tls_address): ... this.
(process_target::get_tls_address): Rename as ...
(process_stratum_target::get_tls_address): ... this.
(process_target::hostio_last_error): Rename as ...
(process_stratum_target::hostio_last_error): ... this.
(process_target::supports_qxfer_osdata): Rename as ...
(process_stratum_target::supports_qxfer_osdata): ... this.
(process_target::qxfer_osdata): Rename as ...
(process_stratum_target::qxfer_osdata): ... this.
(process_target::supports_qxfer_siginfo): Rename as ...
(process_stratum_target::supports_qxfer_siginfo): ... this.
(process_target::qxfer_siginfo): Rename as ...
(process_stratum_target::qxfer_siginfo): ... this.
(process_target::supports_non_stop): Rename as ...
(process_stratum_target::supports_non_stop): ... this.
(process_target::async): Rename as ...
(process_stratum_target::async): ... this.
(process_target::start_non_stop): Rename as ...
(process_stratum_target::start_non_stop): ... this.
(process_target::supports_multi_process): Rename as ...
(process_stratum_target::supports_multi_process): ... this.
(process_target::supports_fork_events): Rename as ...
(process_stratum_target::supports_fork_events): ... this.
(process_target::supports_vfork_events): Rename as ...
(process_stratum_target::supports_vfork_events): ... this.
(process_target::supports_exec_events): Rename as ...
(process_stratum_target::supports_exec_events): ... this.
(process_target::handle_new_gdb_connection): Rename as ...
(process_stratum_target::handle_new_gdb_connection): ... this.
(process_target::handle_monitor_command): Rename as ...
(process_stratum_target::handle_monitor_command): ... this.
(process_target::core_of_thread): Rename as ...
(process_stratum_target::core_of_thread): ... this.
(process_target::supports_read_loadmap): Rename as ...
(process_stratum_target::supports_read_loadmap): ... this.
(process_target::read_loadmap): Rename as ...
(process_stratum_target::read_loadmap): ... this.
(process_target::process_qsupported): Rename as ...
(process_stratum_target::process_qsupported): ... this.
(process_target::supports_tracepoints): Rename as ...
(process_stratum_target::supports_tracepoints): ... this.
(process_target::read_pc): Rename as ...
(process_stratum_target::read_pc): ... this.
(process_target::write_pc): Rename as ...
(process_stratum_target::write_pc): ... this.
(process_target::supports_thread_stopped): Rename as ...
(process_stratum_target::supports_thread_stopped): ... this.
(process_target::thread_stopped): Rename as ...
(process_stratum_target::thread_stopped): ... this.
(process_target::supports_get_tib_address): Rename as ...
(process_stratum_target::supports_get_tib_address): ... this.
(process_target::get_tib_address): Rename as ...
(process_stratum_target::get_tib_address): ... this.
(process_target::pause_all): Rename as ...
(process_stratum_target::pause_all): ... this.
(process_target::unpause_all): Rename as ...
(process_stratum_target::unpause_all): ... this.
(process_target::stabilize_threads): Rename as ...
(process_stratum_target::stabilize_threads): ... this.
(process_target::supports_fast_tracepoints): Rename as ...
(process_stratum_target::supports_fast_tracepoints): ... this.
(process_target::get_min_fast_tracepoint_insn_len): Rename as ...
(process_stratum_target::get_min_fast_tracepoint_insn_len): ... this.
(process_target::emit_ops): Rename as ...
(process_stratum_target::emit_ops): ... this.
(process_target::supports_disable_randomization): Rename as ...
(process_stratum_target::supports_disable_randomization): ... this.
(process_target::supports_qxfer_libraries_svr4): Rename as ...
(process_stratum_target::supports_qxfer_libraries_svr4): ... this.
(process_target::qxfer_libraries_svr4): Rename as ...
(process_stratum_target::qxfer_libraries_svr4): ... this.
(process_target::supports_agent): Rename as ...
(process_stratum_target::supports_agent): ... this.
(process_target::enable_btrace): Rename as ...
(process_stratum_target::enable_btrace): ... this.
(process_target::disable_btrace): Rename as ...
(process_stratum_target::disable_btrace): ... this.
(process_target::read_btrace): Rename as ...
(process_stratum_target::read_btrace): ... this.
(process_target::read_btrace_conf): Rename as ...
(process_stratum_target::read_btrace_conf): ... this.
(process_target::supports_range_stepping): Rename as ...
(process_stratum_target::supports_range_stepping): ... this.
(process_target::supports_pid_to_exec_file): Rename as ...
(process_stratum_target::supports_pid_to_exec_file): ... this.
(process_target::pid_to_exec_file): Rename as ...
(process_stratum_target::pid_to_exec_file): ... this.
(process_target::supports_multifs): Rename as ...
(process_stratum_target::supports_multifs): ... this.
(process_target::multifs_open): Rename as ...
(process_stratum_target::multifs_open): ... this.
(process_target::multifs_unlink): Rename as ...
(process_stratum_target::multifs_unlink): ... this.
(process_target::multifs_readlink): Rename as ...
(process_stratum_target::multifs_readlink): ... this.
(process_target::breakpoint_kind_from_pc): Rename as ...
(process_stratum_target::breakpoint_kind_from_pc): ... this.
(process_target::breakpoint_kind_from_current_state): Rename as ...
(process_stratum_target::breakpoint_kind_from_current_state): ... this.
(process_target::thread_name): Rename as ...
(process_stratum_target::thread_name): ... this.
(process_target::thread_handle): Rename as ...
(process_stratum_target::thread_handle): ... this.
(process_target::supports_software_single_step): Rename as ...
(process_stratum_target::supports_software_single_step): ... this.
(process_target::supports_catch_syscall): Rename as ...
(process_stratum_target::supports_catch_syscall): ... this.
(process_target::get_ipa_tdesc_idx): Rename as ...
(process_stratum_target::get_ipa_tdesc_idx): ... this.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's get_ipa_tdesc_idx op into a method
of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_get_ipa_tdesc_idx): Update the macro.
* target.cc (process_target::get_ipa_tdesc_idx): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_get_ipa_tdesc_idx): Turn into ...
(linux_process_target::get_ipa_tdesc_idx): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_catch_syscall op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_catch_syscall): Update the macro.
* target.cc (process_target::supports_catch_syscall): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_catch_syscall): Turn into ...
(linux_process_target::supports_catch_syscall): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_software_single_step op
into a method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_software_single_step): Update the macro.
* target.cc (process_target::supports_software_single_step): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_software_single_step): Turn into ...
(linux_process_target::supports_software_single_step): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's thread_name and thread_handle ops
into methods of process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops.
(target_thread_name): Update the macro.
(target_thread_handle): Update the macro.
* target.cc (process_target::thread_name): Define.
(process_target::thread_handle): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::thread_name): Define.
(linux_process_target::thread_handle): Define.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's breakpoint_kind_from_pc,
sw_breakpoint_from_kind, and breakpoint_kind_from_current_state
ops into methods of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_breakpoint_kind_from_pc): Update the macro.
(target_breakpoint_kind_from_current_state): Update the macro.
(default_breakpoint_kind_from_pc): Remove declaration.
* target.cc (default_breakpoint_kind_from_pc): Turn into ...
(process_target::breakpoint_kind_from_pc): ... this.
(process_target::breakpoint_kind_from_current_state): Define.
Update the derived classes and callers below.
* mem-break.cc (bp_size): Update.
(bp_opcode): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_wait_1): Update.
(linux_breakpoint_kind_from_pc): Turn into ...
(linux_process_target::breakpoint_kind_from_pc): ... this.
(linux_sw_breakpoint_from_kind): Turn into ...
(linux_process_target::sw_breakpoint_from_kind): ... this.
(linux_breakpoint_kind_from_current_state): Turn into ...
(linux_process_target::breakpoint_kind_from_current_state): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
(lynx_process_target::sw_breakpoint_from_kind): Define.
* lynx-low.h (class lynx_process_target): Update.
* nto-low.cc (nto_target_ops): Update.
(nto_sw_breakpoint_from_kind): Turn into ...
(nto_process_target::sw_breakpoint_from_kind): ... this.
* nto-low.h (class nto_process_target): Update.
* win32-low.cc (win32_target_ops): Update.
(win32_sw_breakpoint_from_kind): Turn into ...
(win32_process_target::sw_breakpoint_from_kind): ... this.
* win32-low.h (class win32_process_target): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's multifs_open, multifs_readlink,
multifs_unlink ops into methods of process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops. Also add
'supports_multifs'.
* target.cc: Include "fcntl.h", "unistd.h", "sys/types.h", and
"sys/stat.h".
(process_target::supports_multifs): Define.
(process_target::multifs_open): Define.
(process_target::multifs_readlink): Define.
(process_target::multifs_unlink): Define.
Update the derived classes and callers below.
* hostio.cc (handle_setfs): Update.
(handle_open): Update.
(handle_unlink): Update.
(handle_readlink): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_multifs): Define.
(linux_process_target::multifs_open): Define.
(linux_process_target::multifs_readlink): Define.
(linux_process_target::multifs_unlink): Define.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's pid_to_exec_file op into a method
of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op. Also add
'supports_pid_to_exec_file'.
* target.cc (process_target::pid_to_exec_file): Define.
(process_target::supports_pid_to_exec_file): Define.
Update the derived classes and callers below.
* server.cc (handle_qxfer_exec_file): Update.
(handle_query): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_pid_to_exec_file): Define.
(linux_process_target::pid_to_exec_file): Define.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_range_stepping op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_range_stepping): Update the macro.
* target.cc (process_target::supports_range_stepping): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_range_stepping): Turn into ...
(linux_process_target::supports_range_stepping): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's btrace-related ops (enable_btrace,
disable_btrace, read_btrace, read_btrace_conf) into methods of
process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops.
(target_enable_btrace): Update.
(target_disable_btrace): Update.
(target_read_btrace): Update.
(target_read_btrace_conf): Update.
* target.cc (process_target::enable_btrace): Define.
(process_target::disable_btrace): Define.
(process_target::read_btrace): Define.
(process_target::read_btrace_conf): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target:enable_btrace): Define as a wrapper around
linux_enable_btrace.
(linux_low_disable_btrace): Turn into ...
(linux_process_target::disable_btrace): ... this.
(linux_low_read_btrace): Turn into ...
(linux_process_target::read_btrace): ... this.
(linux_low_btrace_conf): Turn into ...
(linux_process_target::read_btrace_conf): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_agent op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_agent): Update the macro.
* target.cc (process_target::supports_agent): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_agent): Turn into ...
(linux_process_target::supports_agent): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's qxfer_libraries_svr4 op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op. Also add
'supports_qxfer_libraries_svr4'.
* target.cc (process_target::qxfer_libraries_svr4): Define.
(process_target::supports_qxfer_libraries_svr4): Define.
Update the derived classes and callers below.
* server.cc (handle_qxfer_libraries_svr4): Update.
(handle_query): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_qxfer_libraries_svr4): Define.
(linux_qxfer_libraries_svr4): Turn into ...
(linux_process_target::qxfer_libraries_svr4): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_disable_randomization op
into a method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_disable_randomization): Update the macro.
* target.cc (process_target::supports_disable_randomization): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_disable_randomization): Turn into ...
(linux_process_target::supports_disable_randomization): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's emit_ops op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_emit_ops): Update the macro.
* target.cc (process_target::emit_ops): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_emit_ops): Turn into ...
(linux_process_target::emit_ops): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's install_fast_tracepoint_jump_pad
and get_min_fast_tracepoint_insn_len ops into methods of
process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops. Also add
'supports_fast_tracepoints'.
(target_supports_fast_tracepoints): Update the macro.
(target_get_min_fast_tracepoint_insn_len): Update the macro.
(install_fast_tracepoint_jump_pad): Update and rename the macro
to ...
(target_install_fast_tracepoint_jump_pad): ... this.
* target.cc (process_target::supports_fast_tracepoints): Define.
(process_target::install_fast_tracepoint_jump_pad): Define.
(process_target::get_min_fast_tracepoint_insn_len): Define.
Update the derived classes and callers below.
* tracepoint.cc (install_fast_tracepoint): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_fast_tracepoints): Define.
(linux_install_fast_tracepoint_jump_pad): Turn into ...
(linux_process_target::install_fast_tracepoint_jump_pad): ... this.
(linux_get_min_fast_tracepoint_insn_len): Turn into ...
(linux_process_target::get_min_fast_tracepoint_insn_len): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's stabilize_threads op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_stabilize_threads): Update the macro.
* target.cc (process_target::stabilize_threads): Define.
Update the derived classes and callers below.
* server.cc (handle_status): Update.
* tracepoint.cc (cmd_qtdp): Update.
(cmd_qtstart): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_stabilize_threads): Turn into ...
(linux_process_target::stabilize_threads): ... this.
(linux_wait_1): Update.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's pause_all and unpause_all ops
into methods of process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops.
(pause_all): Update the macro and rename to...
(target_pause_all): ... this.
(unpause_all): Update the macro and rename to...
(target_unpause_all): ... this.
* target.cc (process_target::pause_all): Define.
(process_target::unpause_all): Define.
Update the derived classes and callers below.
* server.cc (handle_status): Update.
* tracepoint.cc (clear_installed_tracepoints): Update.
(cmd_qtdp): Update.
(cmd_qtstart): Update.
(stop_tracing): Update.
(cmd_qtstatus): Update.
(upload_fast_traceframes): Update.
(run_inferior_command): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_pause_all): Turn into ...
(linux_process_target::pause_all): ... this.
(linux_unpause_all): Turn into ...
(linux_process_target::unpause_all): ... this.
(linux_process_target::prepare_to_access_memory): Update.
(linux_process_target::done_accessing_memory): Update.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's get_tib_address op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op. Also add
'supports_get_tib_address'.
* target.cc (process_target::get_tib_address): Define.
(process_target::supports_get_tib_address): Define.
Update the derived classes and callers below.
* server.cc (handle_query): Update.
* linux-low.cc (win32_target_ops): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
(win32_process_target::supports_get_tib_address): Define.
(win32_get_tib_address): Turn into ...
(win32_process_target::get_tib_address): ... this.
* win32-low.h (class win32_process_target): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's thread_stopped op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op. Also add
'supports_thread_stopped'.
(target_thread_stopped): Update the macro.
* target.cc (process_target::thread_stopped): Define.
(process_target::supports_thread_stopped): Define.
(prepare_to_access_memory): Update.
Update the derived classes and callers below.
* server.cc (queue_stop_reply_callback): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_thread_stopped): Define.
(linux_thread_stopped): Turn into ...
(linux_process_target::thread_stopped): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's read_pc and write_pc ops into
methods of process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops.
* target.cc (process_target::read_pc): Define.
(process_target::write_pc): Define.
Update the derived classes and callers below.
* regcache.cc (regcache_read_pc): Update.
(regcache_write_pc): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_read_pc): Turn into ...
(linux_process_target::read_pc): ... this.
(linux_write_pc): Turn into ...
(linux_process_target::write_pc): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_tracepoints op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_supports_tracepoints): Update the macro.
* target.cc (process_target::supports_tracepoints): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_tracepoints): Turn into ...
(linux_process_target::supports_tracepoints): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's process_qsupported op into a method
of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_process_qsupported): Update the macro.
* target.cc (process_target::process_qsupported): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_process_qsupported): Turn into ...
(linux_process_target::process_qsupported): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's read_loadmap op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op. Also add
'supports_read_loadmap'.
* target.cc (process_target::read_loadmap): Define.
(process_target::supports_read_loadmap): Define.
Update the derived classes and callers below.
* server.cc (handle_qxfer_fdpic): Update.
(handle_query): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::supports_read_loadmap): Define.
(linux_read_loadmap): Turn into ...
(linux_process_target::read_loadmap): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's core_of_thread op into a method of
process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_core_of_thread): Update the macro.
* target.cc (process_target::core_of_thread): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::core_of_thread): Define.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's handle_monitor_command op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_handle_monitor_command): Update the macro.
* target.cc (process_target::handle_monitor_command): Define.
Update the derived classes and callers below.
* server.cc (handle_query): Update.
* linux-low.cc (linux_target_ops): Update.
(linux_process_target::handle_monitor_command): Define.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's handle_new_gdb_connection op into a
method of process_target.
* target.h (struct process_stratum_target): Remove the target op.
(class process_target): Add the target op.
(target_handle_new_gdb_connection): Update the macro.
* target.cc (process_target::handle_new_gdb_connection): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_handle_new_gdb_connection): Turn into ...
(linux_process_target::handle_new_gdb_connection): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|
|
gdbserver/ChangeLog:
2020-02-20 Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>
Turn process_stratum_target's supports_fork_events,
supports_vfork_events, and supports_exec_events ops into methods
of process_target.
* target.h (struct process_stratum_target): Remove the target ops.
(class process_target): Add the target ops.
(target_supports_fork_events): Update the macro.
(target_supports_vfork_events): Update the macro.
(target_supports_exec_events): Update the macro.
* target.cc (process_target::supports_fork_events): Define.
(process_target::supports_vfork_events): Define.
(process_target::supports_exec_events): Define.
Update the derived classes and callers below.
* linux-low.cc (linux_target_ops): Update.
(linux_supports_fork_events): Turn into ...
(linux_process_target::supports_fork_events): ... this.
(linux_supports_vfork_events): Turn into ...
(linux_process_target::supports_vfork_events): ... this.
(linux_supports_exec_events): Turn into ...
(linux_process_target::supports_exec_events): ... this.
* linux-low.h (class linux_process_target): Update.
* lynx-low.cc (lynx_target_ops): Update.
* nto-low.cc (nto_target_ops): Update.
* win32-low.cc (win32_target_ops): Update.
|