Commit | Line | Data |
---|---|---|
fb08a90b MK |
1 | /* Target-dependent code for OpenBSD. |
2 | ||
ecd75fc8 | 3 | Copyright (C) 2005-2014 Free Software Foundation, Inc. |
fb08a90b MK |
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 | |
a9762ec7 | 9 | the Free Software Foundation; either version 3 of the License, or |
fb08a90b MK |
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 | |
a9762ec7 | 18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
fb08a90b MK |
19 | |
20 | #include "defs.h" | |
21 | #include "frame.h" | |
22 | #include "symtab.h" | |
23 | ||
24 | #include "obsd-tdep.h" | |
25 | ||
26 | CORE_ADDR | |
27 | obsd_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc) | |
28 | { | |
29 | struct minimal_symbol *msym; | |
30 | ||
31 | msym = lookup_minimal_symbol("_dl_bind", NULL, NULL); | |
32 | if (msym && SYMBOL_VALUE_ADDRESS (msym) == pc) | |
c7ce8faa | 33 | return frame_unwind_caller_pc (get_current_frame ()); |
fb08a90b | 34 | else |
52f729a7 | 35 | return find_solib_trampoline_target (get_current_frame (), pc); |
fb08a90b | 36 | } |
93ffa5b9 MK |
37 | |
38 | /* OpenBSD signal numbers. From <sys/signal.h>. */ | |
39 | ||
40 | enum | |
41 | { | |
42 | OBSD_SIGHUP = 1, | |
43 | OBSD_SIGINT = 2, | |
44 | OBSD_SIGQUIT = 3, | |
45 | OBSD_SIGILL = 4, | |
46 | OBSD_SIGTRAP = 5, | |
47 | OBSD_SIGABRT = 6, | |
48 | OBSD_SIGEMT = 7, | |
49 | OBSD_SIGFPE = 8, | |
50 | OBSD_SIGKILL = 9, | |
51 | OBSD_SIGBUS = 10, | |
52 | OBSD_SIGSEGV = 11, | |
53 | OBSD_SIGSYS = 12, | |
54 | OBSD_SIGPIPE = 13, | |
55 | OBSD_SIGALRM = 14, | |
56 | OBSD_SIGTERM = 15, | |
57 | OBSD_SIGURG = 16, | |
58 | OBSD_SIGSTOP = 17, | |
59 | OBSD_SIGTSTP = 18, | |
60 | OBSD_SIGCONT = 19, | |
61 | OBSD_SIGCHLD = 20, | |
62 | OBSD_SIGTTIN = 21, | |
63 | OBSD_SIGTTOU = 22, | |
64 | OBSD_SIGIO = 23, | |
65 | OBSD_SIGXCPU = 24, | |
66 | OBSD_SIGXFSZ = 25, | |
67 | OBSD_SIGVTALRM = 26, | |
68 | OBSD_SIGPROF = 27, | |
69 | OBSD_SIGWINCH = 28, | |
70 | OBSD_SIGINFO = 29, | |
71 | OBSD_SIGUSR1 = 30, | |
72 | OBSD_SIGUSR2 = 31, | |
73 | OBSD_SIGTHR = 32, | |
74 | }; | |
75 | ||
76 | /* Implement the "gdb_signal_from_target" gdbarch method. */ | |
77 | ||
78 | static enum gdb_signal | |
79 | obsd_gdb_signal_from_target (struct gdbarch *gdbarch, int signal) | |
80 | { | |
81 | switch (signal) | |
82 | { | |
83 | case 0: | |
84 | return GDB_SIGNAL_0; | |
85 | ||
86 | case OBSD_SIGHUP: | |
87 | return GDB_SIGNAL_HUP; | |
88 | ||
89 | case OBSD_SIGINT: | |
90 | return GDB_SIGNAL_INT; | |
91 | ||
92 | case OBSD_SIGQUIT: | |
93 | return GDB_SIGNAL_QUIT; | |
94 | ||
95 | case OBSD_SIGILL: | |
96 | return GDB_SIGNAL_ILL; | |
97 | ||
98 | case OBSD_SIGTRAP: | |
99 | return GDB_SIGNAL_TRAP; | |
100 | ||
101 | case OBSD_SIGABRT: | |
102 | return GDB_SIGNAL_ABRT; | |
103 | ||
104 | case OBSD_SIGEMT: | |
105 | return GDB_SIGNAL_EMT; | |
106 | ||
107 | case OBSD_SIGFPE: | |
108 | return GDB_SIGNAL_FPE; | |
109 | ||
110 | case OBSD_SIGKILL: | |
111 | return GDB_SIGNAL_KILL; | |
112 | ||
113 | case OBSD_SIGBUS: | |
114 | return GDB_SIGNAL_BUS; | |
115 | ||
116 | case OBSD_SIGSEGV: | |
117 | return GDB_SIGNAL_SEGV; | |
118 | ||
119 | case OBSD_SIGSYS: | |
120 | return GDB_SIGNAL_SYS; | |
121 | ||
122 | case OBSD_SIGPIPE: | |
123 | return GDB_SIGNAL_PIPE; | |
124 | ||
125 | case OBSD_SIGALRM: | |
126 | return GDB_SIGNAL_ALRM; | |
127 | ||
128 | case OBSD_SIGTERM: | |
129 | return GDB_SIGNAL_TERM; | |
130 | ||
131 | case OBSD_SIGURG: | |
132 | return GDB_SIGNAL_URG; | |
133 | ||
134 | case OBSD_SIGSTOP: | |
135 | return GDB_SIGNAL_STOP; | |
136 | ||
137 | case OBSD_SIGTSTP: | |
138 | return GDB_SIGNAL_TSTP; | |
139 | ||
140 | case OBSD_SIGCONT: | |
141 | return GDB_SIGNAL_CONT; | |
142 | ||
143 | case OBSD_SIGCHLD: | |
144 | return GDB_SIGNAL_CHLD; | |
145 | ||
146 | case OBSD_SIGTTIN: | |
147 | return GDB_SIGNAL_TTIN; | |
148 | ||
149 | case OBSD_SIGTTOU: | |
150 | return GDB_SIGNAL_TTOU; | |
151 | ||
152 | case OBSD_SIGIO: | |
153 | return GDB_SIGNAL_IO; | |
154 | ||
155 | case OBSD_SIGXCPU: | |
156 | return GDB_SIGNAL_XCPU; | |
157 | ||
158 | case OBSD_SIGXFSZ: | |
159 | return GDB_SIGNAL_XFSZ; | |
160 | ||
161 | case OBSD_SIGVTALRM: | |
162 | return GDB_SIGNAL_VTALRM; | |
163 | ||
164 | case OBSD_SIGPROF: | |
165 | return GDB_SIGNAL_PROF; | |
166 | ||
167 | case OBSD_SIGWINCH: | |
168 | return GDB_SIGNAL_WINCH; | |
169 | ||
170 | case OBSD_SIGINFO: | |
171 | return GDB_SIGNAL_INFO; | |
172 | ||
173 | case OBSD_SIGUSR1: | |
174 | return GDB_SIGNAL_USR1; | |
175 | ||
176 | case OBSD_SIGUSR2: | |
177 | return GDB_SIGNAL_USR2; | |
178 | } | |
179 | ||
180 | return GDB_SIGNAL_UNKNOWN; | |
181 | } | |
182 | ||
183 | /* Implement the "gdb_signal_to_target" gdbarch method. */ | |
184 | ||
185 | static int | |
186 | obsd_gdb_signal_to_target (struct gdbarch *gdbarch, | |
187 | enum gdb_signal signal) | |
188 | { | |
189 | switch (signal) | |
190 | { | |
191 | case GDB_SIGNAL_0: | |
192 | return 0; | |
193 | ||
194 | case GDB_SIGNAL_HUP: | |
195 | return OBSD_SIGHUP; | |
196 | ||
197 | case GDB_SIGNAL_INT: | |
198 | return OBSD_SIGINT; | |
199 | ||
200 | case GDB_SIGNAL_QUIT: | |
201 | return OBSD_SIGQUIT; | |
202 | ||
203 | case GDB_SIGNAL_ILL: | |
204 | return OBSD_SIGILL; | |
205 | ||
206 | case GDB_SIGNAL_TRAP: | |
207 | return OBSD_SIGTRAP; | |
208 | ||
209 | case GDB_SIGNAL_ABRT: | |
210 | return OBSD_SIGABRT; | |
211 | ||
212 | case GDB_SIGNAL_EMT: | |
213 | return OBSD_SIGEMT; | |
214 | ||
215 | case GDB_SIGNAL_FPE: | |
216 | return OBSD_SIGFPE; | |
217 | ||
218 | case GDB_SIGNAL_KILL: | |
219 | return OBSD_SIGKILL; | |
220 | ||
221 | case GDB_SIGNAL_BUS: | |
222 | return OBSD_SIGBUS; | |
223 | ||
224 | case GDB_SIGNAL_SEGV: | |
225 | return OBSD_SIGSEGV; | |
226 | ||
227 | case GDB_SIGNAL_SYS: | |
228 | return OBSD_SIGSYS; | |
229 | ||
230 | case GDB_SIGNAL_PIPE: | |
231 | return OBSD_SIGPIPE; | |
232 | ||
233 | case GDB_SIGNAL_ALRM: | |
234 | return OBSD_SIGALRM; | |
235 | ||
236 | case GDB_SIGNAL_TERM: | |
237 | return OBSD_SIGTERM; | |
238 | ||
239 | case GDB_SIGNAL_URG: | |
240 | return OBSD_SIGURG; | |
241 | ||
242 | case GDB_SIGNAL_STOP: | |
243 | return OBSD_SIGSTOP; | |
244 | ||
245 | case GDB_SIGNAL_TSTP: | |
246 | return OBSD_SIGTSTP; | |
247 | ||
248 | case GDB_SIGNAL_CONT: | |
249 | return OBSD_SIGCONT; | |
250 | ||
251 | case GDB_SIGNAL_CHLD: | |
252 | return OBSD_SIGCHLD; | |
253 | ||
254 | case GDB_SIGNAL_TTIN: | |
255 | return OBSD_SIGTTIN; | |
256 | ||
257 | case GDB_SIGNAL_TTOU: | |
258 | return OBSD_SIGTTOU; | |
259 | ||
260 | case GDB_SIGNAL_IO: | |
261 | return OBSD_SIGIO; | |
262 | ||
263 | case GDB_SIGNAL_XCPU: | |
264 | return OBSD_SIGXCPU; | |
265 | ||
266 | case GDB_SIGNAL_XFSZ: | |
267 | return OBSD_SIGXFSZ; | |
268 | ||
269 | case GDB_SIGNAL_VTALRM: | |
270 | return OBSD_SIGVTALRM; | |
271 | ||
272 | case GDB_SIGNAL_PROF: | |
273 | return OBSD_SIGPROF; | |
274 | ||
275 | case GDB_SIGNAL_WINCH: | |
276 | return OBSD_SIGWINCH; | |
277 | ||
278 | case GDB_SIGNAL_USR1: | |
279 | return OBSD_SIGUSR1; | |
280 | ||
281 | case GDB_SIGNAL_USR2: | |
282 | return OBSD_SIGUSR2; | |
283 | ||
284 | case GDB_SIGNAL_INFO: | |
285 | return OBSD_SIGINFO; | |
286 | } | |
287 | ||
288 | return -1; | |
289 | } | |
290 | ||
291 | ||
292 | void | |
293 | obsd_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) | |
294 | { | |
295 | set_gdbarch_gdb_signal_from_target (gdbarch, | |
296 | obsd_gdb_signal_from_target); | |
297 | set_gdbarch_gdb_signal_to_target (gdbarch, | |
298 | obsd_gdb_signal_to_target); | |
299 | } |