forked from Imagelibrary/binutils-gdb
e02544b292
We have noticed a regression in our watchpoint support when debugging
through the remote protocol a program running on a bare metal platform,
when the program uses what we call the Ravenscar Runtime.
This runtime is a subset of the Ada runtime defined by the Ravenscar
Profile. One of the nice things about this runtime is that it provides
tasking, which is equivalent to the concept of threads in C (it is
actually often mapped to threads, when available). For bare metal
targets, however, there is no OS, and therefore no thread layer.
What we did, then, was add a ravenscar-thread layer, which has insider
knowledge of the runtime to get the list of threads, but also all
necessary info to perform thread switching.
For the record, the commit which caused the regression is:
commit 799a2abe61
Date: Mon Nov 30 16:05:16 2015 +0000
Subject: remote: stop reason and watchpoint data address per thread
Running local-watch-wrong-thread.exp with "maint set target-non-stop
on" exposes that gdb/remote.c only records whether the target stopped
for a breakpoint/watchpoint plus the watchpoint data address *for the
last reported remote event*. But in non-stop mode, we need to keep
that info per-thread, as each thread can end up with its own
last-status pending.
Our testcase is very simple. We have a package defining a global
variable named "Watch"...
package Pck is
Watch : Integer := 1974;
end Pck;
... and a main subprogram which changes its value
procedure Foo is
begin
Pck.Watch := Pck.Watch + 1;
end Foo;
To reproduce, we built our program as usual, started it in QEMU,
and then connected GDB to QEMU...
(gdb) target remote :4444
(gdb) break _ada_foo
(gdb) cont <--- this is to make sure the program is started
and the variable we want to watch is initialized
... at which point we try to use a watchpoint on our global variable:
(gdb) watch watch
... but, upon resuming the execution with a "cont", we expected to
get a watchpoint-hit notification, such as...
(gdb) cont
Hardware watchpoint 2: watch
Old value = 1974
New value = 1975
0xfff00258 in foo () at /[...]/foo.adb:6
6 end Foo;
... but unfortunately, we get a SIGTRAP instead:
(gdb) cont
Program received signal SIGTRAP, Trace/breakpoint trap.
foo () at /[...]/foo.adb:6
6 end Foo;
What happens is that, on the one hand, the change in remote.c
now stores the watchpoint-hit notification info in the thread
that received it; and on the other hand, we have a ravenscar-thread
layer which manages the thread list on top of the remote protocol
layer. The two of them get disconnected, and this eventually results
in GDB not realizing that we hit a watchpoint. Below is how:
First, once connected and just before inserting our watchpoint,
we have the ravenscar-thread layer which built the list of threads
by extracting some info from inferior memory, giving us the following
two threads:
(gdb) info threads
Id Target Id Frame
1 Thread 0 "0Q@" (Ravenscar task) foo () at /[...]/foo.adb:5
* 2 Thread 0x24618 (Ravenscar task) foo () at /[...]/foo.adb:5
The first thread is the only thread QEMU told GDB about. The second
one is a thread that the ravenscar-thread added. QEMU has now way
to know about those threads, since they are really embedded inside
the program; that's why we have the ravenscar layer, which uses
inside-knowledge to extract the list of threads.
Next, we insert a watchpoint, which applies to all threads. No problem
so far.
Then, we continue; meaning that GDB sends a Z2 packet to QEMU to
get the watchpoint inserted, then a vCont to resume the program's
execution. The program hits the watchpoints, and thererfore QEMU
reports it back:
Packet received: T05thread:01;watch:000022c4;
Since QEMU knows about one thread and one thread only, it stands
to reason that it would say that the event applies to thread:01,
which is our first thread in the "info threads" listing. That
thread has a ptid of {42000, lwp=1, tid=0}.
This is where Pedro's change kicks in: Seeing this event, and
having determined that the event was reported for thread 01,
and therefore ptid {42000, lwp=1, tid=0}, it saves the watchpoint-hit
event info in the private area of that thread/ptid. Once this is
done, remote.c's event-wait layer returns.
Enter the ravenscar-thread layer of the event-wait, which does
a little dance to delegate the wait to underlying layers with
ptids that those layers know about, and then when the target_beneath's
to_wait is done, tries to figure out which thread is now the active
thread. The code looks like this:
1. inferior_ptid = base_ptid;
2. beneath->to_wait (beneath, base_ptid, status, 0);
3. [...]
4. ravenscar_update_inferior_ptid ();
5.
6. return inferior_ptid;
Line 1 is where we reset inferior_ptid to the ptid that
the target_beneath layer knows about, allowing us to then
call its to_wait implementation (line 2). And then, upon
return, we call ravenscar_update_inferior_ptid, which reads
inferior memory to determine which thread is actually active,
setting inferior_ptid accordingly. Then we return that
inferior_ptid (which, again, neither QEMU and therefore nor
the remote.c layer knows about).
Upon return, we eventually arrive to the part where we try
to handle the inferior event: we discover that we got a SIGTRAP
and, as part of its handling, we call watchpoints_triggered,
which calls target_stopped_by_watchpoint, which eventually
remote_stopped_by_watchpoint, where Pedro's change kicks in
again:
struct thread_info *thread = inferior_thread ();
return (thread->priv != NULL
&& thread->priv->stop_reason == TARGET_STOPPED_BY_WATCHPOINT);
Because the ravenscar-thread layer changed the inferior_ptid
to the ptid of the active thread, inferior_thread now returns
the private data of that thread. This is not the thread that
QEMU reported the watchpoint-hit on, and thus, the function
returns "no watchpoint hit, mister". Hence GDB not understanding
the SIGTRAP, thus reporting it verbatim.
The way we chose to fix the issue is by making sure that the
ravenscar-thread layer doesn't let the remote layer be called
with inferior_ptid being set to a thread that the remote layer
does not know about.
gdb/ChangeLog:
* ravenscar-thread.c (ravenscar_stopped_by_sw_breakpoint)
(ravenscar_stopped_by_hw_breakpoint, ravenscar_stopped_by_watchpoint)
(ravenscar_stopped_data_address, ravenscar_core_of_thread):
New functions.
(init_ravenscar_thread_ops): Set the to_stopped_by_sw_breakpoint,
to_stopped_by_hw_breakpoint, to_stopped_by_watchpoint,
to_stopped_data_address and to_core_of_thread fields of
ravenscar_ops.
539 lines
17 KiB
C
539 lines
17 KiB
C
/* Ada Ravenscar thread support.
|
|
|
|
Copyright (C) 2004-2017 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "gdbcore.h"
|
|
#include "gdbthread.h"
|
|
#include "ada-lang.h"
|
|
#include "target.h"
|
|
#include "inferior.h"
|
|
#include "command.h"
|
|
#include "ravenscar-thread.h"
|
|
#include "observer.h"
|
|
#include "gdbcmd.h"
|
|
#include "top.h"
|
|
#include "regcache.h"
|
|
#include "objfiles.h"
|
|
|
|
/* If non-null, ravenscar task support is enabled. */
|
|
static int ravenscar_task_support = 1;
|
|
|
|
/* This module's target-specific operations. */
|
|
static struct target_ops ravenscar_ops;
|
|
|
|
/* Some base target uses a special value for the null PID (exempli gratia
|
|
remote). */
|
|
static ptid_t base_magic_null_ptid;
|
|
|
|
/* Ptid of the inferior as seen by the process stratum. */
|
|
static ptid_t base_ptid;
|
|
|
|
static const char running_thread_name[] = "__gnat_running_thread_table";
|
|
|
|
static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
|
|
static const char first_task_name[] = "system__tasking__debug__first_task";
|
|
|
|
static const char ravenscar_runtime_initializer[] =
|
|
"system__bb__threads__initialize";
|
|
|
|
static void ravenscar_update_thread_list (struct target_ops *ops);
|
|
static ptid_t ravenscar_running_thread (void);
|
|
static const char *ravenscar_extra_thread_info (struct target_ops *self,
|
|
struct thread_info *tp);
|
|
static int ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid);
|
|
static void ravenscar_fetch_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regnum);
|
|
static void ravenscar_store_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regnum);
|
|
static void ravenscar_prepare_to_store (struct target_ops *self,
|
|
struct regcache *regcache);
|
|
static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
|
|
enum gdb_signal siggnal);
|
|
static void ravenscar_mourn_inferior (struct target_ops *ops);
|
|
static void ravenscar_update_inferior_ptid (void);
|
|
static int has_ravenscar_runtime (void);
|
|
static int ravenscar_runtime_initialized (void);
|
|
static void ravenscar_inferior_created (struct target_ops *target,
|
|
int from_tty);
|
|
|
|
/* Fetch the ravenscar running thread from target memory and
|
|
update inferior_ptid accordingly. */
|
|
|
|
static void
|
|
ravenscar_update_inferior_ptid (void)
|
|
{
|
|
base_ptid = inferior_ptid;
|
|
|
|
/* If the runtime has not been initialized yet, the inferior_ptid is
|
|
the only ptid that there is. */
|
|
if (!ravenscar_runtime_initialized ())
|
|
return;
|
|
|
|
/* Make sure we set base_ptid before calling ravenscar_running_thread
|
|
as the latter relies on it. */
|
|
inferior_ptid = ravenscar_running_thread ();
|
|
gdb_assert (!ptid_equal (inferior_ptid, null_ptid));
|
|
|
|
/* The running thread may not have been added to
|
|
system.tasking.debug's list yet; so ravenscar_update_thread_list
|
|
may not always add it to the thread list. Add it here. */
|
|
if (!find_thread_ptid (inferior_ptid))
|
|
add_thread (inferior_ptid);
|
|
}
|
|
|
|
/* The Ravenscar Runtime exports a symbol which contains the ID of
|
|
the thread that is currently running. Try to locate that symbol
|
|
and return its associated minimal symbol.
|
|
Return NULL if not found. */
|
|
|
|
static struct bound_minimal_symbol
|
|
get_running_thread_msymbol (void)
|
|
{
|
|
struct bound_minimal_symbol msym;
|
|
|
|
msym = lookup_minimal_symbol (running_thread_name, NULL, NULL);
|
|
if (!msym.minsym)
|
|
/* Older versions of the GNAT runtime were using a different
|
|
(less ideal) name for the symbol where the active thread ID
|
|
is stored. If we couldn't find the symbol using the latest
|
|
name, then try the old one. */
|
|
msym = lookup_minimal_symbol ("running_thread", NULL, NULL);
|
|
|
|
return msym;
|
|
}
|
|
|
|
/* Return True if the Ada Ravenscar run-time can be found in the
|
|
application. */
|
|
|
|
static int
|
|
has_ravenscar_runtime (void)
|
|
{
|
|
struct bound_minimal_symbol msym_ravenscar_runtime_initializer =
|
|
lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL);
|
|
struct bound_minimal_symbol msym_known_tasks =
|
|
lookup_minimal_symbol (known_tasks_name, NULL, NULL);
|
|
struct bound_minimal_symbol msym_first_task =
|
|
lookup_minimal_symbol (first_task_name, NULL, NULL);
|
|
struct bound_minimal_symbol msym_running_thread
|
|
= get_running_thread_msymbol ();
|
|
|
|
return (msym_ravenscar_runtime_initializer.minsym
|
|
&& (msym_known_tasks.minsym || msym_first_task.minsym)
|
|
&& msym_running_thread.minsym);
|
|
}
|
|
|
|
/* Return True if the Ada Ravenscar run-time can be found in the
|
|
application, and if it has been initialized on target. */
|
|
|
|
static int
|
|
ravenscar_runtime_initialized (void)
|
|
{
|
|
return (!(ptid_equal (ravenscar_running_thread (), null_ptid)));
|
|
}
|
|
|
|
/* Return the ID of the thread that is currently running.
|
|
Return 0 if the ID could not be determined. */
|
|
|
|
static CORE_ADDR
|
|
get_running_thread_id (void)
|
|
{
|
|
struct bound_minimal_symbol object_msym = get_running_thread_msymbol ();
|
|
int object_size;
|
|
int buf_size;
|
|
gdb_byte *buf;
|
|
CORE_ADDR object_addr;
|
|
struct type *builtin_type_void_data_ptr =
|
|
builtin_type (target_gdbarch ())->builtin_data_ptr;
|
|
|
|
if (!object_msym.minsym)
|
|
return 0;
|
|
|
|
object_addr = BMSYMBOL_VALUE_ADDRESS (object_msym);
|
|
object_size = TYPE_LENGTH (builtin_type_void_data_ptr);
|
|
buf_size = object_size;
|
|
buf = (gdb_byte *) alloca (buf_size);
|
|
read_memory (object_addr, buf, buf_size);
|
|
return extract_typed_address (buf, builtin_type_void_data_ptr);
|
|
}
|
|
|
|
static void
|
|
ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step,
|
|
enum gdb_signal siggnal)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
|
|
inferior_ptid = base_ptid;
|
|
beneath->to_resume (beneath, base_ptid, step, siggnal);
|
|
}
|
|
|
|
static ptid_t
|
|
ravenscar_wait (struct target_ops *ops, ptid_t ptid,
|
|
struct target_waitstatus *status,
|
|
int options)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
|
|
inferior_ptid = base_ptid;
|
|
beneath->to_wait (beneath, base_ptid, status, 0);
|
|
/* Find any new threads that might have been created, and update
|
|
inferior_ptid to the active thread.
|
|
|
|
Only do it if the program is still alive, though. Otherwise,
|
|
this causes problems when debugging through the remote protocol,
|
|
because we might try switching threads (and thus sending packets)
|
|
after the remote has disconnected. */
|
|
if (status->kind != TARGET_WAITKIND_EXITED
|
|
&& status->kind != TARGET_WAITKIND_SIGNALLED)
|
|
{
|
|
ravenscar_update_thread_list (ops);
|
|
ravenscar_update_inferior_ptid ();
|
|
}
|
|
return inferior_ptid;
|
|
}
|
|
|
|
/* Add the thread associated to the given TASK to the thread list
|
|
(if the thread has already been added, this is a no-op). */
|
|
|
|
static void
|
|
ravenscar_add_thread (struct ada_task_info *task)
|
|
{
|
|
if (find_thread_ptid (task->ptid) == NULL)
|
|
add_thread (task->ptid);
|
|
}
|
|
|
|
static void
|
|
ravenscar_update_thread_list (struct target_ops *ops)
|
|
{
|
|
ada_build_task_list ();
|
|
|
|
/* Do not clear the thread list before adding the Ada task, to keep
|
|
the thread that the process stratum has included into it
|
|
(base_ptid) and the running thread, that may not have been included
|
|
to system.tasking.debug's list yet. */
|
|
|
|
iterate_over_live_ada_tasks (ravenscar_add_thread);
|
|
}
|
|
|
|
static ptid_t
|
|
ravenscar_running_thread (void)
|
|
{
|
|
CORE_ADDR tid = get_running_thread_id ();
|
|
|
|
if (tid == 0)
|
|
return null_ptid;
|
|
else
|
|
return ptid_build (ptid_get_pid (base_ptid), 0, tid);
|
|
}
|
|
|
|
static const char *
|
|
ravenscar_extra_thread_info (struct target_ops *self, struct thread_info *tp)
|
|
{
|
|
return "Ravenscar task";
|
|
}
|
|
|
|
static int
|
|
ravenscar_thread_alive (struct target_ops *ops, ptid_t ptid)
|
|
{
|
|
/* Ravenscar tasks are non-terminating. */
|
|
return 1;
|
|
}
|
|
|
|
static const char *
|
|
ravenscar_pid_to_str (struct target_ops *ops, ptid_t ptid)
|
|
{
|
|
static char buf[30];
|
|
|
|
snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid_get_tid (ptid));
|
|
return buf;
|
|
}
|
|
|
|
static void
|
|
ravenscar_fetch_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regnum)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
ptid_t ptid = regcache_get_ptid (regcache);
|
|
|
|
if (!ravenscar_runtime_initialized ()
|
|
|| ptid_equal (ptid, base_magic_null_ptid)
|
|
|| ptid_equal (ptid, ravenscar_running_thread ()))
|
|
beneath->to_fetch_registers (beneath, regcache, regnum);
|
|
else
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
struct ravenscar_arch_ops *arch_ops
|
|
= gdbarch_ravenscar_ops (gdbarch);
|
|
|
|
arch_ops->to_fetch_registers (regcache, regnum);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ravenscar_store_registers (struct target_ops *ops,
|
|
struct regcache *regcache, int regnum)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
ptid_t ptid = regcache_get_ptid (regcache);
|
|
|
|
if (!ravenscar_runtime_initialized ()
|
|
|| ptid_equal (ptid, base_magic_null_ptid)
|
|
|| ptid_equal (ptid, ravenscar_running_thread ()))
|
|
beneath->to_store_registers (beneath, regcache, regnum);
|
|
else
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
struct ravenscar_arch_ops *arch_ops
|
|
= gdbarch_ravenscar_ops (gdbarch);
|
|
|
|
arch_ops->to_store_registers (regcache, regnum);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ravenscar_prepare_to_store (struct target_ops *self,
|
|
struct regcache *regcache)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (self);
|
|
ptid_t ptid = regcache_get_ptid (regcache);
|
|
|
|
if (!ravenscar_runtime_initialized ()
|
|
|| ptid_equal (ptid, base_magic_null_ptid)
|
|
|| ptid_equal (ptid, ravenscar_running_thread ()))
|
|
beneath->to_prepare_to_store (beneath, regcache);
|
|
else
|
|
{
|
|
struct gdbarch *gdbarch = regcache->arch ();
|
|
struct ravenscar_arch_ops *arch_ops
|
|
= gdbarch_ravenscar_ops (gdbarch);
|
|
|
|
arch_ops->to_prepare_to_store (regcache);
|
|
}
|
|
}
|
|
|
|
/* Implement the to_stopped_by_sw_breakpoint target_ops "method". */
|
|
|
|
static int
|
|
ravenscar_stopped_by_sw_breakpoint (struct target_ops *ops)
|
|
{
|
|
ptid_t saved_ptid = inferior_ptid;
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
int result;
|
|
|
|
inferior_ptid = base_ptid;
|
|
result = beneath->to_stopped_by_sw_breakpoint (beneath);
|
|
inferior_ptid = saved_ptid;
|
|
return result;
|
|
}
|
|
|
|
/* Implement the to_stopped_by_hw_breakpoint target_ops "method". */
|
|
|
|
static int
|
|
ravenscar_stopped_by_hw_breakpoint (struct target_ops *ops)
|
|
{
|
|
ptid_t saved_ptid = inferior_ptid;
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
int result;
|
|
|
|
inferior_ptid = base_ptid;
|
|
result = beneath->to_stopped_by_hw_breakpoint (beneath);
|
|
inferior_ptid = saved_ptid;
|
|
return result;
|
|
}
|
|
|
|
/* Implement the to_stopped_by_watchpoint target_ops "method". */
|
|
|
|
static int
|
|
ravenscar_stopped_by_watchpoint (struct target_ops *ops)
|
|
{
|
|
ptid_t saved_ptid = inferior_ptid;
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
int result;
|
|
|
|
inferior_ptid = base_ptid;
|
|
result = beneath->to_stopped_by_watchpoint (beneath);
|
|
inferior_ptid = saved_ptid;
|
|
return result;
|
|
}
|
|
|
|
/* Implement the to_stopped_data_address target_ops "method". */
|
|
|
|
static int
|
|
ravenscar_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
|
|
{
|
|
ptid_t saved_ptid = inferior_ptid;
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
int result;
|
|
|
|
inferior_ptid = base_ptid;
|
|
result = beneath->to_stopped_data_address (beneath, addr_p);
|
|
inferior_ptid = saved_ptid;
|
|
return result;
|
|
}
|
|
|
|
static void
|
|
ravenscar_mourn_inferior (struct target_ops *ops)
|
|
{
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
|
|
base_ptid = null_ptid;
|
|
beneath->to_mourn_inferior (beneath);
|
|
unpush_target (&ravenscar_ops);
|
|
}
|
|
|
|
/* Implement the to_core_of_thread target_ops "method". */
|
|
|
|
static int
|
|
ravenscar_core_of_thread (struct target_ops *ops, ptid_t ptid)
|
|
{
|
|
ptid_t saved_ptid = inferior_ptid;
|
|
struct target_ops *beneath = find_target_beneath (ops);
|
|
int result;
|
|
|
|
inferior_ptid = base_ptid;
|
|
result = beneath->to_core_of_thread (beneath, inferior_ptid);
|
|
inferior_ptid = saved_ptid;
|
|
return result;
|
|
}
|
|
|
|
/* Observer on inferior_created: push ravenscar thread stratum if needed. */
|
|
|
|
static void
|
|
ravenscar_inferior_created (struct target_ops *target, int from_tty)
|
|
{
|
|
|
|
if (!ravenscar_task_support
|
|
|| gdbarch_ravenscar_ops (target_gdbarch ()) == NULL
|
|
|| !has_ravenscar_runtime ())
|
|
return;
|
|
|
|
base_magic_null_ptid = inferior_ptid;
|
|
ravenscar_update_inferior_ptid ();
|
|
push_target (&ravenscar_ops);
|
|
}
|
|
|
|
static ptid_t
|
|
ravenscar_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
|
|
{
|
|
return ptid_build (ptid_get_pid (base_ptid), 0, thread);
|
|
}
|
|
|
|
static void
|
|
init_ravenscar_thread_ops (void)
|
|
{
|
|
ravenscar_ops.to_shortname = "ravenscar";
|
|
ravenscar_ops.to_longname = "Ravenscar tasks.";
|
|
ravenscar_ops.to_doc = "Ravenscar tasks support.";
|
|
ravenscar_ops.to_resume = ravenscar_resume;
|
|
ravenscar_ops.to_wait = ravenscar_wait;
|
|
ravenscar_ops.to_fetch_registers = ravenscar_fetch_registers;
|
|
ravenscar_ops.to_store_registers = ravenscar_store_registers;
|
|
ravenscar_ops.to_prepare_to_store = ravenscar_prepare_to_store;
|
|
ravenscar_ops.to_stopped_by_sw_breakpoint
|
|
= ravenscar_stopped_by_sw_breakpoint;
|
|
ravenscar_ops.to_stopped_by_hw_breakpoint
|
|
= ravenscar_stopped_by_hw_breakpoint;
|
|
ravenscar_ops.to_stopped_by_watchpoint = ravenscar_stopped_by_watchpoint;
|
|
ravenscar_ops.to_stopped_data_address = ravenscar_stopped_data_address;
|
|
ravenscar_ops.to_thread_alive = ravenscar_thread_alive;
|
|
ravenscar_ops.to_update_thread_list = ravenscar_update_thread_list;
|
|
ravenscar_ops.to_pid_to_str = ravenscar_pid_to_str;
|
|
ravenscar_ops.to_extra_thread_info = ravenscar_extra_thread_info;
|
|
ravenscar_ops.to_get_ada_task_ptid = ravenscar_get_ada_task_ptid;
|
|
ravenscar_ops.to_mourn_inferior = ravenscar_mourn_inferior;
|
|
ravenscar_ops.to_has_all_memory = default_child_has_all_memory;
|
|
ravenscar_ops.to_has_memory = default_child_has_memory;
|
|
ravenscar_ops.to_has_stack = default_child_has_stack;
|
|
ravenscar_ops.to_has_registers = default_child_has_registers;
|
|
ravenscar_ops.to_has_execution = default_child_has_execution;
|
|
ravenscar_ops.to_stratum = thread_stratum;
|
|
ravenscar_ops.to_core_of_thread = ravenscar_core_of_thread;
|
|
ravenscar_ops.to_magic = OPS_MAGIC;
|
|
}
|
|
|
|
/* Command-list for the "set/show ravenscar" prefix command. */
|
|
static struct cmd_list_element *set_ravenscar_list;
|
|
static struct cmd_list_element *show_ravenscar_list;
|
|
|
|
/* Implement the "set ravenscar" prefix command. */
|
|
|
|
static void
|
|
set_ravenscar_command (const char *arg, int from_tty)
|
|
{
|
|
printf_unfiltered (_(\
|
|
"\"set ravenscar\" must be followed by the name of a setting.\n"));
|
|
help_list (set_ravenscar_list, "set ravenscar ", all_commands, gdb_stdout);
|
|
}
|
|
|
|
/* Implement the "show ravenscar" prefix command. */
|
|
|
|
static void
|
|
show_ravenscar_command (const char *args, int from_tty)
|
|
{
|
|
cmd_show_list (show_ravenscar_list, from_tty, "");
|
|
}
|
|
|
|
/* Implement the "show ravenscar task-switching" command. */
|
|
|
|
static void
|
|
show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
|
|
struct cmd_list_element *c,
|
|
const char *value)
|
|
{
|
|
if (ravenscar_task_support)
|
|
fprintf_filtered (file, _("\
|
|
Support for Ravenscar task/thread switching is enabled\n"));
|
|
else
|
|
fprintf_filtered (file, _("\
|
|
Support for Ravenscar task/thread switching is disabled\n"));
|
|
}
|
|
|
|
/* Module startup initialization function, automagically called by
|
|
init.c. */
|
|
|
|
void
|
|
_initialize_ravenscar (void)
|
|
{
|
|
init_ravenscar_thread_ops ();
|
|
base_ptid = null_ptid;
|
|
|
|
/* Notice when the inferior is created in order to push the
|
|
ravenscar ops if needed. */
|
|
observer_attach_inferior_created (ravenscar_inferior_created);
|
|
|
|
complete_target_initialization (&ravenscar_ops);
|
|
|
|
add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command,
|
|
_("Prefix command for changing Ravenscar-specific settings"),
|
|
&set_ravenscar_list, "set ravenscar ", 0, &setlist);
|
|
|
|
add_prefix_cmd ("ravenscar", no_class, show_ravenscar_command,
|
|
_("Prefix command for showing Ravenscar-specific settings"),
|
|
&show_ravenscar_list, "show ravenscar ", 0, &showlist);
|
|
|
|
add_setshow_boolean_cmd ("task-switching", class_obscure,
|
|
&ravenscar_task_support, _("\
|
|
Enable or disable support for GNAT Ravenscar tasks"), _("\
|
|
Show whether support for GNAT Ravenscar tasks is enabled"),
|
|
_("\
|
|
Enable or disable support for task/thread switching with the GNAT\n\
|
|
Ravenscar run-time library for bareboard configuration."),
|
|
NULL, show_ravenscar_task_switching_command,
|
|
&set_ravenscar_list, &show_ravenscar_list);
|
|
}
|