gdbserver/linux-low: turn 'supports_software_single_step' and 'get_next_pcs' into...
[deliverable/binutils-gdb.git] / gdbserver / linux-low.h
CommitLineData
58caa3dc 1/* Internal interfaces for the GNU/Linux specific target code for gdbserver.
b811d2c2 2 Copyright (C) 2002-2020 Free Software Foundation, Inc.
58caa3dc
DJ
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
a9762ec7 8 the Free Software Foundation; either version 3 of the License, or
58caa3dc
DJ
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
a9762ec7 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
58caa3dc 18
1a5c2598
TT
19#ifndef GDBSERVER_LINUX_LOW_H
20#define GDBSERVER_LINUX_LOW_H
21
6d4ee8c6 22#include "nat/linux-nat.h"
125f8a3d 23#include "nat/gdb_thread_db.h"
a5362b9a 24#include <signal.h>
dae5f5cf 25
623b6bdf 26#include "gdbthread.h"
95954743
PA
27#include "gdb_proc_service.h"
28
96d7229d 29/* Included for ptrace type definitions. */
125f8a3d 30#include "nat/linux-ptrace.h"
15c66dd6 31#include "target/waitstatus.h" /* For enum target_stop_reason. */
229d26fc 32#include "tracepoint.h"
96d7229d 33
f15f9948
TJB
34#define PTRACE_XFER_TYPE long
35
58caa3dc 36#ifdef HAVE_LINUX_REGSETS
442ea881
PA
37typedef void (*regset_fill_func) (struct regcache *, void *);
38typedef void (*regset_store_func) (struct regcache *, const void *);
0d62e5e8
DJ
39enum regset_type {
40 GENERAL_REGS,
41 FP_REGS,
42 EXTENDED_REGS,
1ef53e6b 43 OPTIONAL_REGS, /* Do not error if the regset cannot be accessed. */
0d62e5e8
DJ
44};
45
50bc912a
PA
46/* The arch's regsets array initializer must be terminated with a NULL
47 regset. */
48#define NULL_REGSET \
49 { 0, 0, 0, -1, (enum regset_type) -1, NULL, NULL }
50
58caa3dc
DJ
51struct regset_info
52{
53 int get_request, set_request;
1570b33e
L
54 /* If NT_TYPE isn't 0, it will be passed to ptrace as the 3rd
55 argument and the 4th argument should be "const struct iovec *". */
56 int nt_type;
58caa3dc 57 int size;
0d62e5e8
DJ
58 enum regset_type type;
59 regset_fill_func fill_function;
60 regset_store_func store_function;
58caa3dc 61};
3aee8918
PA
62
63/* Aggregation of all the supported regsets of a given
64 architecture/mode. */
65
66struct regsets_info
67{
68 /* The regsets array. */
69 struct regset_info *regsets;
70
71 /* The number of regsets in the REGSETS array. */
72 int num_regsets;
73
74 /* If we get EIO on a regset, do not try it again. Note the set of
75 supported regsets may depend on processor mode on biarch
030031ee
PA
76 machines. This is a (lazily allocated) array holding one boolean
77 byte (0/1) per regset, with each element corresponding to the
78 regset in the REGSETS array above at the same offset. */
3aee8918
PA
79 char *disabled_regsets;
80};
81
82#endif
83
84/* Mapping between the general-purpose registers in `struct user'
85 format and GDB's register array layout. */
86
87struct usrregs_info
88{
89 /* The number of registers accessible. */
90 int num_regs;
91
92 /* The registers map. */
93 int *regmap;
94};
95
96/* All info needed to access an architecture/mode's registers. */
97
98struct regs_info
99{
100 /* Regset support bitmap: 1 for registers that are transferred as a part
101 of a regset, 0 for ones that need to be handled individually. This
102 can be NULL if all registers are transferred with regsets or regsets
103 are not supported. */
104 unsigned char *regset_bitmap;
105
106 /* Info used when accessing registers with PTRACE_PEEKUSER /
107 PTRACE_POKEUSER. This can be NULL if all registers are
108 transferred with regsets .*/
109 struct usrregs_info *usrregs;
110
111#ifdef HAVE_LINUX_REGSETS
112 /* Info used when accessing registers with regsets. */
113 struct regsets_info *regsets_info;
58caa3dc 114#endif
3aee8918 115};
2ec06d2e 116
95954743
PA
117struct process_info_private
118{
aa5ca48f
DE
119 /* Arch-specific additions. */
120 struct arch_process_info *arch_private;
cdbfd419
PP
121
122 /* libthread_db-specific additions. Not NULL if this process has loaded
123 thread_db, and it is active. */
124 struct thread_db *thread_db;
2268b414
JK
125
126 /* &_r_debug. 0 if not yet determined. -1 if no PT_DYNAMIC in Phdrs. */
127 CORE_ADDR r_debug;
95954743
PA
128};
129
aa5ca48f
DE
130struct lwp_info;
131
2ec06d2e
DJ
132struct linux_target_ops
133{
0d62e5e8
DJ
134 int decr_pc_after_break;
135 int (*breakpoint_at) (CORE_ADDR pc);
e013ee27 136
d993e290
PA
137 /* Breakpoint and watchpoint related functions. See target.h for
138 comments. */
802e8e6d
PA
139 int (*supports_z_point_type) (char z_type);
140 int (*insert_point) (enum raw_bkpt_type type, CORE_ADDR addr,
141 int size, struct raw_breakpoint *bp);
142 int (*remove_point) (enum raw_bkpt_type type, CORE_ADDR addr,
143 int size, struct raw_breakpoint *bp);
144
e013ee27
OF
145 int (*stopped_by_watchpoint) (void);
146 CORE_ADDR (*stopped_data_address) (void);
147
ee1a7ae4
UW
148 /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular
149 for registers smaller than an xfer unit). */
442ea881
PA
150 void (*collect_ptrace_register) (struct regcache *regcache,
151 int regno, char *buf);
152 void (*supply_ptrace_register) (struct regcache *regcache,
153 int regno, const char *buf);
d0722149
DE
154
155 /* Hook to convert from target format to ptrace format and back.
156 Returns true if any conversion was done; false otherwise.
157 If DIRECTION is 1, then copy from INF to NATIVE.
158 If DIRECTION is 0, copy from NATIVE to INF. */
8adce034 159 int (*siginfo_fixup) (siginfo_t *native, gdb_byte *inf, int direction);
aa5ca48f
DE
160
161 /* Hook to call when a new process is created or attached to.
162 If extra per-process architecture-specific data is needed,
163 allocate it here. */
164 struct arch_process_info * (*new_process) (void);
165
04ec7890
SM
166 /* Hook to call when a process is being deleted. If extra per-process
167 architecture-specific data is needed, delete it here. */
168 void (*delete_process) (struct arch_process_info *info);
169
aa5ca48f
DE
170 /* Hook to call when a new thread is detected.
171 If extra per-thread architecture-specific data is needed,
172 allocate it here. */
34c703da 173 void (*new_thread) (struct lwp_info *);
aa5ca48f 174
466eecee
SM
175 /* Hook to call when a thread is being deleted. If extra per-thread
176 architecture-specific data is needed, delete it here. */
177 void (*delete_thread) (struct arch_lwp_info *);
178
3a8a0396
DB
179 /* Hook to call, if any, when a new fork is attached. */
180 void (*new_fork) (struct process_info *parent, struct process_info *child);
181
aa5ca48f
DE
182 /* Hook to call prior to resuming a thread. */
183 void (*prepare_to_resume) (struct lwp_info *);
1570b33e
L
184
185 /* Hook to support target specific qSupported. */
06e03fff 186 void (*process_qsupported) (char **, int count);
219f2f23
PA
187
188 /* Returns true if the low target supports tracepoints. */
189 int (*supports_tracepoints) (void);
fa593d66
PA
190
191 /* Fill ADDRP with the thread area address of LWPID. Returns 0 on
192 success, -1 on failure. */
193 int (*get_thread_area) (int lwpid, CORE_ADDR *addrp);
194
195 /* Install a fast tracepoint jump pad. See target.h for
196 comments. */
197 int (*install_fast_tracepoint_jump_pad) (CORE_ADDR tpoint, CORE_ADDR tpaddr,
198 CORE_ADDR collector,
199 CORE_ADDR lockaddr,
200 ULONGEST orig_size,
201 CORE_ADDR *jump_entry,
405f8e94
SS
202 CORE_ADDR *trampoline,
203 ULONGEST *trampoline_size,
fa593d66
PA
204 unsigned char *jjump_pad_insn,
205 ULONGEST *jjump_pad_insn_size,
206 CORE_ADDR *adjusted_insn_addr,
405f8e94
SS
207 CORE_ADDR *adjusted_insn_addr_end,
208 char *err);
6a271cae
PA
209
210 /* Return the bytecode operations vector for the current inferior.
211 Returns NULL if bytecode compilation is not supported. */
212 struct emit_ops *(*emit_ops) (void);
405f8e94
SS
213
214 /* Return the minimum length of an instruction that can be safely overwritten
215 for use as a fast tracepoint. */
216 int (*get_min_fast_tracepoint_insn_len) (void);
217
c2d6af84
PA
218 /* Returns true if the low target supports range stepping. */
219 int (*supports_range_stepping) (void);
769ef81f 220
7d00775e
AT
221 /* See target.h. */
222 int (*supports_hardware_single_step) (void);
82075af2 223
4cc32bec
YQ
224 /* Fill *SYSNO with the syscall nr trapped. Only to be called when
225 inferior is stopped due to SYSCALL_SIGTRAP. */
226 void (*get_syscall_trapinfo) (struct regcache *regcache, int *sysno);
ae91f625
MK
227
228 /* See target.h. */
229 int (*get_ipa_tdesc_idx) (void);
2ec06d2e
DJ
230};
231
232extern struct linux_target_ops the_low_target;
0d62e5e8 233
5ef9273d
TBA
234/* Target ops definitions for a Linux target. */
235
52405d85 236class linux_process_target : public process_stratum_target
5ef9273d
TBA
237{
238public:
239
15295543
TBA
240 int create_inferior (const char *program,
241 const std::vector<char *> &program_args) override;
6dee9afb
TBA
242
243 void post_create_inferior () override;
ef03dad8
TBA
244
245 int attach (unsigned long pid) override;
c6885a57
TBA
246
247 int kill (process_info *proc) override;
9061c9cf
TBA
248
249 int detach (process_info *proc) override;
8adb37b9
TBA
250
251 void mourn (process_info *proc) override;
95a49a39
TBA
252
253 void join (int pid) override;
13d3d99b
TBA
254
255 bool thread_alive (ptid_t pid) override;
0e4d7e35
TBA
256
257 void resume (thread_resume *resume_info, size_t n) override;
6532e7e3
TBA
258
259 ptid_t wait (ptid_t ptid, target_waitstatus *status,
260 int options) override;
a5a4d4cd
TBA
261
262 void fetch_registers (regcache *regcache, int regno) override;
263
264 void store_registers (regcache *regcache, int regno) override;
79b44087
TBA
265
266 int prepare_to_access_memory () override;
267
268 void done_accessing_memory () override;
e2558df3
TBA
269
270 int read_memory (CORE_ADDR memaddr, unsigned char *myaddr,
271 int len) override;
272
273 int write_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
274 int len) override;
2a31c7aa
TBA
275
276 void look_up_symbols () override;
eb497a2a
TBA
277
278 void request_interrupt () override;
eac215cc
TBA
279
280 bool supports_read_auxv () override;
281
282 int read_auxv (CORE_ADDR offset, unsigned char *myaddr,
283 unsigned int len) override;
a2b2297a
TBA
284
285 bool supports_z_point_type (char z_type) override;
7e0bde70
TBA
286
287 int insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
288 int size, raw_breakpoint *bp) override;
289
290 int remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
291 int size, raw_breakpoint *bp) override;
84320c4e
TBA
292
293 bool stopped_by_sw_breakpoint () override;
294
295 bool supports_stopped_by_sw_breakpoint () override;
93fe88b2
TBA
296
297 bool stopped_by_hw_breakpoint () override;
298
299 bool supports_stopped_by_hw_breakpoint () override;
22aa6223
TBA
300
301 bool supports_hardware_single_step () override;
6eeb5c55
TBA
302
303 bool stopped_by_watchpoint () override;
304
305 CORE_ADDR stopped_data_address () override;
5203ae1e
TBA
306
307 bool supports_read_offsets () override;
308
309 int read_offsets (CORE_ADDR *text, CORE_ADDR *data) override;
6e3fd7e9
TBA
310
311 bool supports_get_tls_address () override;
312
313 int get_tls_address (thread_info *thread, CORE_ADDR offset,
314 CORE_ADDR load_module, CORE_ADDR *address) override;
2d0795ee
TBA
315
316 bool supports_qxfer_osdata () override;
317
318 int qxfer_osdata (const char *annex, unsigned char *readbuf,
319 unsigned const char *writebuf,
320 CORE_ADDR offset, int len) override;
d7abedf7
TBA
321
322 bool supports_qxfer_siginfo () override;
323
324 int qxfer_siginfo (const char *annex, unsigned char *readbuf,
325 unsigned const char *writebuf,
326 CORE_ADDR offset, int len) override;
0dc587d4
TBA
327
328 bool supports_non_stop () override;
329
330 bool async (bool enable) override;
331
332 int start_non_stop (bool enable) override;
652aef77
TBA
333
334 bool supports_multi_process () override;
9690a72a
TBA
335
336 bool supports_fork_events () override;
337
338 bool supports_vfork_events () override;
339
340 bool supports_exec_events () override;
fb00dfce
TBA
341
342 void handle_new_gdb_connection () override;
55cf3021
TBA
343
344 int handle_monitor_command (char *mon) override;
95a45fc1
TBA
345
346 int core_of_thread (ptid_t ptid) override;
9da41fda
TBA
347
348#if defined PT_GETDSBT || defined PTRACE_GETFDPIC
349 bool supports_read_loadmap () override;
350
351 int read_loadmap (const char *annex, CORE_ADDR offset,
352 unsigned char *myaddr, unsigned int len) override;
353#endif
0df28b1b
TBA
354
355 void process_qsupported (char **features, int count) override;
290732bf
TBA
356
357 bool supports_tracepoints () override;
770d8f6a
TBA
358
359 CORE_ADDR read_pc (regcache *regcache) override;
360
361 void write_pc (regcache *regcache, CORE_ADDR pc) override;
68119632
TBA
362
363 bool supports_thread_stopped () override;
364
365 bool thread_stopped (thread_info *thread) override;
29e8dc09
TBA
366
367 void pause_all (bool freeze) override;
368
369 void unpause_all (bool unfreeze) override;
5c9eb2f2
TBA
370
371 void stabilize_threads () override;
c23c9391
TBA
372
373 bool supports_fast_tracepoints () override;
374
375 int install_fast_tracepoint_jump_pad (CORE_ADDR tpoint,
376 CORE_ADDR tpaddr,
377 CORE_ADDR collector,
378 CORE_ADDR lockaddr,
379 ULONGEST orig_size,
380 CORE_ADDR *jump_entry,
381 CORE_ADDR *trampoline,
382 ULONGEST *trampoline_size,
383 unsigned char *jjump_pad_insn,
384 ULONGEST *jjump_pad_insn_size,
385 CORE_ADDR *adjusted_insn_addr,
386 CORE_ADDR *adjusted_insn_addr_end,
387 char *err) override;
388
389 int get_min_fast_tracepoint_insn_len () override;
345dafad
TBA
390
391 struct emit_ops *emit_ops () override;
c756403b
TBA
392
393 bool supports_disable_randomization () override;
974387bb
TBA
394
395 bool supports_qxfer_libraries_svr4 () override;
396
397 int qxfer_libraries_svr4 (const char *annex,
398 unsigned char *readbuf,
399 unsigned const char *writebuf,
400 CORE_ADDR offset, int len) override;
c0245cb9
TBA
401
402 bool supports_agent () override;
79597bdd
TBA
403
404#ifdef HAVE_LINUX_BTRACE
405 btrace_target_info *enable_btrace (ptid_t ptid,
406 const btrace_config *conf) override;
407
408 int disable_btrace (btrace_target_info *tinfo) override;
409
410 int read_btrace (btrace_target_info *tinfo, buffer *buf,
411 enum btrace_read_type type) override;
412
413 int read_btrace_conf (const btrace_target_info *tinfo,
414 buffer *buf) override;
415#endif
2526e0cd
TBA
416
417 bool supports_range_stepping () override;
8247b823
TBA
418
419 bool supports_pid_to_exec_file () override;
420
421 char *pid_to_exec_file (int pid) override;
c9b7b804
TBA
422
423 bool supports_multifs () override;
424
425 int multifs_open (int pid, const char *filename, int flags,
426 mode_t mode) override;
427
428 int multifs_unlink (int pid, const char *filename) override;
429
430 ssize_t multifs_readlink (int pid, const char *filename, char *buf,
431 size_t bufsiz) override;
d367006f 432
7f63b89b
TBA
433 const char *thread_name (ptid_t thread) override;
434
435#if USE_THREAD_DB
436 bool thread_handle (ptid_t ptid, gdb_byte **handle,
437 int *handle_len) override;
438#endif
5303a34f 439
bc8d3ae4 440 bool supports_catch_syscall () override;
d633e831
TBA
441
442 int get_ipa_tdesc_idx () override;
d16f3f6c 443
aa8d21c9
TBA
444 /* Return the information to access registers. This has public
445 visibility because proc-service uses it. */
446 virtual const regs_info *get_regs_info () = 0;
447
d16f3f6c
TBA
448private:
449
450 /* Handle a GNU/Linux extended wait response. If we see a clone,
451 fork, or vfork event, we need to add the new LWP to our list
452 (and return 0 so as not to report the trap to higher layers).
453 If we see an exec event, we will modify ORIG_EVENT_LWP to point
454 to a new LWP representing the new program. */
455 int handle_extended_wait (lwp_info **orig_event_lwp, int wstat);
456
457 /* Do low-level handling of the event, and check if we should go on
458 and pass it to caller code. Return the affected lwp if we are, or
459 NULL otherwise. */
460 lwp_info *filter_event (int lwpid, int wstat);
461
462 /* Wait for an event from child(ren) WAIT_PTID, and return any that
463 match FILTER_PTID (leaving others pending). The PTIDs can be:
464 minus_one_ptid, to specify any child; a pid PTID, specifying all
465 lwps of a thread group; or a PTID representing a single lwp. Store
466 the stop status through the status pointer WSTAT. OPTIONS is
467 passed to the waitpid call. Return 0 if no event was found and
468 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
469 was found. Return the PID of the stopped child otherwise. */
470 int wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
471 int *wstatp, int options);
472
473 /* Wait for an event from child(ren) PTID. PTIDs can be:
474 minus_one_ptid, to specify any child; a pid PTID, specifying all
475 lwps of a thread group; or a PTID representing a single lwp. Store
476 the stop status through the status pointer WSTAT. OPTIONS is
477 passed to the waitpid call. Return 0 if no event was found and
478 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
479 was found. Return the PID of the stopped child otherwise. */
480 int wait_for_event (ptid_t ptid, int *wstatp, int options);
481
482 /* Wait for all children to stop for the SIGSTOPs we just queued. */
483 void wait_for_sigstop ();
484
485 /* Wait for process, returns status. */
486 ptid_t wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
487 int target_options);
488
489 /* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
490 If SUSPEND, then also increase the suspend count of every LWP,
491 except EXCEPT. */
492 void stop_all_lwps (int suspend, lwp_info *except);
493
494 /* Stopped LWPs that the client wanted to be running, that don't have
495 pending statuses, are set to run again, except for EXCEPT, if not
496 NULL. This undoes a stop_all_lwps call. */
497 void unstop_all_lwps (int unsuspend, lwp_info *except);
498
499 /* Start a step-over operation on LWP. When LWP stopped at a
500 breakpoint, to make progress, we need to remove the breakpoint out
501 of the way. If we let other threads run while we do that, they may
502 pass by the breakpoint location and miss hitting it. To avoid
503 that, a step-over momentarily stops all threads while LWP is
504 single-stepped by either hardware or software while the breakpoint
505 is temporarily uninserted from the inferior. When the single-step
506 finishes, we reinsert the breakpoint, and let all threads that are
507 supposed to be running, run again. */
508 void start_step_over (lwp_info *lwp);
509
510 /* If there's a step over in progress, wait until all threads stop
511 (that is, until the stepping thread finishes its step), and
512 unsuspend all lwps. The stepping thread ends with its status
513 pending, which is processed later when we get back to processing
514 events. */
515 void complete_ongoing_step_over ();
516
517 /* When we finish a step-over, set threads running again. If there's
518 another thread that may need a step-over, now's the time to start
519 it. Eventually, we'll move all threads past their breakpoints. */
520 void proceed_all_lwps ();
521
522 /* The reason we resume in the caller, is because we want to be able
523 to pass lwp->status_pending as WSTAT, and we need to clear
524 status_pending_p before resuming, otherwise, resume_one_lwp
525 refuses to resume. */
526 bool maybe_move_out_of_jump_pad (lwp_info *lwp, int *wstat);
527
528 /* Move THREAD out of the jump pad. */
529 void move_out_of_jump_pad (thread_info *thread);
ef0478f6 530
797bcff5
TBA
531 /* Call low_arch_setup on THREAD. */
532 void arch_setup_thread (thread_info *thread);
533
daca57a7
TBA
534#ifdef HAVE_LINUX_USRREGS
535 /* Fetch one register. */
536 void fetch_register (const usrregs_info *usrregs, regcache *regcache,
537 int regno);
538
539 /* Store one register. */
540 void store_register (const usrregs_info *usrregs, regcache *regcache,
541 int regno);
542#endif
543
544 /* Fetch all registers, or just one, from the child process.
545 If REGNO is -1, do this for all registers, skipping any that are
546 assumed to have been retrieved by regsets_fetch_inferior_registers,
547 unless ALL is non-zero.
548 Otherwise, REGNO specifies which register (so we can save time). */
549 void usr_fetch_inferior_registers (const regs_info *regs_info,
550 regcache *regcache, int regno, int all);
551
552 /* Store our register values back into the inferior.
553 If REGNO is -1, do this for all registers, skipping any that are
554 assumed to have been saved by regsets_store_inferior_registers,
555 unless ALL is non-zero.
556 Otherwise, REGNO specifies which register (so we can save time). */
557 void usr_store_inferior_registers (const regs_info *regs_info,
558 regcache *regcache, int regno, int all);
559
df95181f
TBA
560 /* Return the PC as read from the regcache of LWP, without any
561 adjustment. */
562 CORE_ADDR get_pc (lwp_info *lwp);
563
564 /* Called when the LWP stopped for a signal/trap. If it stopped for a
565 trap check what caused it (breakpoint, watchpoint, trace, etc.),
566 and save the result in the LWP's stop_reason field. If it stopped
567 for a breakpoint, decrement the PC if necessary on the lwp's
568 architecture. Returns true if we now have the LWP's stop PC. */
569 bool save_stop_reason (lwp_info *lwp);
570
571 /* Resume execution of LWP. If STEP is nonzero, single-step it. If
572 SIGNAL is nonzero, give it that signal. */
573 void resume_one_lwp_throw (lwp_info *lwp, int step, int signal,
574 siginfo_t *info);
575
576 /* Like resume_one_lwp_throw, but no error is thrown if the LWP
577 disappears while we try to resume it. */
578 void resume_one_lwp (lwp_info *lwp, int step, int signal, siginfo_t *info);
579
580 /* This function is called once per thread. We check the thread's
581 last resume request, which will tell us whether to resume, step, or
582 leave the thread stopped. Any signal the client requested to be
583 delivered has already been enqueued at this point.
584
585 If any thread that GDB wants running is stopped at an internal
586 breakpoint that needs stepping over, we start a step-over operation
587 on that particular thread, and leave all others stopped. */
588 void proceed_one_lwp (thread_info *thread, lwp_info *except);
589
590 /* This function is called once per thread. We check the thread's
591 resume request, which will tell us whether to resume, step, or
592 leave the thread stopped; and what signal, if any, it should be
593 sent.
594
595 For threads which we aren't explicitly told otherwise, we preserve
596 the stepping flag; this is used for stepping over gdbserver-placed
597 breakpoints.
598
599 If pending_flags was set in any thread, we queue any needed
600 signals, since we won't actually resume. We already have a pending
601 event to report, so we don't need to preserve any step requests;
602 they should be re-issued if necessary. */
603 void resume_one_thread (thread_info *thread, bool leave_all_stopped);
604
605 /* Return true if this lwp has an interesting status pending. */
606 bool status_pending_p_callback (thread_info *thread, ptid_t ptid);
607
608 /* Resume LWPs that are currently stopped without any pending status
609 to report, but are resumed from the core's perspective. */
610 void resume_stopped_resumed_lwps (thread_info *thread);
611
612 /* Unsuspend THREAD, except EXCEPT, and proceed. */
613 void unsuspend_and_proceed_one_lwp (thread_info *thread, lwp_info *except);
614
615 /* Return true if this lwp still has an interesting status pending.
616 If not (e.g., it had stopped for a breakpoint that is gone), return
617 false. */
618 bool thread_still_has_status_pending (thread_info *thread);
619
620 /* Return true if this lwp is to-be-resumed and has an interesting
621 status pending. */
622 bool resume_status_pending (thread_info *thread);
623
624 /* Return true if this lwp that GDB wants running is stopped at an
625 internal breakpoint that we need to step over. It assumes that
626 any required STOP_PC adjustment has already been propagated to
627 the inferior's regcache. */
628 bool thread_needs_step_over (thread_info *thread);
629
630 /* Single step via hardware or software single step.
631 Return 1 if hardware single stepping, 0 if software single stepping
632 or can't single step. */
633 int single_step (lwp_info* lwp);
634
635 /* Install breakpoints for software single stepping. */
636 void install_software_single_step_breakpoints (lwp_info *lwp);
637
ef0478f6
TBA
638protected:
639 /* The architecture-specific "low" methods are listed below. */
797bcff5
TBA
640
641 /* Architecture-specific setup for the current thread. */
642 virtual void low_arch_setup () = 0;
daca57a7
TBA
643
644 /* Return false if we can fetch/store the register, true if we cannot
645 fetch/store the register. */
646 virtual bool low_cannot_fetch_register (int regno) = 0;
647
648 virtual bool low_cannot_store_register (int regno) = 0;
bd70b1f2
TBA
649
650 /* Hook to fetch a register in some non-standard way. Used for
651 example by backends that have read-only registers with hardcoded
652 values (e.g., IA64's gr0/fr0/fr1). Returns true if register
653 REGNO was supplied, false if not, and we should fallback to the
654 standard ptrace methods. */
655 virtual bool low_fetch_register (regcache *regcache, int regno);
bf9ae9d8
TBA
656
657 /* Return true if breakpoints are supported. Such targets must
658 implement the GET_PC and SET_PC methods. */
659 virtual bool low_supports_breakpoints ();
660
661 virtual CORE_ADDR low_get_pc (regcache *regcache);
662
663 virtual void low_set_pc (regcache *regcache, CORE_ADDR newpc);
7582c77c
TBA
664
665 /* Find the next possible PCs after the current instruction executes.
666 Targets that override this method should also override
667 'supports_software_single_step' to return true. */
668 virtual std::vector<CORE_ADDR> low_get_next_pcs (regcache *regcache);
5ef9273d
TBA
669};
670
ef0478f6
TBA
671extern linux_process_target *the_linux_target;
672
6afd337d 673#define get_thread_lwp(thr) ((struct lwp_info *) (thread_target_data (thr)))
f7667f0d 674#define get_lwp_thread(lwp) ((lwp)->thread)
0d62e5e8 675
d86d4aaf
DE
676/* This struct is recorded in the target_data field of struct thread_info.
677
678 On linux ``all_threads'' is keyed by the LWP ID, which we use as the
679 GDB protocol representation of the thread ID. Threads also have
680 a "process ID" (poorly named) which is (presently) the same as the
681 LWP ID.
682
683 There is also ``all_processes'' is keyed by the "overall process ID",
684 which GNU/Linux calls tgid, "thread group ID". */
685
54a0b537 686struct lwp_info
0d62e5e8 687{
d86d4aaf 688 /* Backlink to the parent object. */
f7667f0d
DE
689 struct thread_info *thread;
690
ae13219e
DJ
691 /* If this flag is set, the next SIGSTOP will be ignored (the
692 process will be immediately resumed). This means that either we
693 sent the SIGSTOP to it ourselves and got some other pending event
694 (so the SIGSTOP is still pending), or that we stopped the
695 inferior implicitly via PTRACE_ATTACH and have not waited for it
696 yet. */
0d62e5e8
DJ
697 int stop_expected;
698
d50171e4
PA
699 /* When this is true, we shall not try to resume this thread, even
700 if last_resume_kind isn't resume_stop. */
bd99dc85
PA
701 int suspended;
702
703 /* If this flag is set, the lwp is known to be stopped right now (stop
0d62e5e8
DJ
704 event already received in a wait()). */
705 int stopped;
706
82075af2
JS
707 /* Signal whether we are in a SYSCALL_ENTRY or
708 in a SYSCALL_RETURN event.
709 Values:
710 - TARGET_WAITKIND_SYSCALL_ENTRY
711 - TARGET_WAITKIND_SYSCALL_RETURN */
712 enum target_waitkind syscall_state;
713
bd99dc85 714 /* When stopped is set, the last wait status recorded for this lwp. */
32ca6d61
DJ
715 int last_status;
716
00db26fa
PA
717 /* If WAITSTATUS->KIND != TARGET_WAITKIND_IGNORE, the waitstatus for
718 this LWP's last event, to pass to GDB without any further
719 processing. This is used to store extended ptrace event
720 information or exit status until it can be reported to GDB. */
de0d863e
DB
721 struct target_waitstatus waitstatus;
722
5a04c4cf
PA
723 /* A pointer to the fork child/parent relative. Valid only while
724 the parent fork event is not reported to higher layers. Used to
725 avoid wildcard vCont actions resuming a fork child before GDB is
726 notified about the parent's fork event. */
727 struct lwp_info *fork_relative;
728
582511be
PA
729 /* When stopped is set, this is where the lwp last stopped, with
730 decr_pc_after_break already accounted for. If the LWP is
731 running, this is the address at which the lwp was resumed. */
d50171e4
PA
732 CORE_ADDR stop_pc;
733
0d62e5e8
DJ
734 /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
735 been reported. */
736 int status_pending_p;
737 int status_pending;
738
582511be
PA
739 /* The reason the LWP last stopped, if we need to track it
740 (breakpoint, watchpoint, etc.) */
15c66dd6 741 enum target_stop_reason stop_reason;
c3adc08c
PA
742
743 /* On architectures where it is possible to know the data address of
744 a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
745 contains such data address. Only valid if STOPPED_BY_WATCHPOINT
746 is true. */
747 CORE_ADDR stopped_data_address;
748
0d62e5e8
DJ
749 /* If this is non-zero, it is a breakpoint to be reinserted at our next
750 stop (SIGTRAP stops only). */
751 CORE_ADDR bp_reinsert;
752
d50171e4
PA
753 /* If this flag is set, the last continue operation at the ptrace
754 level on this process was a single-step. */
0d62e5e8
DJ
755 int stepping;
756
c2d6af84
PA
757 /* Range to single step within. This is a copy of the step range
758 passed along the last resume request. See 'struct
759 thread_resume'. */
760 CORE_ADDR step_range_start; /* Inclusive */
761 CORE_ADDR step_range_end; /* Exclusive */
762
a6dbe5df
PA
763 /* If this flag is set, we need to set the event request flags the
764 next time we see this LWP stop. */
765 int must_set_ptrace_flags;
766
0d62e5e8
DJ
767 /* If this is non-zero, it points to a chain of signals which need to
768 be delivered to this process. */
769 struct pending_signals *pending_signals;
5544ad89
DJ
770
771 /* A link used when resuming. It is initialized from the resume request,
54a0b537 772 and then processed and cleared in linux_resume_one_lwp. */
5544ad89 773 struct thread_resume *resume;
dae5f5cf 774
229d26fc
SM
775 /* Information bout this lwp's fast tracepoint collection status (is it
776 currently stopped in the jump pad, and if so, before or at/after the
777 relocated instruction). Normally, we won't care about this, but we will
778 if a signal arrives to this lwp while it is collecting. */
779 fast_tpoint_collect_result collecting_fast_tracepoint;
fa593d66
PA
780
781 /* If this is non-zero, it points to a chain of signals which need
782 to be reported to GDB. These were deferred because the thread
783 was doing a fast tracepoint collect when they arrived. */
784 struct pending_signals *pending_signals_to_report;
785
786 /* When collecting_fast_tracepoint is first found to be 1, we insert
787 a exit-jump-pad-quickly breakpoint. This is it. */
788 struct breakpoint *exit_jump_pad_bkpt;
789
04f5fe89 790#ifdef USE_THREAD_DB
d5c93e41 791 int thread_known;
24a09b5f
DJ
792 /* The thread handle, used for e.g. TLS access. Only valid if
793 THREAD_KNOWN is set. */
dae5f5cf 794 td_thrhandle_t th;
f6327dcb
KB
795
796 /* The pthread_t handle. */
797 thread_t thread_handle;
dae5f5cf 798#endif
aa5ca48f
DE
799
800 /* Arch-specific additions. */
801 struct arch_lwp_info *arch_private;
0d62e5e8 802};
5544ad89 803
214d508e 804int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine);
d0722149 805
7ae1a6a6
PA
806/* Attach to PTID. Returns 0 on success, non-zero otherwise (an
807 errno). */
808int linux_attach_lwp (ptid_t ptid);
809
cdbfd419 810struct lwp_info *find_lwp_pid (ptid_t ptid);
b2f7c7e8 811/* For linux_stop_lwp see nat/linux-nat.h. */
0d62e5e8 812
3aee8918
PA
813#ifdef HAVE_LINUX_REGSETS
814void initialize_regsets_info (struct regsets_info *regsets_info);
815#endif
816
817void initialize_low_arch (void);
818
276d4552
YQ
819void linux_set_pc_32bit (struct regcache *regcache, CORE_ADDR pc);
820CORE_ADDR linux_get_pc_32bit (struct regcache *regcache);
821
6f69e520
YQ
822void linux_set_pc_64bit (struct regcache *regcache, CORE_ADDR pc);
823CORE_ADDR linux_get_pc_64bit (struct regcache *regcache);
824
cdbfd419 825/* From thread-db.c */
9b4c5f87 826int thread_db_init (void);
8336d594
PA
827void thread_db_detach (struct process_info *);
828void thread_db_mourn (struct process_info *);
cdbfd419 829int thread_db_handle_monitor_command (char *);
dae5f5cf
DJ
830int thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
831 CORE_ADDR load_module, CORE_ADDR *address);
9836d6ea 832int thread_db_look_up_one_symbol (const char *name, CORE_ADDR *addrp);
ded48a5e 833
86299109
KB
834/* Called from linux-low.c when a clone event is detected. Upon entry,
835 both the clone and the parent should be stopped. This function does
836 whatever is required have the clone under thread_db's control. */
837
94c207e0 838void thread_db_notice_clone (struct thread_info *parent_thr, ptid_t child_ptid);
86299109 839
f6327dcb
KB
840bool thread_db_thread_handle (ptid_t ptid, gdb_byte **handle, int *handle_len);
841
ded48a5e 842extern int have_ptrace_getregset;
1a5c2598 843
0570503d
PFC
844/* Search for the value with type MATCH in the auxv vector with
845 entries of length WORDSIZE bytes. If found, store the value in
846 *VALP and return 1. If not found or if there is an error, return
847 0. */
848
849int linux_get_auxv (int wordsize, CORE_ADDR match,
850 CORE_ADDR *valp);
851
974c89e0
AH
852/* Fetch the AT_HWCAP entry from the auxv vector, where entries are length
853 WORDSIZE. If no entry was found, return zero. */
854
855CORE_ADDR linux_get_hwcap (int wordsize);
856
857/* Fetch the AT_HWCAP2 entry from the auxv vector, where entries are length
858 WORDSIZE. If no entry was found, return zero. */
859
860CORE_ADDR linux_get_hwcap2 (int wordsize);
861
1a5c2598 862#endif /* GDBSERVER_LINUX_LOW_H */
This page took 1.847235 seconds and 4 git commands to generate.