[ARC] Fix typo in extension instruction name.
[deliverable/binutils-gdb.git] / gdb / linux-nat.h
1 /* Native debugging support for GNU/Linux (LWP layer).
2
3 Copyright (C) 2000-2016 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 "nat/linux-nat.h"
21 #include "target.h"
22 #include <signal.h>
23
24 struct arch_lwp_info;
25
26 /* Structure describing an LWP. This is public only for the purposes
27 of ALL_LWPS; target-specific code should generally not access it
28 directly. */
29
30 struct lwp_info
31 {
32 /* The process id of the LWP. This is a combination of the LWP id
33 and overall process id. */
34 ptid_t ptid;
35
36 /* If this flag is set, we need to set the event request flags the
37 next time we see this LWP stop. */
38 int must_set_ptrace_flags;
39
40 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report
41 it back yet). */
42 int signalled;
43
44 /* Non-zero if this LWP is stopped. */
45 int stopped;
46
47 /* Non-zero if this LWP will be/has been resumed. Note that an LWP
48 can be marked both as stopped and resumed at the same time. This
49 happens if we try to resume an LWP that has a wait status
50 pending. We shouldn't let the LWP run until that wait status has
51 been processed, but we should not report that wait status if GDB
52 didn't try to let the LWP run. */
53 int resumed;
54
55 /* The last resume GDB requested on this thread. */
56 enum resume_kind last_resume_kind;
57
58 /* If non-zero, a pending wait status. */
59 int status;
60
61 /* When 'stopped' is set, this is where the lwp last stopped, with
62 decr_pc_after_break already accounted for. If the LWP is
63 running, and stepping, this is the address at which the lwp was
64 resumed (that is, it's the previous stop PC). If the LWP is
65 running and not stepping, this is 0. */
66 CORE_ADDR stop_pc;
67
68 /* Non-zero if we were stepping this LWP. */
69 int step;
70
71 /* The reason the LWP last stopped, if we need to track it
72 (breakpoint, watchpoint, etc.) */
73 enum target_stop_reason stop_reason;
74
75 /* On architectures where it is possible to know the data address of
76 a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and
77 STOPPED_DATA_ADDRESS contains such data address. Otherwise,
78 STOPPED_DATA_ADDRESS_P is false, and STOPPED_DATA_ADDRESS is
79 undefined. Only valid if STOPPED_BY_WATCHPOINT is true. */
80 int stopped_data_address_p;
81 CORE_ADDR stopped_data_address;
82
83 /* Non-zero if we expect a duplicated SIGINT. */
84 int ignore_sigint;
85
86 /* If WAITSTATUS->KIND != TARGET_WAITKIND_SPURIOUS, the waitstatus
87 for this LWP's last event. This may correspond to STATUS above,
88 or to a local variable in lin_lwp_wait. */
89 struct target_waitstatus waitstatus;
90
91 /* Signal whether we are in a SYSCALL_ENTRY or
92 in a SYSCALL_RETURN event.
93 Values:
94 - TARGET_WAITKIND_SYSCALL_ENTRY
95 - TARGET_WAITKIND_SYSCALL_RETURN */
96 enum target_waitkind syscall_state;
97
98 /* The processor core this LWP was last seen on. */
99 int core;
100
101 /* Arch-specific additions. */
102 struct arch_lwp_info *arch_private;
103
104 /* Next LWP in list. */
105 struct lwp_info *next;
106 };
107
108 /* The global list of LWPs, for ALL_LWPS. Unlike the threads list,
109 there is always at least one LWP on the list while the GNU/Linux
110 native target is active. */
111 extern struct lwp_info *lwp_list;
112
113 /* Does the current host support PTRACE_GETREGSET? */
114 extern enum tribool have_ptrace_getregset;
115
116 /* Iterate over each active thread (light-weight process). */
117 #define ALL_LWPS(LP) \
118 for ((LP) = lwp_list; \
119 (LP) != NULL; \
120 (LP) = (LP)->next)
121
122 /* Attempt to initialize libthread_db. */
123 void check_for_thread_db (void);
124
125 /* Called from the LWP layer to inform the thread_db layer that PARENT
126 spawned CHILD. Both LWPs are currently stopped. This function
127 does whatever is required to have the child LWP under the
128 thread_db's control --- e.g., enabling event reporting. Returns
129 true on success, false if the process isn't using libpthread. */
130 extern int thread_db_notice_clone (ptid_t parent, ptid_t child);
131
132 /* Return the set of signals used by the threads library. */
133 extern void lin_thread_get_thread_signals (sigset_t *mask);
134
135 /* Find process PID's pending signal set from /proc/pid/status. */
136 void linux_proc_pending_signals (int pid, sigset_t *pending,
137 sigset_t *blocked, sigset_t *ignored);
138
139 /* For linux_stop_lwp see nat/linux-nat.h. */
140
141 /* Stop all LWPs, synchronously. (Any events that trigger while LWPs
142 are being stopped are left pending.) */
143 extern void linux_stop_and_wait_all_lwps (void);
144
145 /* Set resumed LWPs running again, as they were before being stopped
146 with linux_stop_and_wait_all_lwps. (LWPS with pending events are
147 left stopped.) */
148 extern void linux_unstop_all_lwps (void);
149
150 /* Create a prototype generic GNU/Linux target. The client can
151 override it with local methods. */
152 struct target_ops * linux_target (void);
153
154 /* Create a generic GNU/Linux target using traditional
155 ptrace register access. */
156 struct target_ops *
157 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int));
158
159 /* Register the customized GNU/Linux target. This should be used
160 instead of calling add_target directly. */
161 void linux_nat_add_target (struct target_ops *);
162
163 /* Register a method to call whenever a new thread is attached. */
164 void linux_nat_set_new_thread (struct target_ops *, void (*) (struct lwp_info *));
165
166
167 /* Register a method to call whenever a new fork is attached. */
168 typedef void (linux_nat_new_fork_ftype) (struct lwp_info *parent,
169 pid_t child_pid);
170 void linux_nat_set_new_fork (struct target_ops *ops,
171 linux_nat_new_fork_ftype *fn);
172
173 /* Register a method to call whenever a process is killed or
174 detached. */
175 typedef void (linux_nat_forget_process_ftype) (pid_t pid);
176 void linux_nat_set_forget_process (struct target_ops *ops,
177 linux_nat_forget_process_ftype *fn);
178
179 /* Call the method registered with the function above. PID is the
180 process to forget about. */
181 void linux_nat_forget_process (pid_t pid);
182
183 /* Register a method that converts a siginfo object between the layout
184 that ptrace returns, and the layout in the architecture of the
185 inferior. */
186 void linux_nat_set_siginfo_fixup (struct target_ops *,
187 int (*) (siginfo_t *,
188 gdb_byte *,
189 int));
190
191 /* Register a method to call prior to resuming a thread. */
192
193 void linux_nat_set_prepare_to_resume (struct target_ops *,
194 void (*) (struct lwp_info *));
195
196 /* Update linux-nat internal state when changing from one fork
197 to another. */
198 void linux_nat_switch_fork (ptid_t new_ptid);
199
200 /* Store the saved siginfo associated with PTID in *SIGINFO.
201 Return 1 if it was retrieved successfully, 0 otherwise (*SIGINFO is
202 uninitialized in such case). */
203 int linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo);
204
205 /* Set alternative SIGTRAP-like events recognizer. */
206 void linux_nat_set_status_is_event (struct target_ops *t,
207 int (*status_is_event) (int status));
This page took 0.032967 seconds and 4 git commands to generate.