]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/ravenscar-thread.c
4d79b3d06e02cd0a1372510f838a091a5835f293
[thirdparty/binutils-gdb.git] / gdb / ravenscar-thread.c
1 /* Ada Ravenscar thread support.
2
3 Copyright (C) 2004-2025 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "extract-store-integer.h"
21 #include "gdbcore.h"
22 #include "gdbthread.h"
23 #include "ada-lang.h"
24 #include "target.h"
25 #include "inferior.h"
26 #include "command.h"
27 #include "ravenscar-thread.h"
28 #include "observable.h"
29 #include "cli/cli-cmds.h"
30 #include "top.h"
31 #include "regcache.h"
32 #include "objfiles.h"
33 #include "gdbsupport/unordered_map.h"
34
35 /* This module provides support for "Ravenscar" tasks (Ada) when
36 debugging on bare-metal targets.
37
38 The typical situation is when debugging a bare-metal target over
39 the remote protocol. In that situation, the system does not know
40 about high-level concepts such as threads, only about some code
41 running on one or more CPUs. And since the remote protocol does not
42 provide any handling for CPUs, the de facto standard for handling
43 them is to have one thread per CPU, where the thread's ptid has
44 its lwp field set to the CPU number (eg: 1 for the first CPU,
45 2 for the second one, etc). This module will make that assumption.
46
47 This module then creates and maintains the list of threads based
48 on the list of Ada tasks, with one thread per Ada task. The convention
49 is that threads corresponding to the CPUs (see assumption above)
50 have a ptid_t of the form (PID, LWP, 0), while threads corresponding
51 to our Ada tasks have a ptid_t of the form (PID, 0, TID) where TID
52 is the Ada task's ID as extracted from Ada runtime information.
53
54 Switching to a given Ada task (or its underlying thread) is performed
55 by fetching the registers of that task from the memory area where
56 the registers were saved. For any of the other operations, the
57 operation is performed by first finding the CPU on which the task
58 is running, switching to its corresponding ptid, and then performing
59 the operation on that ptid using the target beneath us. */
60
61 /* If true, ravenscar task support is enabled. */
62 static bool ravenscar_task_support = true;
63
64 static const char running_thread_name[] = "__gnat_running_thread_table";
65
66 static const char known_tasks_name[] = "system__tasking__debug__known_tasks";
67 static const char first_task_name[] = "system__tasking__debug__first_task";
68
69 static const char ravenscar_runtime_initializer[]
70 = "system__bb__threads__initialize";
71
72 static const target_info ravenscar_target_info = {
73 "ravenscar",
74 N_("Ravenscar tasks."),
75 N_("Ravenscar tasks support.")
76 };
77
78 struct ravenscar_thread_target final : public target_ops
79 {
80 ravenscar_thread_target ()
81 : m_base_ptid (inferior_ptid)
82 {
83 }
84
85 const target_info &info () const override
86 { return ravenscar_target_info; }
87
88 strata stratum () const override { return thread_stratum; }
89
90 ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
91 void resume (ptid_t, int, enum gdb_signal) override;
92
93 void fetch_registers (struct regcache *, int) override;
94 void store_registers (struct regcache *, int) override;
95
96 void prepare_to_store (struct regcache *) override;
97
98 bool stopped_by_sw_breakpoint () override;
99
100 bool stopped_by_hw_breakpoint () override;
101
102 bool stopped_by_watchpoint () override;
103
104 bool stopped_data_address (CORE_ADDR *) override;
105
106 enum target_xfer_status xfer_partial (enum target_object object,
107 const char *annex,
108 gdb_byte *readbuf,
109 const gdb_byte *writebuf,
110 ULONGEST offset, ULONGEST len,
111 ULONGEST *xfered_len) override;
112
113 bool thread_alive (ptid_t ptid) override;
114
115 int core_of_thread (ptid_t ptid) override;
116
117 void update_thread_list () override;
118
119 std::string pid_to_str (ptid_t) override;
120
121 ptid_t get_ada_task_ptid (long lwp, ULONGEST thread) override;
122
123 struct btrace_target_info *enable_btrace (thread_info *tp,
124 const struct btrace_config *conf)
125 override
126 {
127 process_stratum_target *proc_target
128 = as_process_stratum_target (this->beneath ());
129 ptid_t underlying = get_base_thread_from_ravenscar_task (tp->ptid);
130 tp = proc_target->find_thread (underlying);
131
132 return beneath ()->enable_btrace (tp, conf);
133 }
134
135 void mourn_inferior () override;
136
137 void close () override
138 {
139 delete this;
140 }
141
142 thread_info *add_active_thread ();
143
144 private:
145
146 /* PTID of the last thread that received an event.
147 This can be useful to determine the associated task that received
148 the event, to make it the current task. */
149 ptid_t m_base_ptid;
150
151 ptid_t active_task (int cpu);
152 bool task_is_currently_active (ptid_t ptid);
153 bool runtime_initialized ();
154 int get_thread_base_cpu (ptid_t ptid);
155 ptid_t get_base_thread_from_ravenscar_task (ptid_t ptid);
156 void add_thread (struct ada_task_info *task);
157
158 /* Like switch_to_thread, but uses the base ptid for the thread. */
159 void set_base_thread_from_ravenscar_task (ptid_t ptid)
160 {
161 process_stratum_target *proc_target
162 = as_process_stratum_target (this->beneath ());
163 ptid_t underlying = get_base_thread_from_ravenscar_task (ptid);
164 switch_to_thread (proc_target->find_thread (underlying));
165 }
166
167 /* Some targets use lazy FPU initialization. On these, the FP
168 registers for a given task might be uninitialized, or stored in
169 the per-task context, or simply be the live registers on the CPU.
170 This enum is used to encode this information. */
171 enum fpu_state
172 {
173 /* This target doesn't do anything special for FP registers -- if
174 any exist, they are treated just identical to non-FP
175 registers. */
176 NOTHING_SPECIAL,
177 /* This target uses the lazy FP scheme, and the FP registers are
178 taken from the CPU. This can happen for any task, because if a
179 task switch occurs, the registers aren't immediately written to
180 the per-task context -- this is deferred until the current task
181 causes an FPU trap. */
182 LIVE_FP_REGISTERS,
183 /* This target uses the lazy FP scheme, and the FP registers are
184 not available. Maybe this task never initialized the FPU, or
185 maybe GDB couldn't find the required symbol. */
186 NO_FP_REGISTERS
187 };
188
189 /* Return the FPU state. */
190 fpu_state get_fpu_state (struct regcache *regcache,
191 const ravenscar_arch_ops *arch_ops);
192
193 /* This maps a TID to the CPU on which it was running. This is
194 needed because sometimes the runtime will report an active task
195 that hasn't yet been put on the list of tasks that is read by
196 ada-tasks.c. */
197 gdb::unordered_map<ULONGEST, int> m_cpu_map;
198 };
199
200 /* Return true iff PTID corresponds to a ravenscar task. */
201
202 static bool
203 is_ravenscar_task (ptid_t ptid)
204 {
205 /* By construction, ravenscar tasks have their LWP set to zero.
206 Also make sure that the TID is nonzero, as some remotes, when
207 asked for the list of threads, will return the first thread
208 as having its TID set to zero. For instance, TSIM version
209 2.0.48 for LEON3 sends 'm0' as a reply to the 'qfThreadInfo'
210 query, which the remote protocol layer then treats as a thread
211 whose TID is 0. This is obviously not a ravenscar task. */
212 return ptid.lwp () == 0 && ptid.tid () != 0;
213 }
214
215 /* Given PTID, which can be either a ravenscar task or a CPU thread,
216 return which CPU that ptid is running on.
217
218 This assume that PTID is a valid ptid_t. Otherwise, a gdb_assert
219 will be triggered. */
220
221 int
222 ravenscar_thread_target::get_thread_base_cpu (ptid_t ptid)
223 {
224 int base_cpu;
225
226 if (is_ravenscar_task (ptid))
227 {
228 /* Prefer to not read inferior memory if possible, to avoid
229 reentrancy problems with xfer_partial. */
230 auto iter = m_cpu_map.find (ptid.tid ());
231
232 if (iter != m_cpu_map.end ())
233 base_cpu = iter->second;
234 else
235 {
236 struct ada_task_info *task_info = ada_get_task_info_from_ptid (ptid);
237
238 gdb_assert (task_info != NULL);
239 base_cpu = task_info->base_cpu;
240 }
241 }
242 else
243 {
244 /* We assume that the LWP of the PTID is equal to the CPU number. */
245 base_cpu = ptid.lwp ();
246 }
247
248 return base_cpu;
249 }
250
251 /* Given a ravenscar task (identified by its ptid_t PTID), return true
252 if this task is the currently active task on the cpu that task is
253 running on.
254
255 In other words, this function determine which CPU this task is
256 currently running on, and then return nonzero if the CPU in question
257 is executing the code for that task. If that's the case, then
258 that task's registers are in the CPU bank. Otherwise, the task
259 is currently suspended, and its registers have been saved in memory. */
260
261 bool
262 ravenscar_thread_target::task_is_currently_active (ptid_t ptid)
263 {
264 ptid_t active_task_ptid = active_task (get_thread_base_cpu (ptid));
265
266 return ptid == active_task_ptid;
267 }
268
269 /* Return the CPU thread (as a ptid_t) on which the given ravenscar
270 task is running.
271
272 This is the thread that corresponds to the CPU on which the task
273 is running. */
274
275 ptid_t
276 ravenscar_thread_target::get_base_thread_from_ravenscar_task (ptid_t ptid)
277 {
278 int base_cpu;
279
280 if (!is_ravenscar_task (ptid))
281 return ptid;
282
283 base_cpu = get_thread_base_cpu (ptid);
284 return ptid_t (ptid.pid (), base_cpu);
285 }
286
287 /* Fetch the ravenscar running thread from target memory, make sure
288 there's a corresponding thread in the thread list, and return it.
289 If the runtime is not initialized, return NULL. */
290
291 thread_info *
292 ravenscar_thread_target::add_active_thread ()
293 {
294 process_stratum_target *proc_target
295 = as_process_stratum_target (this->beneath ());
296
297 int base_cpu;
298
299 gdb_assert (!is_ravenscar_task (m_base_ptid));
300 base_cpu = get_thread_base_cpu (m_base_ptid);
301
302 if (!runtime_initialized ())
303 return nullptr;
304
305 /* It's possible for runtime_initialized to return true but for it
306 not to be fully initialized. For example, this can happen for a
307 breakpoint placed at the task's beginning. */
308 ptid_t active_ptid = active_task (base_cpu);
309 if (active_ptid == null_ptid)
310 return nullptr;
311
312 /* The running thread may not have been added to
313 system.tasking.debug's list yet; so ravenscar_update_thread_list
314 may not always add it to the thread list. Add it here. */
315 thread_info *active_thr = proc_target->find_thread (active_ptid);
316 if (active_thr == nullptr)
317 {
318 active_thr = ::add_thread (proc_target, active_ptid);
319 m_cpu_map[active_ptid.tid ()] = base_cpu;
320 }
321 return active_thr;
322 }
323
324 /* The Ravenscar Runtime exports a symbol which contains the ID of
325 the thread that is currently running. Try to locate that symbol
326 and return its associated minimal symbol.
327 Return NULL if not found. */
328
329 static bound_minimal_symbol
330 get_running_thread_msymbol ()
331 {
332 bound_minimal_symbol msym
333 = lookup_minimal_symbol (current_program_space, running_thread_name);
334 if (!msym.minsym)
335 /* Older versions of the GNAT runtime were using a different
336 (less ideal) name for the symbol where the active thread ID
337 is stored. If we couldn't find the symbol using the latest
338 name, then try the old one. */
339 msym = lookup_minimal_symbol (current_program_space, "running_thread");
340
341 return msym;
342 }
343
344 /* Return True if the Ada Ravenscar run-time can be found in the
345 application. */
346
347 static bool
348 has_ravenscar_runtime ()
349 {
350 bound_minimal_symbol msym_ravenscar_runtime_initializer
351 = lookup_minimal_symbol (current_program_space,
352 ravenscar_runtime_initializer);
353 bound_minimal_symbol msym_known_tasks
354 = lookup_minimal_symbol (current_program_space, known_tasks_name);
355 bound_minimal_symbol msym_first_task
356 = lookup_minimal_symbol (current_program_space, first_task_name);
357 bound_minimal_symbol msym_running_thread = get_running_thread_msymbol ();
358
359 return (msym_ravenscar_runtime_initializer.minsym
360 && (msym_known_tasks.minsym || msym_first_task.minsym)
361 && msym_running_thread.minsym);
362 }
363
364 /* Return True if the Ada Ravenscar run-time can be found in the
365 application, and if it has been initialized on target. */
366
367 bool
368 ravenscar_thread_target::runtime_initialized ()
369 {
370 return active_task (1) != null_ptid;
371 }
372
373 /* Return the ID of the thread that is currently running.
374 Return 0 if the ID could not be determined. */
375
376 static CORE_ADDR
377 get_running_thread_id (int cpu)
378 {
379 bound_minimal_symbol object_msym = get_running_thread_msymbol ();
380 int object_size;
381 int buf_size;
382 gdb_byte *buf;
383 CORE_ADDR object_addr;
384 struct type *builtin_type_void_data_ptr
385 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr;
386
387 if (!object_msym.minsym)
388 return 0;
389
390 object_size = builtin_type_void_data_ptr->length ();
391 object_addr = (object_msym.value_address ()
392 + (cpu - 1) * object_size);
393 buf_size = object_size;
394 buf = (gdb_byte *) alloca (buf_size);
395 read_memory (object_addr, buf, buf_size);
396 return extract_typed_address (buf, builtin_type_void_data_ptr);
397 }
398
399 void
400 ravenscar_thread_target::resume (ptid_t ptid, int step,
401 enum gdb_signal siggnal)
402 {
403 /* If we see a wildcard resume, we simply pass that on. Otherwise,
404 arrange to resume the base ptid. */
405 inferior_ptid = m_base_ptid;
406 if (ptid.is_pid ())
407 {
408 /* We only have one process, so resume all threads of it. */
409 ptid = minus_one_ptid;
410 }
411 else if (ptid != minus_one_ptid)
412 ptid = m_base_ptid;
413 beneath ()->resume (ptid, step, siggnal);
414 }
415
416 ptid_t
417 ravenscar_thread_target::wait (ptid_t ptid,
418 struct target_waitstatus *status,
419 target_wait_flags options)
420 {
421 process_stratum_target *beneath
422 = as_process_stratum_target (this->beneath ());
423 ptid_t event_ptid;
424
425 if (ptid != minus_one_ptid)
426 ptid = m_base_ptid;
427 event_ptid = beneath->wait (ptid, status, 0);
428 /* Find any new threads that might have been created, and return the
429 active thread.
430
431 Only do it if the program is still alive, though. Otherwise,
432 this causes problems when debugging through the remote protocol,
433 because we might try switching threads (and thus sending packets)
434 after the remote has disconnected. */
435 if (status->kind () != TARGET_WAITKIND_EXITED
436 && status->kind () != TARGET_WAITKIND_SIGNALLED
437 && runtime_initialized ())
438 {
439 m_base_ptid = event_ptid;
440 this->update_thread_list ();
441 thread_info *thr = this->add_active_thread ();
442 if (thr != nullptr)
443 return thr->ptid;
444 }
445 return event_ptid;
446 }
447
448 /* Add the thread associated to the given TASK to the thread list
449 (if the thread has already been added, this is a no-op). */
450
451 void
452 ravenscar_thread_target::add_thread (struct ada_task_info *task)
453 {
454 if (current_inferior ()->find_thread (task->ptid) == NULL)
455 {
456 ::add_thread (current_inferior ()->process_target (), task->ptid);
457 m_cpu_map[task->ptid.tid ()] = task->base_cpu;
458 }
459 }
460
461 void
462 ravenscar_thread_target::update_thread_list ()
463 {
464 /* iterate_over_live_ada_tasks requires that inferior_ptid be set,
465 but this isn't always the case in target methods. So, we ensure
466 it here. */
467 scoped_restore save_ptid = make_scoped_restore (&inferior_ptid,
468 m_base_ptid);
469
470 /* Do not clear the thread list before adding the Ada task, to keep
471 the thread that the process stratum has included into it
472 (m_base_ptid) and the running thread, that may not have been included
473 to system.tasking.debug's list yet. */
474
475 iterate_over_live_ada_tasks ([this] (struct ada_task_info *task)
476 {
477 this->add_thread (task);
478 });
479 }
480
481 ptid_t
482 ravenscar_thread_target::active_task (int cpu)
483 {
484 CORE_ADDR tid = get_running_thread_id (cpu);
485
486 if (tid == 0)
487 return null_ptid;
488 else
489 return ptid_t (m_base_ptid.pid (), 0, tid);
490 }
491
492 bool
493 ravenscar_thread_target::thread_alive (ptid_t ptid)
494 {
495 /* Ravenscar tasks are non-terminating. */
496 return true;
497 }
498
499 std::string
500 ravenscar_thread_target::pid_to_str (ptid_t ptid)
501 {
502 if (!is_ravenscar_task (ptid))
503 return beneath ()->pid_to_str (ptid);
504
505 return string_printf ("Ravenscar Thread 0x%s",
506 phex_nz (ptid.tid ()));
507 }
508
509 CORE_ADDR
510 ravenscar_arch_ops::get_stack_base (struct regcache *regcache) const
511 {
512 struct gdbarch *gdbarch = regcache->arch ();
513 const int sp_regnum = gdbarch_sp_regnum (gdbarch);
514 ULONGEST stack_address;
515 regcache_cooked_read_unsigned (regcache, sp_regnum, &stack_address);
516 return (CORE_ADDR) stack_address;
517 }
518
519 void
520 ravenscar_arch_ops::supply_one_register (struct regcache *regcache,
521 int regnum,
522 CORE_ADDR descriptor,
523 CORE_ADDR stack_base) const
524 {
525 CORE_ADDR addr;
526 if (regnum >= first_stack_register && regnum <= last_stack_register)
527 addr = stack_base;
528 else
529 addr = descriptor;
530 addr += offsets[regnum];
531
532 struct gdbarch *gdbarch = regcache->arch ();
533 int size = register_size (gdbarch, regnum);
534 gdb_byte *buf = (gdb_byte *) alloca (size);
535 read_memory (addr, buf, size);
536 regcache->raw_supply (regnum, buf);
537 }
538
539 void
540 ravenscar_arch_ops::fetch_register (struct regcache *regcache,
541 int regnum) const
542 {
543 gdb_assert (regnum != -1);
544
545 struct gdbarch *gdbarch = regcache->arch ();
546 /* The tid is the thread_id field, which is a pointer to the thread. */
547 CORE_ADDR thread_descriptor_address
548 = (CORE_ADDR) regcache->ptid ().tid ();
549
550 int sp_regno = -1;
551 CORE_ADDR stack_address = 0;
552 if (regnum >= first_stack_register && regnum <= last_stack_register)
553 {
554 /* We must supply SP for get_stack_base, so recurse. */
555 sp_regno = gdbarch_sp_regnum (gdbarch);
556 gdb_assert (!(sp_regno >= first_stack_register
557 && sp_regno <= last_stack_register));
558 fetch_register (regcache, sp_regno);
559 stack_address = get_stack_base (regcache);
560 }
561
562 if (regnum < offsets.size () && offsets[regnum] != -1)
563 supply_one_register (regcache, regnum, thread_descriptor_address,
564 stack_address);
565 }
566
567 void
568 ravenscar_arch_ops::store_one_register (struct regcache *regcache, int regnum,
569 CORE_ADDR descriptor,
570 CORE_ADDR stack_base) const
571 {
572 CORE_ADDR addr;
573 if (regnum >= first_stack_register && regnum <= last_stack_register)
574 addr = stack_base;
575 else
576 addr = descriptor;
577 addr += offsets[regnum];
578
579 struct gdbarch *gdbarch = regcache->arch ();
580 int size = register_size (gdbarch, regnum);
581 gdb_byte *buf = (gdb_byte *) alloca (size);
582 regcache->raw_collect (regnum, buf);
583 write_memory (addr, buf, size);
584 }
585
586 void
587 ravenscar_arch_ops::store_register (struct regcache *regcache,
588 int regnum) const
589 {
590 gdb_assert (regnum != -1);
591
592 /* The tid is the thread_id field, which is a pointer to the thread. */
593 CORE_ADDR thread_descriptor_address
594 = (CORE_ADDR) regcache->ptid ().tid ();
595
596 CORE_ADDR stack_address = 0;
597 if (regnum >= first_stack_register && regnum <= last_stack_register)
598 stack_address = get_stack_base (regcache);
599
600 if (regnum < offsets.size () && offsets[regnum] != -1)
601 store_one_register (regcache, regnum, thread_descriptor_address,
602 stack_address);
603 }
604
605 /* Temporarily set the ptid of a regcache to some other value. When
606 this object is destroyed, the regcache's original ptid is
607 restored. */
608
609 class temporarily_change_regcache_ptid
610 {
611 public:
612
613 temporarily_change_regcache_ptid (struct regcache *regcache, ptid_t new_ptid)
614 : m_regcache (regcache),
615 m_save_ptid (regcache->ptid ())
616 {
617 m_regcache->set_ptid (new_ptid);
618 }
619
620 ~temporarily_change_regcache_ptid ()
621 {
622 m_regcache->set_ptid (m_save_ptid);
623 }
624
625 private:
626
627 /* The regcache. */
628 struct regcache *m_regcache;
629 /* The saved ptid. */
630 ptid_t m_save_ptid;
631 };
632
633 ravenscar_thread_target::fpu_state
634 ravenscar_thread_target::get_fpu_state (struct regcache *regcache,
635 const ravenscar_arch_ops *arch_ops)
636 {
637 /* We want to return true if the special FP register handling is
638 needed. If this target doesn't have lazy FP, then no special
639 treatment is ever needed. */
640 if (!arch_ops->on_demand_fp ())
641 return NOTHING_SPECIAL;
642
643 bound_minimal_symbol fpu_context
644 = lookup_minimal_symbol (current_program_space,
645 "system__bb__cpu_primitives__current_fpu_context",
646 nullptr, nullptr);
647 /* If the symbol can't be found, just fall back. */
648 if (fpu_context.minsym == nullptr)
649 return NO_FP_REGISTERS;
650
651 type *ptr_type
652 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr;
653 ptr_type = lookup_pointer_type (ptr_type);
654 value *val = value_from_pointer (ptr_type, fpu_context.value_address ());
655
656 int cpu = get_thread_base_cpu (regcache->ptid ());
657 /* The array index type has a lower bound of 1 -- it is Ada code --
658 so subtract 1 here. */
659 val = value_ptradd (val, cpu - 1);
660
661 val = value_ind (val);
662 CORE_ADDR fpu_task = value_as_long (val);
663
664 /* The tid is the thread_id field, which is a pointer to the thread. */
665 CORE_ADDR thread_descriptor_address
666 = (CORE_ADDR) regcache->ptid ().tid ();
667 if (fpu_task == (thread_descriptor_address
668 + arch_ops->get_fpu_context_offset ()))
669 return LIVE_FP_REGISTERS;
670
671 int v_init_offset = arch_ops->get_v_init_offset ();
672 gdb_byte init = 0;
673 read_memory (thread_descriptor_address + v_init_offset, &init, 1);
674 return init ? NOTHING_SPECIAL : NO_FP_REGISTERS;
675 }
676
677 void
678 ravenscar_thread_target::fetch_registers (struct regcache *regcache,
679 int regnum)
680 {
681 ptid_t ptid = regcache->ptid ();
682
683 if (runtime_initialized () && is_ravenscar_task (ptid))
684 {
685 struct gdbarch *gdbarch = regcache->arch ();
686 bool is_active = task_is_currently_active (ptid);
687 struct ravenscar_arch_ops *arch_ops = gdbarch_ravenscar_ops (gdbarch);
688 std::optional<fpu_state> fp_state;
689
690 int low_reg = regnum == -1 ? 0 : regnum;
691 int high_reg = regnum == -1 ? gdbarch_num_regs (gdbarch) : regnum + 1;
692
693 ptid_t base = get_base_thread_from_ravenscar_task (ptid);
694 for (int i = low_reg; i < high_reg; ++i)
695 {
696 bool use_beneath = false;
697 if (arch_ops->is_fp_register (i))
698 {
699 if (!fp_state.has_value ())
700 fp_state = get_fpu_state (regcache, arch_ops);
701 if (*fp_state == NO_FP_REGISTERS)
702 continue;
703 if (*fp_state == LIVE_FP_REGISTERS
704 || (is_active && *fp_state == NOTHING_SPECIAL))
705 use_beneath = true;
706 }
707 else
708 use_beneath = is_active;
709
710 if (use_beneath)
711 {
712 temporarily_change_regcache_ptid changer (regcache, base);
713 beneath ()->fetch_registers (regcache, i);
714 }
715 else
716 arch_ops->fetch_register (regcache, i);
717 }
718 }
719 else
720 beneath ()->fetch_registers (regcache, regnum);
721 }
722
723 void
724 ravenscar_thread_target::store_registers (struct regcache *regcache,
725 int regnum)
726 {
727 ptid_t ptid = regcache->ptid ();
728
729 if (runtime_initialized () && is_ravenscar_task (ptid))
730 {
731 struct gdbarch *gdbarch = regcache->arch ();
732 bool is_active = task_is_currently_active (ptid);
733 struct ravenscar_arch_ops *arch_ops = gdbarch_ravenscar_ops (gdbarch);
734 std::optional<fpu_state> fp_state;
735
736 int low_reg = regnum == -1 ? 0 : regnum;
737 int high_reg = regnum == -1 ? gdbarch_num_regs (gdbarch) : regnum + 1;
738
739 ptid_t base = get_base_thread_from_ravenscar_task (ptid);
740 for (int i = low_reg; i < high_reg; ++i)
741 {
742 bool use_beneath = false;
743 if (arch_ops->is_fp_register (i))
744 {
745 if (!fp_state.has_value ())
746 fp_state = get_fpu_state (regcache, arch_ops);
747 if (*fp_state == NO_FP_REGISTERS)
748 continue;
749 if (*fp_state == LIVE_FP_REGISTERS
750 || (is_active && *fp_state == NOTHING_SPECIAL))
751 use_beneath = true;
752 }
753 else
754 use_beneath = is_active;
755
756 if (use_beneath)
757 {
758 temporarily_change_regcache_ptid changer (regcache, base);
759 beneath ()->store_registers (regcache, i);
760 }
761 else
762 arch_ops->store_register (regcache, i);
763 }
764 }
765 else
766 beneath ()->store_registers (regcache, regnum);
767 }
768
769 void
770 ravenscar_thread_target::prepare_to_store (struct regcache *regcache)
771 {
772 ptid_t ptid = regcache->ptid ();
773
774 if (runtime_initialized () && is_ravenscar_task (ptid))
775 {
776 if (task_is_currently_active (ptid))
777 {
778 ptid_t base = get_base_thread_from_ravenscar_task (ptid);
779 temporarily_change_regcache_ptid changer (regcache, base);
780 beneath ()->prepare_to_store (regcache);
781 }
782 else
783 {
784 /* Nothing. */
785 }
786 }
787 else
788 beneath ()->prepare_to_store (regcache);
789 }
790
791 /* Implement the to_stopped_by_sw_breakpoint target_ops "method". */
792
793 bool
794 ravenscar_thread_target::stopped_by_sw_breakpoint ()
795 {
796 scoped_restore_current_thread saver;
797 set_base_thread_from_ravenscar_task (inferior_ptid);
798 return beneath ()->stopped_by_sw_breakpoint ();
799 }
800
801 /* Implement the to_stopped_by_hw_breakpoint target_ops "method". */
802
803 bool
804 ravenscar_thread_target::stopped_by_hw_breakpoint ()
805 {
806 scoped_restore_current_thread saver;
807 set_base_thread_from_ravenscar_task (inferior_ptid);
808 return beneath ()->stopped_by_hw_breakpoint ();
809 }
810
811 /* Implement the to_stopped_by_watchpoint target_ops "method". */
812
813 bool
814 ravenscar_thread_target::stopped_by_watchpoint ()
815 {
816 scoped_restore_current_thread saver;
817 set_base_thread_from_ravenscar_task (inferior_ptid);
818 return beneath ()->stopped_by_watchpoint ();
819 }
820
821 /* Implement the to_stopped_data_address target_ops "method". */
822
823 bool
824 ravenscar_thread_target::stopped_data_address (CORE_ADDR *addr_p)
825 {
826 scoped_restore_current_thread saver;
827 set_base_thread_from_ravenscar_task (inferior_ptid);
828 return beneath ()->stopped_data_address (addr_p);
829 }
830
831 void
832 ravenscar_thread_target::mourn_inferior ()
833 {
834 m_base_ptid = null_ptid;
835 target_ops *beneath = this->beneath ();
836 current_inferior ()->unpush_target (this);
837 beneath->mourn_inferior ();
838 }
839
840 /* Implement the to_core_of_thread target_ops "method". */
841
842 int
843 ravenscar_thread_target::core_of_thread (ptid_t ptid)
844 {
845 scoped_restore_current_thread saver;
846 set_base_thread_from_ravenscar_task (inferior_ptid);
847 return beneath ()->core_of_thread (inferior_ptid);
848 }
849
850 /* Implement the target xfer_partial method. */
851
852 enum target_xfer_status
853 ravenscar_thread_target::xfer_partial (enum target_object object,
854 const char *annex,
855 gdb_byte *readbuf,
856 const gdb_byte *writebuf,
857 ULONGEST offset, ULONGEST len,
858 ULONGEST *xfered_len)
859 {
860 scoped_restore save_ptid = make_scoped_restore (&inferior_ptid);
861 /* Calling get_base_thread_from_ravenscar_task can read memory from
862 the inferior. However, that function is written to prefer our
863 internal map, so it should not result in recursive calls in
864 practice. */
865 inferior_ptid = get_base_thread_from_ravenscar_task (inferior_ptid);
866 return beneath ()->xfer_partial (object, annex, readbuf, writebuf,
867 offset, len, xfered_len);
868 }
869
870 /* Observer on inferior_created: push ravenscar thread stratum if needed. */
871
872 static void
873 ravenscar_inferior_created (inferior *inf)
874 {
875 const char *err_msg;
876
877 if (!ravenscar_task_support
878 || gdbarch_ravenscar_ops (current_inferior ()->arch ()) == NULL
879 || !has_ravenscar_runtime ())
880 return;
881
882 err_msg = ada_get_tcb_types_info ();
883 if (err_msg != NULL)
884 {
885 warning (_("%s. Task/thread support disabled."), err_msg);
886 return;
887 }
888
889 ravenscar_thread_target *rtarget = new ravenscar_thread_target ();
890 inf->push_target (target_ops_up (rtarget));
891 thread_info *thr = rtarget->add_active_thread ();
892 if (thr != nullptr)
893 switch_to_thread (thr);
894 }
895
896 ptid_t
897 ravenscar_thread_target::get_ada_task_ptid (long lwp, ULONGEST thread)
898 {
899 return ptid_t (m_base_ptid.pid (), 0, thread);
900 }
901
902 /* Command-list for the "set/show ravenscar" prefix command. */
903 static struct cmd_list_element *set_ravenscar_list;
904 static struct cmd_list_element *show_ravenscar_list;
905
906 /* Implement the "show ravenscar task-switching" command. */
907
908 static void
909 show_ravenscar_task_switching_command (struct ui_file *file, int from_tty,
910 struct cmd_list_element *c,
911 const char *value)
912 {
913 if (ravenscar_task_support)
914 gdb_printf (file, _("\
915 Support for Ravenscar task/thread switching is enabled\n"));
916 else
917 gdb_printf (file, _("\
918 Support for Ravenscar task/thread switching is disabled\n"));
919 }
920
921 /* Module startup initialization function, automagically called by
922 init.c. */
923
924 INIT_GDB_FILE (ravenscar)
925 {
926 /* Notice when the inferior is created in order to push the
927 ravenscar ops if needed. */
928 gdb::observers::inferior_created.attach (ravenscar_inferior_created,
929 "ravenscar-thread");
930
931 add_setshow_prefix_cmd
932 ("ravenscar", no_class,
933 _("Prefix command for changing Ravenscar-specific settings."),
934 _("Prefix command for showing Ravenscar-specific settings."),
935 &set_ravenscar_list, &show_ravenscar_list,
936 &setlist, &showlist);
937
938 add_setshow_boolean_cmd ("task-switching", class_obscure,
939 &ravenscar_task_support, _("\
940 Enable or disable support for GNAT Ravenscar tasks."), _("\
941 Show whether support for GNAT Ravenscar tasks is enabled."),
942 _("\
943 Enable or disable support for task/thread switching with the GNAT\n\
944 Ravenscar run-time library for bareboard configuration."),
945 NULL, show_ravenscar_task_switching_command,
946 &set_ravenscar_list, &show_ravenscar_list);
947 }