* Add support for GNAT Ravenscar run-time library @ 2010-09-23 19:01 Joel Brobecker 2010-09-23 19:44 ` [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks Joel Brobecker 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker 0 siblings, 2 replies; 13+ messages in thread From: Joel Brobecker @ 2010-09-23 19:01 UTC (permalink / raw) To: gdb-patches I noticed that we never acted on these patches after we submitted them back in April. This updates them, and fixes the little nits that I mentioned to Jerome. I am planning on committing these patches in a day or two. And I am working on the documentation for the new commands next. ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks 2010-09-23 19:01 Add support for GNAT Ravenscar run-time library Joel Brobecker @ 2010-09-23 19:44 ` Joel Brobecker 2010-09-29 3:25 ` Joel Brobecker 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker 1 sibling, 1 reply; 13+ messages in thread From: Joel Brobecker @ 2010-09-23 19:44 UTC (permalink / raw) To: gdb-patches; +Cc: Joel Brobecker This new function is needed by the ravenscar-thread layer. gdb/ChangeLog: * ada-tasks.c (iterate_over_live_ada_tasks): New function. * ada-lang.h (iterate_over_live_ada_tasks): Declare. --- gdb/ada-lang.h | 4 ++++ gdb/ada-tasks.c | 21 +++++++++++++++++++++ 2 files changed, 25 insertions(+), 0 deletions(-) diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index d1e8ca5..935c2e1 100644 --- a/gdb/ada-lang.h +++ b/gdb/ada-lang.h @@ -378,6 +378,10 @@ extern int valid_task_id (int); extern int ada_get_task_number (ptid_t); +typedef void (ada_task_list_iterator_ftype) (struct ada_task_info *task); +extern void iterate_over_live_ada_tasks + (ada_task_list_iterator_ftype *iterator); + extern int ada_build_task_list (int warn_if_null); extern int ada_exception_catchpoint_p (struct breakpoint *b); diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c index 8e42252..3cbcc4f 100644 --- a/gdb/ada-tasks.c +++ b/gdb/ada-tasks.c @@ -212,6 +212,27 @@ ada_task_is_alive (struct ada_task_info *task_info) return (task_info->state != Terminated); } +/* Call the ITERATOR function once for each Ada task that hasn't been + terminated yet. */ + +void +iterate_over_live_ada_tasks (ada_task_list_iterator_ftype *iterator) +{ + int i, nb_tasks; + struct ada_task_info *task; + + ada_build_task_list (0); + nb_tasks = VEC_length (ada_task_info_s, task_list); + + for (i = 0; i < nb_tasks; i++) + { + task = VEC_index (ada_task_info_s, task_list, i); + if (!ada_task_is_alive (task)) + continue; + iterator (task); + } +} + /* Extract the contents of the value as a string whose length is LENGTH, and store the result in DEST. */ -- 1.7.1 ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks 2010-09-23 19:44 ` [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks Joel Brobecker @ 2010-09-29 3:25 ` Joel Brobecker 0 siblings, 0 replies; 13+ messages in thread From: Joel Brobecker @ 2010-09-29 3:25 UTC (permalink / raw) To: gdb-patches > gdb/ChangeLog: > > * ada-tasks.c (iterate_over_live_ada_tasks): New function. > * ada-lang.h (iterate_over_live_ada_tasks): Declare. Checked in. -- Joel ^ permalink raw reply [flat|nested] 13+ messages in thread
* [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 19:01 Add support for GNAT Ravenscar run-time library Joel Brobecker 2010-09-23 19:44 ` [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks Joel Brobecker @ 2010-09-23 19:49 ` Joel Brobecker 2010-09-23 21:56 ` Joel Brobecker ` (2 more replies) 1 sibling, 3 replies; 13+ messages in thread From: Joel Brobecker @ 2010-09-23 19:49 UTC (permalink / raw) To: gdb-patches; +Cc: Joel Brobecker gdb/ChangeLog (Jerome Guitton, Joel Brobecker): * ravenscar-thread.c, ravenscar-thread.h, ravenscar-sparc-thread.c: New files. * configure.tgt (sparc-*-*): Add ravenscar-thread.o and ravenscar-sparc-thread.o to gdb_target_obs. --- gdb/configure.tgt | 3 +- gdb/ravenscar-sparc-thread.c | 184 +++++++++++++++++++ gdb/ravenscar-thread.c | 409 ++++++++++++++++++++++++++++++++++++++++++ gdb/ravenscar-thread.h | 41 +++++ 4 files changed, 636 insertions(+), 1 deletions(-) create mode 100644 gdb/ravenscar-sparc-thread.c create mode 100644 gdb/ravenscar-thread.c create mode 100644 gdb/ravenscar-thread.h diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 0b44005..80cfb49 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -521,7 +521,8 @@ sparc-*-rtems*) ;; sparc-*-*) # Target: SPARC - gdb_target_obs="sparc-tdep.o" + gdb_target_obs="sparc-tdep.o ravenscar-thread.o \ + ravenscar-sparc-thread.o" ;; sparc64-*-*) # Target: UltraSPARC diff --git a/gdb/ravenscar-sparc-thread.c b/gdb/ravenscar-sparc-thread.c new file mode 100644 index 0000000..df2fa2d --- /dev/null +++ b/gdb/ravenscar-sparc-thread.c @@ -0,0 +1,184 @@ +/* Ravenscar SPARC target support. + + Copyright 2004, 2010 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 "regcache.h" +#include "sparc-tdep.h" +#include "inferior.h" +#include "ravenscar-thread.h" + +static struct ravenscar_arch_ops ravenscar_sparc_ops; + +static void ravenscar_sparc_fetch_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_store_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_prepare_to_store (struct regcache *regcache); + +/* Register offsets from a referenced address (exempli gratia the + Thread_Descriptor). The referenced address depends on the register + number. The Thread_Descriptor layout and the stack layout are documented + in the GNAT sources, in sparc-bb.h. */ + +static const int sparc_register_offsets[] = +{ + /* G0 - G7 */ + -1, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* O0 - O7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* L0 - L7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* I0 - I7 */ + 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* F0 - F31 */ + 0x50, 0x54, 0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, + 0x70, 0x74, 0x78, 0x7C, 0x80, 0x84, 0x88, 0x8C, + 0x90, 0x94, 0x99, 0x9C, 0xA0, 0xA4, 0xA8, 0xAC, + 0xB0, 0xB4, 0xBB, 0xBC, 0xC0, 0xC4, 0xC8, 0xCC, + /* Y PSR WIM TBR PC NPC FPSR CPSR */ + 0x40, 0x20, 0x44, -1, 0x1C, -1, 0x4C, -1 +}; + +/* supply register REGNUM, which has been saved on REGISTER_ADDR, to the + regcache. */ + +static void +supply_register_at_address (struct regcache *regcache, int regnum, + CORE_ADDR register_addr) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char buf [buf_size]; + + read_memory (register_addr, buf, buf_size); + regcache_raw_supply (regcache, regnum, &buf); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + stack. */ + +static int +register_on_stack_p (int regnum) +{ + return (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM) + || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + Thread_Descriptor. */ + +static int +register_in_thread_descriptor_p (int regnum) +{ + return (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM) + || (regnum == SPARC32_PSR_REGNUM) + || (regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM) + || (regnum == SPARC32_Y_REGNUM) + || (regnum == SPARC32_WIM_REGNUM) + || (regnum == SPARC32_FSR_REGNUM) + || (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F0_REGNUM + 31) + || (regnum == SPARC32_PC_REGNUM); +} + +/* to_fetch_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_fetch_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + const int sp_regnum = gdbarch_sp_regnum (gdbarch); + const int num_regs = gdbarch_num_regs (gdbarch); + int current_regnum; + CORE_ADDR current_address; + CORE_ADDR thread_descriptor_address; + ULONGEST stack_address; + + thread_descriptor_address = (CORE_ADDR) ptid_get_tid (inferior_ptid); + current_address = thread_descriptor_address + + sparc_register_offsets [sp_regnum]; + supply_register_at_address (regcache, sp_regnum, current_address); + regcache_cooked_read_unsigned (regcache, sp_regnum, &stack_address); + + for (current_regnum = 0; current_regnum < num_regs; current_regnum ++) + { + if (register_in_thread_descriptor_p (current_regnum)) + { + current_address = thread_descriptor_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + else if (register_on_stack_p (current_regnum)) + { + current_address = stack_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + } +} + +/* to_prepare_to_store when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_prepare_to_store (struct regcache *regcache) +{ + /* Nothing to do. */ +} + +/* to_store_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_store_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char buf [buf_size]; + ULONGEST register_address; + + if (register_in_thread_descriptor_p (regnum)) + register_address = + ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum]; + else if (register_on_stack_p (regnum)) + { + regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, + ®ister_address); + register_address += sparc_register_offsets [regnum]; + } + else + return; + + regcache_raw_collect (regcache, regnum, buf); + write_memory (register_address, + buf, + buf_size); +} + +void +_initialize_ravenscar_sparc (void) +{ + ravenscar_sparc_ops.to_fetch_registers = ravenscar_sparc_fetch_registers; + ravenscar_sparc_ops.to_store_registers = ravenscar_sparc_store_registers; + ravenscar_sparc_ops.to_prepare_to_store = ravenscar_sparc_prepare_to_store; + ravenscar_register_arch_ops (&ravenscar_sparc_ops); +} diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c new file mode 100644 index 0000000..55f8a93 --- /dev/null +++ b/gdb/ravenscar-thread.c @@ -0,0 +1,409 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2009, 2010 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 "gdb_string.h" +#include "gdbcmd.h" +#include "top.h" +#include "regcache.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 = "running_thread"; + +static const char *known_tasks_name = "system__tasking__debug__known_tasks"; + +static const char *ravenscar_runtime_initializer = +"system__bb__threads__initialize"; + +static struct observer *update_target_observer = NULL; + +/* Architecture-specific hooks. */ +static struct ravenscar_arch_ops* current_arch_ops; + +static CORE_ADDR read_thread_id (const char* symbol_name); + +static void ravenscar_find_new_threads (struct target_ops *ops); +static ptid_t ravenscar_running_thread (void); +static char * ravenscar_extra_thread_info (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 regcache *regcache); +static void ravenscar_initialize (char *name, int from_tty); +static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_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_find_new_threads + may not always add it to the thread list. Add it here. */ + if (!find_thread_ptid (inferior_ptid)) + add_thread (inferior_ptid); +} + +/* Return True if the Ada Ravenscar run-time can be found in the + application. */ + +static int +has_ravenscar_runtime (void) +{ + struct minimal_symbol *msym_ravenscar_runtime_initializer = + lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL); + struct minimal_symbol *msym_known_tasks = + lookup_minimal_symbol (known_tasks_name, NULL, NULL); + struct minimal_symbol *msym_running_thread = + lookup_minimal_symbol (running_thread_name, NULL, NULL); + + return (msym_ravenscar_runtime_initializer + && msym_known_tasks + && msym_running_thread); +} + +/* 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))); +} + +/* Read the thread ID whose symbol name is SYMBOL_NAME. */ + +static CORE_ADDR +read_thread_id (const char* symbol_name) +{ + const struct minimal_symbol *object_msym = + lookup_minimal_symbol (symbol_name, NULL, NULL); + int object_size; + int buf_size; + char* buf; + CORE_ADDR object_addr; + struct type *builtin_type_void_data_ptr = + builtin_type (target_gdbarch)->builtin_data_ptr; + + if (!object_msym) + return 0; + + object_addr = SYMBOL_VALUE_ADDRESS (object_msym); + object_size = TYPE_LENGTH (builtin_type_void_data_ptr); + buf_size = object_size; + buf = alloca (buf_size); + read_memory (object_addr, buf, buf_size); + return extract_typed_address (buf, builtin_type_void_data_ptr); +} + +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 (ops, base_ptid, status, 0); + ravenscar_find_new_threads (ops); + ravenscar_update_inferior_ptid (); + return inferior_ptid; +} + +static void +ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_signal siggnal) +{ + struct target_ops *beneath = find_target_beneath (ops); + + inferior_ptid = base_ptid; + beneath->to_resume (ops, base_ptid, step, siggnal); +} + +/* 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_find_new_threads (struct target_ops *ops) +{ + ada_build_task_list (0); + + /* 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 = read_thread_id (running_thread_name); + + if (tid == 0) + return null_ptid; + else + return ptid_build (ptid_get_pid (base_ptid), 0, tid); +} + +static char * +ravenscar_extra_thread_info (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 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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_fetch_registers (ops, regcache, regnum); + else + current_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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_store_registers (ops, regcache, regnum); + else + current_arch_ops->to_store_registers (regcache, regnum); +} + +static void +ravenscar_prepare_to_store (struct regcache *regcache) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_prepare_to_store (regcache); + else + current_arch_ops->to_prepare_to_store (regcache); +} + +static void +ravenscar_mourn_inferior (struct target_ops *ops) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + base_ptid = null_ptid; + beneath->to_mourn_inferior (beneath); + unpush_target (&ravenscar_ops); +} + +/* 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 + && has_ravenscar_runtime () + && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) + ravenscar_initialize (NULL, 0); +} + +void +ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops) +{ + /* FIXME: To be clean, we would need to handle a list of + architectures, just like in remote-wtx-hw.c. However, for now the + only Ravenscar run-time for bare board that is implemented in + GNAT is for only one architecture: erc32-elf. So no need to care about + that for now...*/ + current_arch_ops = ops; +} + +/* Initialize Ravenscar support. */ + +static void +ravenscar_initialize (char *name, int from_tty) +{ + base_magic_null_ptid = inferior_ptid; + ravenscar_update_inferior_ptid (); + push_target (&ravenscar_ops); +} + +static ptid_t +ravenscar_get_ada_task_ptid (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_wait = ravenscar_wait; + ravenscar_ops.to_resume = ravenscar_resume; + 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_thread_alive = ravenscar_thread_alive; + ravenscar_ops.to_find_new_threads = ravenscar_find_new_threads; + 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_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 (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 ", -1, gdb_stdout); +} + +/* Implement the "show ravenscar" prefix command. */ + +static void +show_ravenscar_command (char *args, int from_tty) +{ + cmd_show_list (show_ravenscar_list, from_tty, ""); +} + +/* Module startup initialization function, automagically called by + init.c. */ + +void +_initialize_ravenscar (void) +{ + extern struct cmd_list_element *cmdlist; + + 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); + + add_target (&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, "set ravenscar ", 0, &showlist); + + add_setshow_boolean_cmd ("task-switching", class_obscure, + &ravenscar_task_support, _("\ +Enable or disable support for GNAT Ravenscar tasks"), _("\ +Show whether supported for GNAT Ravenscar tasks is enabled"), + _("\ +Enable or disable support for task/thread switching\n\ +with the GNAT Ravenscar run-time lib for bareboard configuration."), + NULL, NULL, &set_ravenscar_list, + &show_ravenscar_list); +} diff --git a/gdb/ravenscar-thread.h b/gdb/ravenscar-thread.h new file mode 100644 index 0000000..c8844e3 --- /dev/null +++ b/gdb/ravenscar-thread.h @@ -0,0 +1,41 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2010 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/>. */ + +#ifndef RAVENSCAR_THREAD_H +#define RAVENSCAR_THREAD_H + +/* Architecture-specific hooks. */ + +struct ravenscar_arch_ops +{ + void (*to_fetch_registers) (struct regcache *, int); + void (*to_store_registers) (struct regcache *, int); + void (*to_prepare_to_store) (struct regcache *); +}; + +/* Register implementations for target ops to_store_registers, + to_prepare_to_store and to_fetch_registers when the inferior_ptid + is different from the running thread. In that case, the registers + are saved in a architecture-specific location. */ +/* FIXME: only one architecture can be registered for now. See + implementation. */ + +extern void ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops); + +#endif /* !defined (RAVENSCAR_THREAD_H) */ -- 1.7.1 ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker @ 2010-09-23 21:56 ` Joel Brobecker 2010-09-23 21:58 ` Jan Kratochvil 2010-09-23 22:09 ` Pedro Alves 2 siblings, 0 replies; 13+ messages in thread From: Joel Brobecker @ 2010-09-23 21:56 UTC (permalink / raw) To: gdb-patches > +void > +_initialize_ravenscar (void) > +{ > + extern struct cmd_list_element *cmdlist; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This just caught my attention, and I removed it from my local patch. -- Joel ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker 2010-09-23 21:56 ` Joel Brobecker @ 2010-09-23 21:58 ` Jan Kratochvil 2010-09-23 22:09 ` Pedro Alves 2 siblings, 0 replies; 13+ messages in thread From: Jan Kratochvil @ 2010-09-23 21:58 UTC (permalink / raw) To: Joel Brobecker; +Cc: gdb-patches On Thu, 23 Sep 2010 20:43:00 +0200, Joel Brobecker wrote: > --- /dev/null > +++ b/gdb/ravenscar-thread.c [...] > +static CORE_ADDR read_thread_id (const char* symbol_name); ^^-> ` *' [...] > +static char * ravenscar_extra_thread_info (struct thread_info *tp); ^^^-> ` *' [...] > +read_thread_id (const char* symbol_name) ^^-> ` *' > +{ [...] > + char* buf; ^^-> ` *' [...] > +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 (ops, base_ptid, status, 0); ^^^-> beneath With many other places. [...] > +void > +_initialize_ravenscar (void) > +{ > + extern struct cmd_list_element *cmdlist; This declaration is in "gdbcmd.h". Thanks, Jan ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker 2010-09-23 21:56 ` Joel Brobecker 2010-09-23 21:58 ` Jan Kratochvil @ 2010-09-23 22:09 ` Pedro Alves 2010-09-23 23:39 ` Joel Brobecker 2 siblings, 1 reply; 13+ messages in thread From: Pedro Alves @ 2010-09-23 22:09 UTC (permalink / raw) To: gdb-patches; +Cc: Joel Brobecker On a cursory look, here's what I noted, minus issues already mentioned: > +static const char *running_thread_name = "running_thread"; static const char running_thread_name[] = "running_thread"; > + int buf_size = register_size (gdbarch, regnum); > + char buf [buf_size]; This is not valid C90. Use alloca or MAX_REGISTER_SIZE. > + && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) Please no target name comparisions. You want "is the ravenscar open, even if something else is on top", not "is the ravenscar target open and the topmost". > +/* 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 > + && has_ravenscar_runtime () > + && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) > + ravenscar_initialize (NULL, 0); > +} Note that this assumes that the user connects with symbols already loaded. If you connect, and then do "file foo", ravenscar will not end pushed. > + ravenscar_ops.to_shortname = "ravenscar"; > + ravenscar_ops.to_longname = "Ravenscar tasks."; > + ravenscar_ops.to_doc = "Ravenscar tasks support."; > + ravenscar_ops.to_wait = ravenscar_wait; Please no vertical alignment. > + > + add_setshow_boolean_cmd ("task-switching", class_obscure, > + &ravenscar_task_support, _("\ > +Enable or disable support for GNAT Ravenscar tasks"), _("\ > +Show whether supported for GNAT Ravenscar tasks is enabled"), > + _("\ > +Enable or disable support for task/thread switching\n\ > +with the GNAT Ravenscar run-time lib for bareboard configuration."), > + NULL, NULL, &set_ravenscar_list, > + &show_ravenscar_list); Please implement show_func callbacks for all new set/show commands. -- Pedro Alves ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 22:09 ` Pedro Alves @ 2010-09-23 23:39 ` Joel Brobecker 2010-09-24 1:39 ` Pedro Alves 0 siblings, 1 reply; 13+ messages in thread From: Joel Brobecker @ 2010-09-23 23:39 UTC (permalink / raw) To: Pedro Alves, jan.kratochvil; +Cc: gdb-patches [-- Attachment #1: Type: text/plain, Size: 262 bytes --] Hi guys, Thanks for the review. How about this new version? That should fix all the little things that you commented on. (I actually left out the comment about needing symbols before the program is started - I'll treat this as a limitation for now) -- Joel [-- Attachment #2: ravenscar-2.diff --] [-- Type: text/x-diff, Size: 23348 bytes --] commit c416803e767be496d76855af593586f9d921aa0d Author: Joel Brobecker <brobecker@adacore.com> Date: Thu Sep 23 11:16:53 2010 -0700 Add support for GNAT Ravenscar run-time library. gdb/ChangeLog (Jerome Guitton, Joel Brobecker): * ravenscar-thread.c, ravenscar-thread.h, ravenscar-sparc-thread.c: New files. * configure.tgt (sparc-*-*): Add ravenscar-thread.o and ravenscar-sparc-thread.o to gdb_target_obs. diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 0b44005..80cfb49 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -521,7 +521,8 @@ sparc-*-rtems*) ;; sparc-*-*) # Target: SPARC - gdb_target_obs="sparc-tdep.o" + gdb_target_obs="sparc-tdep.o ravenscar-thread.o \ + ravenscar-sparc-thread.o" ;; sparc64-*-*) # Target: UltraSPARC diff --git a/gdb/ravenscar-sparc-thread.c b/gdb/ravenscar-sparc-thread.c new file mode 100644 index 0000000..197b745 --- /dev/null +++ b/gdb/ravenscar-sparc-thread.c @@ -0,0 +1,185 @@ +/* Ravenscar SPARC target support. + + Copyright 2004, 2010 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 "regcache.h" +#include "sparc-tdep.h" +#include "inferior.h" +#include "ravenscar-thread.h" + +static struct ravenscar_arch_ops ravenscar_sparc_ops; + +static void ravenscar_sparc_fetch_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_store_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_prepare_to_store (struct regcache *regcache); + +/* Register offsets from a referenced address (exempli gratia the + Thread_Descriptor). The referenced address depends on the register + number. The Thread_Descriptor layout and the stack layout are documented + in the GNAT sources, in sparc-bb.h. */ + +static const int sparc_register_offsets[] = +{ + /* G0 - G7 */ + -1, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* O0 - O7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* L0 - L7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* I0 - I7 */ + 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* F0 - F31 */ + 0x50, 0x54, 0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, + 0x70, 0x74, 0x78, 0x7C, 0x80, 0x84, 0x88, 0x8C, + 0x90, 0x94, 0x99, 0x9C, 0xA0, 0xA4, 0xA8, 0xAC, + 0xB0, 0xB4, 0xBB, 0xBC, 0xC0, 0xC4, 0xC8, 0xCC, + /* Y PSR WIM TBR PC NPC FPSR CPSR */ + 0x40, 0x20, 0x44, -1, 0x1C, -1, 0x4C, -1 +}; + +/* supply register REGNUM, which has been saved on REGISTER_ADDR, to the + regcache. */ + +static void +supply_register_at_address (struct regcache *regcache, int regnum, + CORE_ADDR register_addr) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char *buf; + + buf = (char *) alloca (buf_size); + read_memory (register_addr, buf, buf_size); + regcache_raw_supply (regcache, regnum, &buf); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + stack. */ + +static int +register_on_stack_p (int regnum) +{ + return (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM) + || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + Thread_Descriptor. */ + +static int +register_in_thread_descriptor_p (int regnum) +{ + return (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM) + || (regnum == SPARC32_PSR_REGNUM) + || (regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM) + || (regnum == SPARC32_Y_REGNUM) + || (regnum == SPARC32_WIM_REGNUM) + || (regnum == SPARC32_FSR_REGNUM) + || (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F0_REGNUM + 31) + || (regnum == SPARC32_PC_REGNUM); +} + +/* to_fetch_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_fetch_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + const int sp_regnum = gdbarch_sp_regnum (gdbarch); + const int num_regs = gdbarch_num_regs (gdbarch); + int current_regnum; + CORE_ADDR current_address; + CORE_ADDR thread_descriptor_address; + ULONGEST stack_address; + + thread_descriptor_address = (CORE_ADDR) ptid_get_tid (inferior_ptid); + current_address = thread_descriptor_address + + sparc_register_offsets [sp_regnum]; + supply_register_at_address (regcache, sp_regnum, current_address); + regcache_cooked_read_unsigned (regcache, sp_regnum, &stack_address); + + for (current_regnum = 0; current_regnum < num_regs; current_regnum ++) + { + if (register_in_thread_descriptor_p (current_regnum)) + { + current_address = thread_descriptor_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + else if (register_on_stack_p (current_regnum)) + { + current_address = stack_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + } +} + +/* to_prepare_to_store when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_prepare_to_store (struct regcache *regcache) +{ + /* Nothing to do. */ +} + +/* to_store_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_store_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char buf [buf_size]; + ULONGEST register_address; + + if (register_in_thread_descriptor_p (regnum)) + register_address = + ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum]; + else if (register_on_stack_p (regnum)) + { + regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, + ®ister_address); + register_address += sparc_register_offsets [regnum]; + } + else + return; + + regcache_raw_collect (regcache, regnum, buf); + write_memory (register_address, + buf, + buf_size); +} + +void +_initialize_ravenscar_sparc (void) +{ + ravenscar_sparc_ops.to_fetch_registers = ravenscar_sparc_fetch_registers; + ravenscar_sparc_ops.to_store_registers = ravenscar_sparc_store_registers; + ravenscar_sparc_ops.to_prepare_to_store = ravenscar_sparc_prepare_to_store; + ravenscar_register_arch_ops (&ravenscar_sparc_ops); +} diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c new file mode 100644 index 0000000..4d3fe8d --- /dev/null +++ b/gdb/ravenscar-thread.c @@ -0,0 +1,420 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2009, 2010 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 "gdb_string.h" +#include "gdbcmd.h" +#include "top.h" +#include "regcache.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[] = "running_thread"; + +static const char known_tasks_name[] = "system__tasking__debug__known_tasks"; + +static const char ravenscar_runtime_initializer[] = "system__bb__threads__initialize"; + +static struct observer *update_target_observer = NULL; + +/* Architecture-specific hooks. */ +static struct ravenscar_arch_ops* current_arch_ops; + +static CORE_ADDR read_thread_id (const char *symbol_name); + +static void ravenscar_find_new_threads (struct target_ops *ops); +static ptid_t ravenscar_running_thread (void); +static char *ravenscar_extra_thread_info (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 regcache *regcache); +static void ravenscar_initialize (char *name, int from_tty); +static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_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_find_new_threads + may not always add it to the thread list. Add it here. */ + if (!find_thread_ptid (inferior_ptid)) + add_thread (inferior_ptid); +} + +/* Return True if the Ada Ravenscar run-time can be found in the + application. */ + +static int +has_ravenscar_runtime (void) +{ + struct minimal_symbol *msym_ravenscar_runtime_initializer = + lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL); + struct minimal_symbol *msym_known_tasks = + lookup_minimal_symbol (known_tasks_name, NULL, NULL); + struct minimal_symbol *msym_running_thread = + lookup_minimal_symbol (running_thread_name, NULL, NULL); + + return (msym_ravenscar_runtime_initializer + && msym_known_tasks + && msym_running_thread); +} + +/* 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))); +} + +/* Read the thread ID whose symbol name is SYMBOL_NAME. */ + +static CORE_ADDR +read_thread_id (const char *symbol_name) +{ + const struct minimal_symbol *object_msym = + lookup_minimal_symbol (symbol_name, NULL, NULL); + int object_size; + int buf_size; + char *buf; + CORE_ADDR object_addr; + struct type *builtin_type_void_data_ptr = + builtin_type (target_gdbarch)->builtin_data_ptr; + + if (!object_msym) + return 0; + + object_addr = SYMBOL_VALUE_ADDRESS (object_msym); + object_size = TYPE_LENGTH (builtin_type_void_data_ptr); + buf_size = object_size; + buf = alloca (buf_size); + read_memory (object_addr, buf, buf_size); + return extract_typed_address (buf, builtin_type_void_data_ptr); +} + +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); + ravenscar_find_new_threads (ops); + ravenscar_update_inferior_ptid (); + return inferior_ptid; +} + +static void +ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_signal siggnal) +{ + struct target_ops *beneath = find_target_beneath (ops); + + inferior_ptid = base_ptid; + beneath->to_resume (beneath, base_ptid, step, siggnal); +} + +/* 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_find_new_threads (struct target_ops *ops) +{ + ada_build_task_list (0); + + /* 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 = read_thread_id (running_thread_name); + + if (tid == 0) + return null_ptid; + else + return ptid_build (ptid_get_pid (base_ptid), 0, tid); +} + +static char * +ravenscar_extra_thread_info (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 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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_fetch_registers (beneath, regcache, regnum); + else + current_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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_store_registers (beneath, regcache, regnum); + else + current_arch_ops->to_store_registers (regcache, regnum); +} + +static void +ravenscar_prepare_to_store (struct regcache *regcache) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_prepare_to_store (regcache); + else + current_arch_ops->to_prepare_to_store (regcache); +} + +static void +ravenscar_mourn_inferior (struct target_ops *ops) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + base_ptid = null_ptid; + beneath->to_mourn_inferior (beneath); + unpush_target (&ravenscar_ops); +} + +/* 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 + && has_ravenscar_runtime () + && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) + ravenscar_initialize (NULL, 0); +} + +void +ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops) +{ + /* FIXME: To be clean, we would need to handle a list of + architectures, just like in remote-wtx-hw.c. However, for now the + only Ravenscar run-time for bare board that is implemented in + GNAT is for only one architecture: erc32-elf. So no need to care about + that for now...*/ + current_arch_ops = ops; +} + +/* Initialize Ravenscar support. */ + +static void +ravenscar_initialize (char *name, int from_tty) +{ + base_magic_null_ptid = inferior_ptid; + ravenscar_update_inferior_ptid (); + push_target (&ravenscar_ops); +} + +static ptid_t +ravenscar_get_ada_task_ptid (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_wait = ravenscar_wait; + ravenscar_ops.to_resume = ravenscar_resume; + 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_thread_alive = ravenscar_thread_alive; + ravenscar_ops.to_find_new_threads = ravenscar_find_new_threads; + 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_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 (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 ", -1, gdb_stdout); +} + +/* Implement the "show ravenscar" prefix command. */ + +static void +show_ravenscar_command (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")); + else + fprintf_filtered (file, _("\ +Support for Ravenscar task/thread switching is disabled")); +} + +/* 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); + + add_target (&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, "set 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); +} diff --git a/gdb/ravenscar-thread.h b/gdb/ravenscar-thread.h new file mode 100644 index 0000000..c8844e3 --- /dev/null +++ b/gdb/ravenscar-thread.h @@ -0,0 +1,41 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2010 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/>. */ + +#ifndef RAVENSCAR_THREAD_H +#define RAVENSCAR_THREAD_H + +/* Architecture-specific hooks. */ + +struct ravenscar_arch_ops +{ + void (*to_fetch_registers) (struct regcache *, int); + void (*to_store_registers) (struct regcache *, int); + void (*to_prepare_to_store) (struct regcache *); +}; + +/* Register implementations for target ops to_store_registers, + to_prepare_to_store and to_fetch_registers when the inferior_ptid + is different from the running thread. In that case, the registers + are saved in a architecture-specific location. */ +/* FIXME: only one architecture can be registered for now. See + implementation. */ + +extern void ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops); + +#endif /* !defined (RAVENSCAR_THREAD_H) */ ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-23 23:39 ` Joel Brobecker @ 2010-09-24 1:39 ` Pedro Alves 2010-09-27 18:59 ` Joel Brobecker 0 siblings, 1 reply; 13+ messages in thread From: Pedro Alves @ 2010-09-24 1:39 UTC (permalink / raw) To: Joel Brobecker; +Cc: jan.kratochvil, gdb-patches On Thursday 23 September 2010 22:39:27, Joel Brobecker wrote: > +static void > +ravenscar_inferior_created (struct target_ops *target, int from_tty) > +{ > + if (ravenscar_task_support > + && has_ravenscar_runtime () > + && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) > + ravenscar_initialize (NULL, 0); > +} Please no current/topmost target name comparisons. Add a ravenscar_is_open global if you don't have any other global you can use to check whether target revenscar is open. -- Pedro Alves ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-24 1:39 ` Pedro Alves @ 2010-09-27 18:59 ` Joel Brobecker 2010-09-27 19:01 ` Pedro Alves 0 siblings, 1 reply; 13+ messages in thread From: Joel Brobecker @ 2010-09-27 18:59 UTC (permalink / raw) To: Pedro Alves; +Cc: jan.kratochvil, gdb-patches [-- Attachment #1: Type: text/plain, Size: 394 bytes --] > Please no current/topmost target name comparisons. Add a > ravenscar_is_open global if you don't have any other global you > can use to check whether target revenscar is open. I tried to find something I could use, but I don't see any. So I added a new static global, as you suggested. Attached is the change I made to the latest version being posted. Does it look OK? Thanks, -- Joel [-- Attachment #2: ravenscar-adjustment-1.diff --] [-- Type: text/x-diff, Size: 1430 bytes --] diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c index 4d3fe8d..03cde89 100644 --- a/gdb/ravenscar-thread.c +++ b/gdb/ravenscar-thread.c @@ -34,6 +34,10 @@ /* If non-null, ravenscar task support is enabled. */ static int ravenscar_task_support = 1; +/* Non-null if the ravenscar thread layer has been pushed on the target + stack. */ +static int ravenscar_is_open = 0; + /* This module's target-specific operations. */ static struct target_ops ravenscar_ops; @@ -282,6 +286,7 @@ ravenscar_mourn_inferior (struct target_ops *ops) base_ptid = null_ptid; beneath->to_mourn_inferior (beneath); unpush_target (&ravenscar_ops); + ravenscar_is_open = 0; } /* Observer on inferior_created: push ravenscar thread stratum if needed. */ @@ -290,8 +295,7 @@ static void ravenscar_inferior_created (struct target_ops *target, int from_tty) { if (ravenscar_task_support - && has_ravenscar_runtime () - && strcmp (target_shortname, ravenscar_ops.to_shortname) != 0) + && has_ravenscar_runtime ()) ravenscar_initialize (NULL, 0); } @@ -311,9 +315,13 @@ ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops) static void ravenscar_initialize (char *name, int from_tty) { + if (ravenscar_is_open) + return; + base_magic_null_ptid = inferior_ptid; ravenscar_update_inferior_ptid (); push_target (&ravenscar_ops); + ravenscar_is_open = 1; } static ptid_t ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-27 18:59 ` Joel Brobecker @ 2010-09-27 19:01 ` Pedro Alves 2010-09-28 14:55 ` Joel Brobecker 0 siblings, 1 reply; 13+ messages in thread From: Pedro Alves @ 2010-09-27 19:01 UTC (permalink / raw) To: Joel Brobecker; +Cc: jan.kratochvil, gdb-patches Hi Joel, This is close, but, On Monday 27 September 2010 18:34:14, Joel Brobecker wrote: > @@ -282,6 +286,7 @@ ravenscar_mourn_inferior (struct target_ops *ops) > base_ptid = null_ptid; > beneath->to_mourn_inferior (beneath); > unpush_target (&ravenscar_ops); > + ravenscar_is_open = 0; > } I'd prefer that a ranvenscar target_ops->to_close callback was implemented, so that if the target ends up closed without going through mourn_inferior (some paths do that presently): static void ravenscar_close (int quitting) { ranvenscar_is_open = 0; } See for example bsd-uthreads.c:bfd_uthread_close, or remote-sim.c:gdbsim_close. This is fine with me with that change. -- Pedro Alves ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-27 19:01 ` Pedro Alves @ 2010-09-28 14:55 ` Joel Brobecker 2010-09-29 9:52 ` Joel Brobecker 0 siblings, 1 reply; 13+ messages in thread From: Joel Brobecker @ 2010-09-28 14:55 UTC (permalink / raw) To: Pedro Alves; +Cc: jan.kratochvil, gdb-patches [-- Attachment #1: Type: text/plain, Size: 512 bytes --] Hi Pedro, > I'd prefer that a ranvenscar target_ops->to_close callback was > implemented, so that if the target ends up closed without going > through mourn_inferior (some paths do that presently): > > static void > ravenscar_close (int quitting) > { > ranvenscar_is_open = 0; > } so many details, I don't know how you guys manage to remember them all! Thanks for catching that. > This is fine with me with that change. Cool! Attached is what I'm planning on checking in tomorrow. Thanks again, -- Joel [-- Attachment #2: ravenscar-3.diff --] [-- Type: text/x-diff, Size: 23595 bytes --] commit 69db55f14e01475ef5cbf7edf0377fecd76c130a Author: Joel Brobecker <brobecker@adacore.com> Date: Thu Sep 23 11:16:53 2010 -0700 Add support for GNAT Ravenscar run-time library. gdb/ChangeLog (Jerome Guitton, Joel Brobecker): * ravenscar-thread.c, ravenscar-thread.h, ravenscar-sparc-thread.c: New files. * configure.tgt (sparc-*-*): Add ravenscar-thread.o and ravenscar-sparc-thread.o to gdb_target_obs. diff --git a/gdb/configure.tgt b/gdb/configure.tgt index 0b44005..80cfb49 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -521,7 +521,8 @@ sparc-*-rtems*) ;; sparc-*-*) # Target: SPARC - gdb_target_obs="sparc-tdep.o" + gdb_target_obs="sparc-tdep.o ravenscar-thread.o \ + ravenscar-sparc-thread.o" ;; sparc64-*-*) # Target: UltraSPARC diff --git a/gdb/ravenscar-sparc-thread.c b/gdb/ravenscar-sparc-thread.c new file mode 100644 index 0000000..197b745 --- /dev/null +++ b/gdb/ravenscar-sparc-thread.c @@ -0,0 +1,185 @@ +/* Ravenscar SPARC target support. + + Copyright 2004, 2010 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 "regcache.h" +#include "sparc-tdep.h" +#include "inferior.h" +#include "ravenscar-thread.h" + +static struct ravenscar_arch_ops ravenscar_sparc_ops; + +static void ravenscar_sparc_fetch_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_store_registers (struct regcache *regcache, + int regnum); +static void ravenscar_sparc_prepare_to_store (struct regcache *regcache); + +/* Register offsets from a referenced address (exempli gratia the + Thread_Descriptor). The referenced address depends on the register + number. The Thread_Descriptor layout and the stack layout are documented + in the GNAT sources, in sparc-bb.h. */ + +static const int sparc_register_offsets[] = +{ + /* G0 - G7 */ + -1, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* O0 - O7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* L0 - L7 */ + 0x00, 0x04, 0x08, 0x0C, 0x10, 0x14, 0x18, 0x1C, + /* I0 - I7 */ + 0x20, 0x24, 0x28, 0x2C, 0x30, 0x34, 0x38, 0x3C, + /* F0 - F31 */ + 0x50, 0x54, 0x58, 0x5C, 0x60, 0x64, 0x68, 0x6C, + 0x70, 0x74, 0x78, 0x7C, 0x80, 0x84, 0x88, 0x8C, + 0x90, 0x94, 0x99, 0x9C, 0xA0, 0xA4, 0xA8, 0xAC, + 0xB0, 0xB4, 0xBB, 0xBC, 0xC0, 0xC4, 0xC8, 0xCC, + /* Y PSR WIM TBR PC NPC FPSR CPSR */ + 0x40, 0x20, 0x44, -1, 0x1C, -1, 0x4C, -1 +}; + +/* supply register REGNUM, which has been saved on REGISTER_ADDR, to the + regcache. */ + +static void +supply_register_at_address (struct regcache *regcache, int regnum, + CORE_ADDR register_addr) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char *buf; + + buf = (char *) alloca (buf_size); + read_memory (register_addr, buf, buf_size); + regcache_raw_supply (regcache, regnum, &buf); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + stack. */ + +static int +register_on_stack_p (int regnum) +{ + return (regnum >= SPARC_L0_REGNUM && regnum <= SPARC_L7_REGNUM) + || (regnum >= SPARC_I0_REGNUM && regnum <= SPARC_I7_REGNUM); +} + +/* Return true if, for a non-running thread, REGNUM has been saved on the + Thread_Descriptor. */ + +static int +register_in_thread_descriptor_p (int regnum) +{ + return (regnum >= SPARC_O0_REGNUM && regnum <= SPARC_O7_REGNUM) + || (regnum == SPARC32_PSR_REGNUM) + || (regnum >= SPARC_G1_REGNUM && regnum <= SPARC_G7_REGNUM) + || (regnum == SPARC32_Y_REGNUM) + || (regnum == SPARC32_WIM_REGNUM) + || (regnum == SPARC32_FSR_REGNUM) + || (regnum >= SPARC_F0_REGNUM && regnum <= SPARC_F0_REGNUM + 31) + || (regnum == SPARC32_PC_REGNUM); +} + +/* to_fetch_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_fetch_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + const int sp_regnum = gdbarch_sp_regnum (gdbarch); + const int num_regs = gdbarch_num_regs (gdbarch); + int current_regnum; + CORE_ADDR current_address; + CORE_ADDR thread_descriptor_address; + ULONGEST stack_address; + + thread_descriptor_address = (CORE_ADDR) ptid_get_tid (inferior_ptid); + current_address = thread_descriptor_address + + sparc_register_offsets [sp_regnum]; + supply_register_at_address (regcache, sp_regnum, current_address); + regcache_cooked_read_unsigned (regcache, sp_regnum, &stack_address); + + for (current_regnum = 0; current_regnum < num_regs; current_regnum ++) + { + if (register_in_thread_descriptor_p (current_regnum)) + { + current_address = thread_descriptor_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + else if (register_on_stack_p (current_regnum)) + { + current_address = stack_address + + sparc_register_offsets [current_regnum]; + supply_register_at_address (regcache, current_regnum, + current_address); + } + } +} + +/* to_prepare_to_store when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_prepare_to_store (struct regcache *regcache) +{ + /* Nothing to do. */ +} + +/* to_store_registers when inferior_ptid is different from the running + thread. */ + +static void +ravenscar_sparc_store_registers (struct regcache *regcache, int regnum) +{ + struct gdbarch *gdbarch = get_regcache_arch (regcache); + int buf_size = register_size (gdbarch, regnum); + char buf [buf_size]; + ULONGEST register_address; + + if (register_in_thread_descriptor_p (regnum)) + register_address = + ptid_get_tid (inferior_ptid) + sparc_register_offsets [regnum]; + else if (register_on_stack_p (regnum)) + { + regcache_cooked_read_unsigned (regcache, SPARC_SP_REGNUM, + ®ister_address); + register_address += sparc_register_offsets [regnum]; + } + else + return; + + regcache_raw_collect (regcache, regnum, buf); + write_memory (register_address, + buf, + buf_size); +} + +void +_initialize_ravenscar_sparc (void) +{ + ravenscar_sparc_ops.to_fetch_registers = ravenscar_sparc_fetch_registers; + ravenscar_sparc_ops.to_store_registers = ravenscar_sparc_store_registers; + ravenscar_sparc_ops.to_prepare_to_store = ravenscar_sparc_prepare_to_store; + ravenscar_register_arch_ops (&ravenscar_sparc_ops); +} diff --git a/gdb/ravenscar-thread.c b/gdb/ravenscar-thread.c new file mode 100644 index 0000000..7a80dcf --- /dev/null +++ b/gdb/ravenscar-thread.c @@ -0,0 +1,434 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2009, 2010 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 "gdb_string.h" +#include "gdbcmd.h" +#include "top.h" +#include "regcache.h" + +/* If non-null, ravenscar task support is enabled. */ +static int ravenscar_task_support = 1; + +/* Non-null if the ravenscar thread layer has been pushed on the target + stack. */ +static int ravenscar_is_open = 0; + +/* 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[] = "running_thread"; + +static const char known_tasks_name[] = "system__tasking__debug__known_tasks"; + +static const char ravenscar_runtime_initializer[] = "system__bb__threads__initialize"; + +static struct observer *update_target_observer = NULL; + +/* Architecture-specific hooks. */ +static struct ravenscar_arch_ops* current_arch_ops; + +static CORE_ADDR read_thread_id (const char *symbol_name); + +static void ravenscar_find_new_threads (struct target_ops *ops); +static ptid_t ravenscar_running_thread (void); +static char *ravenscar_extra_thread_info (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 regcache *regcache); +static void ravenscar_initialize (char *name, int from_tty); +static void ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_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_find_new_threads + may not always add it to the thread list. Add it here. */ + if (!find_thread_ptid (inferior_ptid)) + add_thread (inferior_ptid); +} + +/* Return True if the Ada Ravenscar run-time can be found in the + application. */ + +static int +has_ravenscar_runtime (void) +{ + struct minimal_symbol *msym_ravenscar_runtime_initializer = + lookup_minimal_symbol (ravenscar_runtime_initializer, NULL, NULL); + struct minimal_symbol *msym_known_tasks = + lookup_minimal_symbol (known_tasks_name, NULL, NULL); + struct minimal_symbol *msym_running_thread = + lookup_minimal_symbol (running_thread_name, NULL, NULL); + + return (msym_ravenscar_runtime_initializer + && msym_known_tasks + && msym_running_thread); +} + +/* 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))); +} + +/* Read the thread ID whose symbol name is SYMBOL_NAME. */ + +static CORE_ADDR +read_thread_id (const char *symbol_name) +{ + const struct minimal_symbol *object_msym = + lookup_minimal_symbol (symbol_name, NULL, NULL); + int object_size; + int buf_size; + char *buf; + CORE_ADDR object_addr; + struct type *builtin_type_void_data_ptr = + builtin_type (target_gdbarch)->builtin_data_ptr; + + if (!object_msym) + return 0; + + object_addr = SYMBOL_VALUE_ADDRESS (object_msym); + object_size = TYPE_LENGTH (builtin_type_void_data_ptr); + buf_size = object_size; + buf = alloca (buf_size); + read_memory (object_addr, buf, buf_size); + return extract_typed_address (buf, builtin_type_void_data_ptr); +} + +static void +ravenscar_close (int quitting) +{ + ravenscar_is_open = 0; +} + +static void +ravenscar_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_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); + ravenscar_find_new_threads (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_find_new_threads (struct target_ops *ops) +{ + ada_build_task_list (0); + + /* 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 = read_thread_id (running_thread_name); + + if (tid == 0) + return null_ptid; + else + return ptid_build (ptid_get_pid (base_ptid), 0, tid); +} + +static char * +ravenscar_extra_thread_info (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 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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_fetch_registers (beneath, regcache, regnum); + else + current_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); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_store_registers (beneath, regcache, regnum); + else + current_arch_ops->to_store_registers (regcache, regnum); +} + +static void +ravenscar_prepare_to_store (struct regcache *regcache) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + if (!ravenscar_runtime_initialized () + || ptid_equal (inferior_ptid, base_magic_null_ptid) + || ptid_equal (inferior_ptid, ravenscar_running_thread ())) + beneath->to_prepare_to_store (regcache); + else + current_arch_ops->to_prepare_to_store (regcache); +} + +static void +ravenscar_mourn_inferior (struct target_ops *ops) +{ + struct target_ops *beneath = find_target_beneath (&ravenscar_ops); + + base_ptid = null_ptid; + beneath->to_mourn_inferior (beneath); + unpush_target (&ravenscar_ops); +} + +/* 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 + && has_ravenscar_runtime ()) + ravenscar_initialize (NULL, 0); +} + +void +ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops) +{ + /* FIXME: To be clean, we would need to handle a list of + architectures, just like in remote-wtx-hw.c. However, for now the + only Ravenscar run-time for bare board that is implemented in + GNAT is for only one architecture: erc32-elf. So no need to care about + that for now...*/ + current_arch_ops = ops; +} + +/* Initialize Ravenscar support. */ + +static void +ravenscar_initialize (char *name, int from_tty) +{ + if (ravenscar_is_open) + return; + + base_magic_null_ptid = inferior_ptid; + ravenscar_update_inferior_ptid (); + push_target (&ravenscar_ops); + ravenscar_is_open = 1; +} + +static ptid_t +ravenscar_get_ada_task_ptid (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_close = ravenscar_close; + 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_thread_alive = ravenscar_thread_alive; + ravenscar_ops.to_find_new_threads = ravenscar_find_new_threads; + 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_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 (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 ", -1, gdb_stdout); +} + +/* Implement the "show ravenscar" prefix command. */ + +static void +show_ravenscar_command (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")); + else + fprintf_filtered (file, _("\ +Support for Ravenscar task/thread switching is disabled")); +} + +/* 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); + + add_target (&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, "set 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); +} diff --git a/gdb/ravenscar-thread.h b/gdb/ravenscar-thread.h new file mode 100644 index 0000000..c8844e3 --- /dev/null +++ b/gdb/ravenscar-thread.h @@ -0,0 +1,41 @@ +/* Ada Ravenscar thread support. + + Copyright 2004, 2010 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/>. */ + +#ifndef RAVENSCAR_THREAD_H +#define RAVENSCAR_THREAD_H + +/* Architecture-specific hooks. */ + +struct ravenscar_arch_ops +{ + void (*to_fetch_registers) (struct regcache *, int); + void (*to_store_registers) (struct regcache *, int); + void (*to_prepare_to_store) (struct regcache *); +}; + +/* Register implementations for target ops to_store_registers, + to_prepare_to_store and to_fetch_registers when the inferior_ptid + is different from the running thread. In that case, the registers + are saved in a architecture-specific location. */ +/* FIXME: only one architecture can be registered for now. See + implementation. */ + +extern void ravenscar_register_arch_ops (struct ravenscar_arch_ops *ops); + +#endif /* !defined (RAVENSCAR_THREAD_H) */ ^ permalink raw reply [flat|nested] 13+ messages in thread
* Re: [PATCH 2/2] Add support for GNAT Ravenscar run-time library. 2010-09-28 14:55 ` Joel Brobecker @ 2010-09-29 9:52 ` Joel Brobecker 0 siblings, 0 replies; 13+ messages in thread From: Joel Brobecker @ 2010-09-29 9:52 UTC (permalink / raw) To: gdb-patches > gdb/ChangeLog (Jerome Guitton, Joel Brobecker): > > * ravenscar-thread.c, ravenscar-thread.h, ravenscar-sparc-thread.c: > New files. > * configure.tgt (sparc-*-*): Add ravenscar-thread.o and > ravenscar-sparc-thread.o to gdb_target_obs. Just confirming that this patch has now been checked in too. -- Joel ^ permalink raw reply [flat|nested] 13+ messages in thread
end of thread, other threads:[~2010-09-28 21:48 UTC | newest] Thread overview: 13+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2010-09-23 19:01 Add support for GNAT Ravenscar run-time library Joel Brobecker 2010-09-23 19:44 ` [PATCH 1/2] [Ada] Add ada-tasks.c:iterate_over_live_ada_tasks Joel Brobecker 2010-09-29 3:25 ` Joel Brobecker 2010-09-23 19:49 ` [PATCH 2/2] Add support for GNAT Ravenscar run-time library Joel Brobecker 2010-09-23 21:56 ` Joel Brobecker 2010-09-23 21:58 ` Jan Kratochvil 2010-09-23 22:09 ` Pedro Alves 2010-09-23 23:39 ` Joel Brobecker 2010-09-24 1:39 ` Pedro Alves 2010-09-27 18:59 ` Joel Brobecker 2010-09-27 19:01 ` Pedro Alves 2010-09-28 14:55 ` Joel Brobecker 2010-09-29 9:52 ` Joel Brobecker
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).