is running, switching to its corresponding ptid, and then performing
the operation on that ptid using the target beneath us. */
-/* If non-null, ravenscar task support is enabled. */
-static int ravenscar_task_support = 1;
-
-/* PTID of the last thread that received an event.
- This can be useful to determine the associated task that received
- the event, to make it the current task. */
-static ptid_t base_ptid;
+/* If true, ravenscar task support is enabled. */
+static bool ravenscar_task_support = true;
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 const char ravenscar_runtime_initializer[]
+ = "system__bb__threads__initialize";
static const target_info ravenscar_target_info = {
"ravenscar",
struct ravenscar_thread_target final : public target_ops
{
+ ravenscar_thread_target ()
+ {
+ update_inferior_ptid ();
+ }
+
const target_info &info () const override
{ return ravenscar_target_info; }
const char *extra_thread_info (struct thread_info *) override;
- const char *pid_to_str (ptid_t) override;
+ std::string pid_to_str (ptid_t) override;
ptid_t get_ada_task_ptid (long lwp, long thread) override;
void mourn_inferior () override;
-};
-/* This module's target-specific operations. */
-static ravenscar_thread_target ravenscar_ops;
+ void close () override
+ {
+ delete this;
+ }
-static ptid_t ravenscar_active_task (int cpu);
-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);
+private:
-/* Return nonzero iff PTID corresponds to a ravenscar task. */
+ /* PTID of the last thread that received an event.
+ This can be useful to determine the associated task that received
+ the event, to make it the current task. */
+ ptid_t m_base_ptid = null_ptid;
-static int
+ void update_inferior_ptid ();
+ ptid_t active_task (int cpu);
+ bool task_is_currently_active (ptid_t ptid);
+ bool runtime_initialized ();
+};
+
+/* Return true iff PTID corresponds to a ravenscar task. */
+
+static bool
is_ravenscar_task (ptid_t ptid)
{
/* By construction, ravenscar tasks have their LWP set to zero.
return base_cpu;
}
-/* Given a ravenscar task (identified by its ptid_t PTID), return nonzero
+/* Given a ravenscar task (identified by its ptid_t PTID), return true
if this task is the currently active task on the cpu that task is
running on.
that task's registers are in the CPU bank. Otherwise, the task
is currently suspended, and its registers have been saved in memory. */
-static int
-ravenscar_task_is_currently_active (ptid_t ptid)
+bool
+ravenscar_thread_target::task_is_currently_active (ptid_t ptid)
{
ptid_t active_task_ptid
- = ravenscar_active_task (ravenscar_get_thread_base_cpu (ptid));
+ = active_task (ravenscar_get_thread_base_cpu (ptid));
return ptid == active_task_ptid;
}
/* Fetch the ravenscar running thread from target memory and
update inferior_ptid accordingly. */
-static void
-ravenscar_update_inferior_ptid (void)
+void
+ravenscar_thread_target::update_inferior_ptid ()
{
int base_cpu;
- base_ptid = inferior_ptid;
+ m_base_ptid = inferior_ptid;
gdb_assert (!is_ravenscar_task (inferior_ptid));
- base_cpu = ravenscar_get_thread_base_cpu (base_ptid);
+ base_cpu = ravenscar_get_thread_base_cpu (m_base_ptid);
/* If the runtime has not been initialized yet, the inferior_ptid is
the only ptid that there is. */
- if (!ravenscar_runtime_initialized ())
+ if (!runtime_initialized ())
return;
- /* Make sure we set base_ptid before calling ravenscar_active_task
+ /* Make sure we set m_base_ptid before calling active_task
as the latter relies on it. */
- inferior_ptid = ravenscar_active_task (base_cpu);
+ inferior_ptid = active_task (base_cpu);
gdb_assert (inferior_ptid != null_ptid);
/* The running thread may not have been added to
Return NULL if not found. */
static struct bound_minimal_symbol
-get_running_thread_msymbol (void)
+get_running_thread_msymbol ()
{
struct bound_minimal_symbol 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);
+static bool
+has_ravenscar_runtime ()
+{
+ 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 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)
+bool
+ravenscar_thread_target::runtime_initialized ()
{
- return (!(ravenscar_active_task (1) == null_ptid));
+ return active_task (1) != null_ptid;
}
/* Return the ID of the thread that is currently running.
int buf_size;
gdb_byte *buf;
CORE_ADDR object_addr;
- struct type *builtin_type_void_data_ptr =
- builtin_type (target_gdbarch ())->builtin_data_ptr;
+ struct type *builtin_type_void_data_ptr
+ = builtin_type (target_gdbarch ())->builtin_data_ptr;
if (!object_msym.minsym)
return 0;
}
void
-ravenscar_thread_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
+ravenscar_thread_target::resume (ptid_t ptid, int step,
+ enum gdb_signal siggnal)
{
- inferior_ptid = base_ptid;
- beneath ()->resume (base_ptid, step, siggnal);
+ /* If we see a wildcard resume, we simply pass that on. Otherwise,
+ arrange to resume the base ptid. */
+ inferior_ptid = m_base_ptid;
+ if (ptid != minus_one_ptid)
+ ptid = m_base_ptid;
+ beneath ()->resume (ptid, step, siggnal);
}
ptid_t
{
ptid_t event_ptid;
- inferior_ptid = base_ptid;
- event_ptid = beneath ()->wait (base_ptid, status, 0);
+ inferior_ptid = m_base_ptid;
+ if (ptid != minus_one_ptid)
+ ptid = m_base_ptid;
+ event_ptid = beneath ()->wait (ptid, status, 0);
/* Find any new threads that might have been created, and update
inferior_ptid to the active thread.
{
inferior_ptid = event_ptid;
this->update_thread_list ();
- ravenscar_update_inferior_ptid ();
+ this->update_inferior_ptid ();
}
+ else
+ inferior_ptid = m_base_ptid;
return inferior_ptid;
}
void
ravenscar_thread_target::update_thread_list ()
{
- 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
+ (m_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_active_task (int cpu)
+ptid_t
+ravenscar_thread_target::active_task (int cpu)
{
CORE_ADDR tid = get_running_thread_id (cpu);
if (tid == 0)
return null_ptid;
else
- return ptid_t (base_ptid.pid (), 0, tid);
+ return ptid_t (m_base_ptid.pid (), 0, tid);
}
const char *
return true;
}
-const char *
+std::string
ravenscar_thread_target::pid_to_str (ptid_t ptid)
{
- static char buf[30];
-
- snprintf (buf, sizeof (buf), "Thread %#x", (int) ptid.tid ());
- return buf;
+ return string_printf ("Thread %#x", (int) ptid.tid ());
}
void
{
ptid_t ptid = regcache->ptid ();
- if (ravenscar_runtime_initialized ()
+ if (runtime_initialized ()
&& is_ravenscar_task (ptid)
- && !ravenscar_task_is_currently_active (ptid))
+ && !task_is_currently_active (ptid))
{
struct gdbarch *gdbarch = regcache->arch ();
struct ravenscar_arch_ops *arch_ops
{
ptid_t ptid = regcache->ptid ();
- if (ravenscar_runtime_initialized ()
+ if (runtime_initialized ()
&& is_ravenscar_task (ptid)
- && !ravenscar_task_is_currently_active (ptid))
+ && !task_is_currently_active (ptid))
{
struct gdbarch *gdbarch = regcache->arch ();
struct ravenscar_arch_ops *arch_ops
{
ptid_t ptid = regcache->ptid ();
- if (ravenscar_runtime_initialized ()
+ if (runtime_initialized ()
&& is_ravenscar_task (ptid)
- && !ravenscar_task_is_currently_active (ptid))
+ && !task_is_currently_active (ptid))
{
/* Nothing. */
}
void
ravenscar_thread_target::mourn_inferior ()
{
- base_ptid = null_ptid;
+ m_base_ptid = null_ptid;
beneath ()->mourn_inferior ();
- unpush_target (&ravenscar_ops);
+ unpush_target (this);
}
/* Implement the to_core_of_thread target_ops "method". */
return;
}
- ravenscar_update_inferior_ptid ();
- push_target (&ravenscar_ops);
+ target_ops_up target_holder (new ravenscar_thread_target ());
+ push_target (std::move (target_holder));
}
ptid_t
ravenscar_thread_target::get_ada_task_ptid (long lwp, long thread)
{
- return ptid_t (base_ptid.pid (), 0, thread);
+ return ptid_t (m_base_ptid.pid (), 0, thread);
}
/* Command-list for the "set/show ravenscar" prefix command. */
init.c. */
void
-_initialize_ravenscar (void)
+_initialize_ravenscar ()
{
- base_ptid = null_ptid;
-
/* Notice when the inferior is created in order to push the
ravenscar ops if needed. */
gdb::observers::inferior_created.attach (ravenscar_inferior_created);
add_prefix_cmd ("ravenscar", no_class, set_ravenscar_command,
- _("Prefix command for changing Ravenscar-specific settings"),
+ _("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"),
+ _("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 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."),
projects / deliverable / binutils-gdb.git / blobdiff