Commit | Line | Data |
---|---|---|
0150732f DJ |
1 | /* Target signal translation functions for GDB. |
2 | Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, | |
3 | 2000, 2001 Free Software Foundation, Inc. | |
4 | Contributed by Cygnus Support. | |
5 | ||
6 | This file is part of GDB. | |
7 | ||
8 | This program is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 2 of the License, or | |
11 | (at your option) any later version. | |
12 | ||
13 | This program is distributed in the hope that it will be useful, | |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
17 | ||
18 | You should have received a copy of the GNU General Public License | |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 59 Temple Place - Suite 330, | |
21 | Boston, MA 02111-1307, USA. */ | |
22 | ||
23 | #include "defs.h" | |
24 | #include "target.h" | |
25 | #include <signal.h> | |
26 | ||
27 | /* This table must match in order and size the signals in enum target_signal | |
28 | in target.h. */ | |
29 | /* *INDENT-OFF* */ | |
30 | static struct { | |
31 | char *name; | |
32 | char *string; | |
33 | } signals [] = | |
34 | { | |
35 | {"0", "Signal 0"}, | |
36 | {"SIGHUP", "Hangup"}, | |
37 | {"SIGINT", "Interrupt"}, | |
38 | {"SIGQUIT", "Quit"}, | |
39 | {"SIGILL", "Illegal instruction"}, | |
40 | {"SIGTRAP", "Trace/breakpoint trap"}, | |
41 | {"SIGABRT", "Aborted"}, | |
42 | {"SIGEMT", "Emulation trap"}, | |
43 | {"SIGFPE", "Arithmetic exception"}, | |
44 | {"SIGKILL", "Killed"}, | |
45 | {"SIGBUS", "Bus error"}, | |
46 | {"SIGSEGV", "Segmentation fault"}, | |
47 | {"SIGSYS", "Bad system call"}, | |
48 | {"SIGPIPE", "Broken pipe"}, | |
49 | {"SIGALRM", "Alarm clock"}, | |
50 | {"SIGTERM", "Terminated"}, | |
51 | {"SIGURG", "Urgent I/O condition"}, | |
52 | {"SIGSTOP", "Stopped (signal)"}, | |
53 | {"SIGTSTP", "Stopped (user)"}, | |
54 | {"SIGCONT", "Continued"}, | |
55 | {"SIGCHLD", "Child status changed"}, | |
56 | {"SIGTTIN", "Stopped (tty input)"}, | |
57 | {"SIGTTOU", "Stopped (tty output)"}, | |
58 | {"SIGIO", "I/O possible"}, | |
59 | {"SIGXCPU", "CPU time limit exceeded"}, | |
60 | {"SIGXFSZ", "File size limit exceeded"}, | |
61 | {"SIGVTALRM", "Virtual timer expired"}, | |
62 | {"SIGPROF", "Profiling timer expired"}, | |
63 | {"SIGWINCH", "Window size changed"}, | |
64 | {"SIGLOST", "Resource lost"}, | |
65 | {"SIGUSR1", "User defined signal 1"}, | |
66 | {"SIGUSR2", "User defined signal 2"}, | |
67 | {"SIGPWR", "Power fail/restart"}, | |
68 | {"SIGPOLL", "Pollable event occurred"}, | |
69 | {"SIGWIND", "SIGWIND"}, | |
70 | {"SIGPHONE", "SIGPHONE"}, | |
71 | {"SIGWAITING", "Process's LWPs are blocked"}, | |
72 | {"SIGLWP", "Signal LWP"}, | |
73 | {"SIGDANGER", "Swap space dangerously low"}, | |
74 | {"SIGGRANT", "Monitor mode granted"}, | |
75 | {"SIGRETRACT", "Need to relinquish monitor mode"}, | |
76 | {"SIGMSG", "Monitor mode data available"}, | |
77 | {"SIGSOUND", "Sound completed"}, | |
78 | {"SIGSAK", "Secure attention"}, | |
79 | {"SIGPRIO", "SIGPRIO"}, | |
80 | {"SIG33", "Real-time event 33"}, | |
81 | {"SIG34", "Real-time event 34"}, | |
82 | {"SIG35", "Real-time event 35"}, | |
83 | {"SIG36", "Real-time event 36"}, | |
84 | {"SIG37", "Real-time event 37"}, | |
85 | {"SIG38", "Real-time event 38"}, | |
86 | {"SIG39", "Real-time event 39"}, | |
87 | {"SIG40", "Real-time event 40"}, | |
88 | {"SIG41", "Real-time event 41"}, | |
89 | {"SIG42", "Real-time event 42"}, | |
90 | {"SIG43", "Real-time event 43"}, | |
91 | {"SIG44", "Real-time event 44"}, | |
92 | {"SIG45", "Real-time event 45"}, | |
93 | {"SIG46", "Real-time event 46"}, | |
94 | {"SIG47", "Real-time event 47"}, | |
95 | {"SIG48", "Real-time event 48"}, | |
96 | {"SIG49", "Real-time event 49"}, | |
97 | {"SIG50", "Real-time event 50"}, | |
98 | {"SIG51", "Real-time event 51"}, | |
99 | {"SIG52", "Real-time event 52"}, | |
100 | {"SIG53", "Real-time event 53"}, | |
101 | {"SIG54", "Real-time event 54"}, | |
102 | {"SIG55", "Real-time event 55"}, | |
103 | {"SIG56", "Real-time event 56"}, | |
104 | {"SIG57", "Real-time event 57"}, | |
105 | {"SIG58", "Real-time event 58"}, | |
106 | {"SIG59", "Real-time event 59"}, | |
107 | {"SIG60", "Real-time event 60"}, | |
108 | {"SIG61", "Real-time event 61"}, | |
109 | {"SIG62", "Real-time event 62"}, | |
110 | {"SIG63", "Real-time event 63"}, | |
111 | {"SIGCANCEL", "LWP internal signal"}, | |
112 | {"SIG32", "Real-time event 32"}, | |
113 | {"SIG64", "Real-time event 64"}, | |
114 | {"SIG65", "Real-time event 65"}, | |
115 | {"SIG66", "Real-time event 66"}, | |
116 | {"SIG67", "Real-time event 67"}, | |
117 | {"SIG68", "Real-time event 68"}, | |
118 | {"SIG69", "Real-time event 69"}, | |
119 | {"SIG70", "Real-time event 70"}, | |
120 | {"SIG71", "Real-time event 71"}, | |
121 | {"SIG72", "Real-time event 72"}, | |
122 | {"SIG73", "Real-time event 73"}, | |
123 | {"SIG74", "Real-time event 74"}, | |
124 | {"SIG75", "Real-time event 75"}, | |
125 | {"SIG76", "Real-time event 76"}, | |
126 | {"SIG77", "Real-time event 77"}, | |
127 | {"SIG78", "Real-time event 78"}, | |
128 | {"SIG79", "Real-time event 79"}, | |
129 | {"SIG80", "Real-time event 80"}, | |
130 | {"SIG81", "Real-time event 81"}, | |
131 | {"SIG82", "Real-time event 82"}, | |
132 | {"SIG83", "Real-time event 83"}, | |
133 | {"SIG84", "Real-time event 84"}, | |
134 | {"SIG85", "Real-time event 85"}, | |
135 | {"SIG86", "Real-time event 86"}, | |
136 | {"SIG87", "Real-time event 87"}, | |
137 | {"SIG88", "Real-time event 88"}, | |
138 | {"SIG89", "Real-time event 89"}, | |
139 | {"SIG90", "Real-time event 90"}, | |
140 | {"SIG91", "Real-time event 91"}, | |
141 | {"SIG92", "Real-time event 92"}, | |
142 | {"SIG93", "Real-time event 93"}, | |
143 | {"SIG94", "Real-time event 94"}, | |
144 | {"SIG95", "Real-time event 95"}, | |
145 | {"SIG96", "Real-time event 96"}, | |
146 | {"SIG97", "Real-time event 97"}, | |
147 | {"SIG98", "Real-time event 98"}, | |
148 | {"SIG99", "Real-time event 99"}, | |
149 | {"SIG100", "Real-time event 100"}, | |
150 | {"SIG101", "Real-time event 101"}, | |
151 | {"SIG102", "Real-time event 102"}, | |
152 | {"SIG103", "Real-time event 103"}, | |
153 | {"SIG104", "Real-time event 104"}, | |
154 | {"SIG105", "Real-time event 105"}, | |
155 | {"SIG106", "Real-time event 106"}, | |
156 | {"SIG107", "Real-time event 107"}, | |
157 | {"SIG108", "Real-time event 108"}, | |
158 | {"SIG109", "Real-time event 109"}, | |
159 | {"SIG110", "Real-time event 110"}, | |
160 | {"SIG111", "Real-time event 111"}, | |
161 | {"SIG112", "Real-time event 112"}, | |
162 | {"SIG113", "Real-time event 113"}, | |
163 | {"SIG114", "Real-time event 114"}, | |
164 | {"SIG115", "Real-time event 115"}, | |
165 | {"SIG116", "Real-time event 116"}, | |
166 | {"SIG117", "Real-time event 117"}, | |
167 | {"SIG118", "Real-time event 118"}, | |
168 | {"SIG119", "Real-time event 119"}, | |
169 | {"SIG120", "Real-time event 120"}, | |
170 | {"SIG121", "Real-time event 121"}, | |
171 | {"SIG122", "Real-time event 122"}, | |
172 | {"SIG123", "Real-time event 123"}, | |
173 | {"SIG124", "Real-time event 124"}, | |
174 | {"SIG125", "Real-time event 125"}, | |
175 | {"SIG126", "Real-time event 126"}, | |
176 | {"SIG127", "Real-time event 127"}, | |
177 | ||
178 | #if defined(MACH) || defined(__MACH__) | |
179 | /* Mach exceptions */ | |
180 | {"EXC_BAD_ACCESS", "Could not access memory"}, | |
181 | {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"}, | |
182 | {"EXC_ARITHMETIC", "Arithmetic exception"}, | |
183 | {"EXC_EMULATION", "Emulation instruction"}, | |
184 | {"EXC_SOFTWARE", "Software generated exception"}, | |
185 | {"EXC_BREAKPOINT", "Breakpoint"}, | |
186 | #endif | |
187 | {"SIGINFO", "Information request"}, | |
188 | ||
189 | {NULL, "Unknown signal"}, | |
190 | {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"}, | |
191 | ||
192 | /* Last entry, used to check whether the table is the right size. */ | |
193 | {NULL, "TARGET_SIGNAL_MAGIC"} | |
194 | }; | |
195 | /* *INDENT-ON* */ | |
196 | ||
197 | ||
198 | ||
199 | /* Return the string for a signal. */ | |
200 | char * | |
201 | target_signal_to_string (enum target_signal sig) | |
202 | { | |
203 | if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST)) | |
204 | return signals[sig].string; | |
205 | else | |
206 | return signals[TARGET_SIGNAL_UNKNOWN].string; | |
207 | } | |
208 | ||
209 | /* Return the name for a signal. */ | |
210 | char * | |
211 | target_signal_to_name (enum target_signal sig) | |
212 | { | |
213 | if (sig == TARGET_SIGNAL_UNKNOWN) | |
214 | /* I think the code which prints this will always print it along with | |
215 | the string, so no need to be verbose. */ | |
216 | return "?"; | |
217 | return signals[sig].name; | |
218 | } | |
219 | ||
220 | /* Given a name, return its signal. */ | |
221 | enum target_signal | |
222 | target_signal_from_name (char *name) | |
223 | { | |
224 | enum target_signal sig; | |
225 | ||
226 | /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD" | |
227 | for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more | |
228 | questionable; seems like by now people should call it SIGABRT | |
229 | instead. */ | |
230 | ||
231 | /* This ugly cast brought to you by the native VAX compiler. */ | |
232 | for (sig = TARGET_SIGNAL_HUP; | |
233 | signals[sig].name != NULL; | |
234 | sig = (enum target_signal) ((int) sig + 1)) | |
235 | if (STREQ (name, signals[sig].name)) | |
236 | return sig; | |
237 | return TARGET_SIGNAL_UNKNOWN; | |
238 | } | |
239 | \f | |
240 | /* The following functions are to help certain targets deal | |
241 | with the signal/waitstatus stuff. They could just as well be in | |
242 | a file called native-utils.c or unixwaitstatus-utils.c or whatever. */ | |
243 | ||
244 | /* Convert host signal to our signals. */ | |
245 | enum target_signal | |
246 | target_signal_from_host (int hostsig) | |
247 | { | |
248 | /* A switch statement would make sense but would require special kludges | |
249 | to deal with the cases where more than one signal has the same number. */ | |
250 | ||
251 | if (hostsig == 0) | |
252 | return TARGET_SIGNAL_0; | |
253 | ||
254 | #if defined (SIGHUP) | |
255 | if (hostsig == SIGHUP) | |
256 | return TARGET_SIGNAL_HUP; | |
257 | #endif | |
258 | #if defined (SIGINT) | |
259 | if (hostsig == SIGINT) | |
260 | return TARGET_SIGNAL_INT; | |
261 | #endif | |
262 | #if defined (SIGQUIT) | |
263 | if (hostsig == SIGQUIT) | |
264 | return TARGET_SIGNAL_QUIT; | |
265 | #endif | |
266 | #if defined (SIGILL) | |
267 | if (hostsig == SIGILL) | |
268 | return TARGET_SIGNAL_ILL; | |
269 | #endif | |
270 | #if defined (SIGTRAP) | |
271 | if (hostsig == SIGTRAP) | |
272 | return TARGET_SIGNAL_TRAP; | |
273 | #endif | |
274 | #if defined (SIGABRT) | |
275 | if (hostsig == SIGABRT) | |
276 | return TARGET_SIGNAL_ABRT; | |
277 | #endif | |
278 | #if defined (SIGEMT) | |
279 | if (hostsig == SIGEMT) | |
280 | return TARGET_SIGNAL_EMT; | |
281 | #endif | |
282 | #if defined (SIGFPE) | |
283 | if (hostsig == SIGFPE) | |
284 | return TARGET_SIGNAL_FPE; | |
285 | #endif | |
286 | #if defined (SIGKILL) | |
287 | if (hostsig == SIGKILL) | |
288 | return TARGET_SIGNAL_KILL; | |
289 | #endif | |
290 | #if defined (SIGBUS) | |
291 | if (hostsig == SIGBUS) | |
292 | return TARGET_SIGNAL_BUS; | |
293 | #endif | |
294 | #if defined (SIGSEGV) | |
295 | if (hostsig == SIGSEGV) | |
296 | return TARGET_SIGNAL_SEGV; | |
297 | #endif | |
298 | #if defined (SIGSYS) | |
299 | if (hostsig == SIGSYS) | |
300 | return TARGET_SIGNAL_SYS; | |
301 | #endif | |
302 | #if defined (SIGPIPE) | |
303 | if (hostsig == SIGPIPE) | |
304 | return TARGET_SIGNAL_PIPE; | |
305 | #endif | |
306 | #if defined (SIGALRM) | |
307 | if (hostsig == SIGALRM) | |
308 | return TARGET_SIGNAL_ALRM; | |
309 | #endif | |
310 | #if defined (SIGTERM) | |
311 | if (hostsig == SIGTERM) | |
312 | return TARGET_SIGNAL_TERM; | |
313 | #endif | |
314 | #if defined (SIGUSR1) | |
315 | if (hostsig == SIGUSR1) | |
316 | return TARGET_SIGNAL_USR1; | |
317 | #endif | |
318 | #if defined (SIGUSR2) | |
319 | if (hostsig == SIGUSR2) | |
320 | return TARGET_SIGNAL_USR2; | |
321 | #endif | |
322 | #if defined (SIGCLD) | |
323 | if (hostsig == SIGCLD) | |
324 | return TARGET_SIGNAL_CHLD; | |
325 | #endif | |
326 | #if defined (SIGCHLD) | |
327 | if (hostsig == SIGCHLD) | |
328 | return TARGET_SIGNAL_CHLD; | |
329 | #endif | |
330 | #if defined (SIGPWR) | |
331 | if (hostsig == SIGPWR) | |
332 | return TARGET_SIGNAL_PWR; | |
333 | #endif | |
334 | #if defined (SIGWINCH) | |
335 | if (hostsig == SIGWINCH) | |
336 | return TARGET_SIGNAL_WINCH; | |
337 | #endif | |
338 | #if defined (SIGURG) | |
339 | if (hostsig == SIGURG) | |
340 | return TARGET_SIGNAL_URG; | |
341 | #endif | |
342 | #if defined (SIGIO) | |
343 | if (hostsig == SIGIO) | |
344 | return TARGET_SIGNAL_IO; | |
345 | #endif | |
346 | #if defined (SIGPOLL) | |
347 | if (hostsig == SIGPOLL) | |
348 | return TARGET_SIGNAL_POLL; | |
349 | #endif | |
350 | #if defined (SIGSTOP) | |
351 | if (hostsig == SIGSTOP) | |
352 | return TARGET_SIGNAL_STOP; | |
353 | #endif | |
354 | #if defined (SIGTSTP) | |
355 | if (hostsig == SIGTSTP) | |
356 | return TARGET_SIGNAL_TSTP; | |
357 | #endif | |
358 | #if defined (SIGCONT) | |
359 | if (hostsig == SIGCONT) | |
360 | return TARGET_SIGNAL_CONT; | |
361 | #endif | |
362 | #if defined (SIGTTIN) | |
363 | if (hostsig == SIGTTIN) | |
364 | return TARGET_SIGNAL_TTIN; | |
365 | #endif | |
366 | #if defined (SIGTTOU) | |
367 | if (hostsig == SIGTTOU) | |
368 | return TARGET_SIGNAL_TTOU; | |
369 | #endif | |
370 | #if defined (SIGVTALRM) | |
371 | if (hostsig == SIGVTALRM) | |
372 | return TARGET_SIGNAL_VTALRM; | |
373 | #endif | |
374 | #if defined (SIGPROF) | |
375 | if (hostsig == SIGPROF) | |
376 | return TARGET_SIGNAL_PROF; | |
377 | #endif | |
378 | #if defined (SIGXCPU) | |
379 | if (hostsig == SIGXCPU) | |
380 | return TARGET_SIGNAL_XCPU; | |
381 | #endif | |
382 | #if defined (SIGXFSZ) | |
383 | if (hostsig == SIGXFSZ) | |
384 | return TARGET_SIGNAL_XFSZ; | |
385 | #endif | |
386 | #if defined (SIGWIND) | |
387 | if (hostsig == SIGWIND) | |
388 | return TARGET_SIGNAL_WIND; | |
389 | #endif | |
390 | #if defined (SIGPHONE) | |
391 | if (hostsig == SIGPHONE) | |
392 | return TARGET_SIGNAL_PHONE; | |
393 | #endif | |
394 | #if defined (SIGLOST) | |
395 | if (hostsig == SIGLOST) | |
396 | return TARGET_SIGNAL_LOST; | |
397 | #endif | |
398 | #if defined (SIGWAITING) | |
399 | if (hostsig == SIGWAITING) | |
400 | return TARGET_SIGNAL_WAITING; | |
401 | #endif | |
402 | #if defined (SIGCANCEL) | |
403 | if (hostsig == SIGCANCEL) | |
404 | return TARGET_SIGNAL_CANCEL; | |
405 | #endif | |
406 | #if defined (SIGLWP) | |
407 | if (hostsig == SIGLWP) | |
408 | return TARGET_SIGNAL_LWP; | |
409 | #endif | |
410 | #if defined (SIGDANGER) | |
411 | if (hostsig == SIGDANGER) | |
412 | return TARGET_SIGNAL_DANGER; | |
413 | #endif | |
414 | #if defined (SIGGRANT) | |
415 | if (hostsig == SIGGRANT) | |
416 | return TARGET_SIGNAL_GRANT; | |
417 | #endif | |
418 | #if defined (SIGRETRACT) | |
419 | if (hostsig == SIGRETRACT) | |
420 | return TARGET_SIGNAL_RETRACT; | |
421 | #endif | |
422 | #if defined (SIGMSG) | |
423 | if (hostsig == SIGMSG) | |
424 | return TARGET_SIGNAL_MSG; | |
425 | #endif | |
426 | #if defined (SIGSOUND) | |
427 | if (hostsig == SIGSOUND) | |
428 | return TARGET_SIGNAL_SOUND; | |
429 | #endif | |
430 | #if defined (SIGSAK) | |
431 | if (hostsig == SIGSAK) | |
432 | return TARGET_SIGNAL_SAK; | |
433 | #endif | |
434 | #if defined (SIGPRIO) | |
435 | if (hostsig == SIGPRIO) | |
436 | return TARGET_SIGNAL_PRIO; | |
437 | #endif | |
438 | ||
439 | /* Mach exceptions. Assumes that the values for EXC_ are positive! */ | |
440 | #if defined (EXC_BAD_ACCESS) && defined (_NSIG) | |
441 | if (hostsig == _NSIG + EXC_BAD_ACCESS) | |
442 | return TARGET_EXC_BAD_ACCESS; | |
443 | #endif | |
444 | #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) | |
445 | if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) | |
446 | return TARGET_EXC_BAD_INSTRUCTION; | |
447 | #endif | |
448 | #if defined (EXC_ARITHMETIC) && defined (_NSIG) | |
449 | if (hostsig == _NSIG + EXC_ARITHMETIC) | |
450 | return TARGET_EXC_ARITHMETIC; | |
451 | #endif | |
452 | #if defined (EXC_EMULATION) && defined (_NSIG) | |
453 | if (hostsig == _NSIG + EXC_EMULATION) | |
454 | return TARGET_EXC_EMULATION; | |
455 | #endif | |
456 | #if defined (EXC_SOFTWARE) && defined (_NSIG) | |
457 | if (hostsig == _NSIG + EXC_SOFTWARE) | |
458 | return TARGET_EXC_SOFTWARE; | |
459 | #endif | |
460 | #if defined (EXC_BREAKPOINT) && defined (_NSIG) | |
461 | if (hostsig == _NSIG + EXC_BREAKPOINT) | |
462 | return TARGET_EXC_BREAKPOINT; | |
463 | #endif | |
464 | ||
465 | #if defined (SIGINFO) | |
466 | if (hostsig == SIGINFO) | |
467 | return TARGET_SIGNAL_INFO; | |
468 | #endif | |
469 | ||
470 | #if defined (REALTIME_LO) | |
471 | if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) | |
472 | { | |
473 | /* This block of TARGET_SIGNAL_REALTIME value is in order. */ | |
474 | if (33 <= hostsig && hostsig <= 63) | |
475 | return (enum target_signal) | |
476 | (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); | |
477 | else if (hostsig == 32) | |
478 | return TARGET_SIGNAL_REALTIME_32; | |
479 | else if (64 <= hostsig && hostsig <= 127) | |
480 | return (enum target_signal) | |
481 | (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64); | |
482 | else | |
483 | error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal"); | |
484 | } | |
485 | #endif | |
486 | ||
487 | #if defined (SIGRTMIN) | |
488 | if (hostsig >= SIGRTMIN && hostsig <= SIGRTMAX) | |
489 | { | |
490 | /* This block of TARGET_SIGNAL_REALTIME value is in order. */ | |
491 | if (33 <= hostsig && hostsig <= 63) | |
492 | return (enum target_signal) | |
493 | (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); | |
494 | else if (hostsig == 64) | |
495 | return TARGET_SIGNAL_REALTIME_64; | |
496 | else | |
497 | error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal"); | |
498 | } | |
499 | #endif | |
500 | return TARGET_SIGNAL_UNKNOWN; | |
501 | } | |
502 | ||
503 | /* Convert a OURSIG (an enum target_signal) to the form used by the | |
504 | target operating system (refered to as the ``host'') or zero if the | |
505 | equivalent host signal is not available. Set/clear OURSIG_OK | |
506 | accordingly. */ | |
507 | ||
508 | static int | |
509 | do_target_signal_to_host (enum target_signal oursig, | |
510 | int *oursig_ok) | |
511 | { | |
512 | *oursig_ok = 1; | |
513 | switch (oursig) | |
514 | { | |
515 | case TARGET_SIGNAL_0: | |
516 | return 0; | |
517 | ||
518 | #if defined (SIGHUP) | |
519 | case TARGET_SIGNAL_HUP: | |
520 | return SIGHUP; | |
521 | #endif | |
522 | #if defined (SIGINT) | |
523 | case TARGET_SIGNAL_INT: | |
524 | return SIGINT; | |
525 | #endif | |
526 | #if defined (SIGQUIT) | |
527 | case TARGET_SIGNAL_QUIT: | |
528 | return SIGQUIT; | |
529 | #endif | |
530 | #if defined (SIGILL) | |
531 | case TARGET_SIGNAL_ILL: | |
532 | return SIGILL; | |
533 | #endif | |
534 | #if defined (SIGTRAP) | |
535 | case TARGET_SIGNAL_TRAP: | |
536 | return SIGTRAP; | |
537 | #endif | |
538 | #if defined (SIGABRT) | |
539 | case TARGET_SIGNAL_ABRT: | |
540 | return SIGABRT; | |
541 | #endif | |
542 | #if defined (SIGEMT) | |
543 | case TARGET_SIGNAL_EMT: | |
544 | return SIGEMT; | |
545 | #endif | |
546 | #if defined (SIGFPE) | |
547 | case TARGET_SIGNAL_FPE: | |
548 | return SIGFPE; | |
549 | #endif | |
550 | #if defined (SIGKILL) | |
551 | case TARGET_SIGNAL_KILL: | |
552 | return SIGKILL; | |
553 | #endif | |
554 | #if defined (SIGBUS) | |
555 | case TARGET_SIGNAL_BUS: | |
556 | return SIGBUS; | |
557 | #endif | |
558 | #if defined (SIGSEGV) | |
559 | case TARGET_SIGNAL_SEGV: | |
560 | return SIGSEGV; | |
561 | #endif | |
562 | #if defined (SIGSYS) | |
563 | case TARGET_SIGNAL_SYS: | |
564 | return SIGSYS; | |
565 | #endif | |
566 | #if defined (SIGPIPE) | |
567 | case TARGET_SIGNAL_PIPE: | |
568 | return SIGPIPE; | |
569 | #endif | |
570 | #if defined (SIGALRM) | |
571 | case TARGET_SIGNAL_ALRM: | |
572 | return SIGALRM; | |
573 | #endif | |
574 | #if defined (SIGTERM) | |
575 | case TARGET_SIGNAL_TERM: | |
576 | return SIGTERM; | |
577 | #endif | |
578 | #if defined (SIGUSR1) | |
579 | case TARGET_SIGNAL_USR1: | |
580 | return SIGUSR1; | |
581 | #endif | |
582 | #if defined (SIGUSR2) | |
583 | case TARGET_SIGNAL_USR2: | |
584 | return SIGUSR2; | |
585 | #endif | |
586 | #if defined (SIGCHLD) || defined (SIGCLD) | |
587 | case TARGET_SIGNAL_CHLD: | |
588 | #if defined (SIGCHLD) | |
589 | return SIGCHLD; | |
590 | #else | |
591 | return SIGCLD; | |
592 | #endif | |
593 | #endif /* SIGCLD or SIGCHLD */ | |
594 | #if defined (SIGPWR) | |
595 | case TARGET_SIGNAL_PWR: | |
596 | return SIGPWR; | |
597 | #endif | |
598 | #if defined (SIGWINCH) | |
599 | case TARGET_SIGNAL_WINCH: | |
600 | return SIGWINCH; | |
601 | #endif | |
602 | #if defined (SIGURG) | |
603 | case TARGET_SIGNAL_URG: | |
604 | return SIGURG; | |
605 | #endif | |
606 | #if defined (SIGIO) | |
607 | case TARGET_SIGNAL_IO: | |
608 | return SIGIO; | |
609 | #endif | |
610 | #if defined (SIGPOLL) | |
611 | case TARGET_SIGNAL_POLL: | |
612 | return SIGPOLL; | |
613 | #endif | |
614 | #if defined (SIGSTOP) | |
615 | case TARGET_SIGNAL_STOP: | |
616 | return SIGSTOP; | |
617 | #endif | |
618 | #if defined (SIGTSTP) | |
619 | case TARGET_SIGNAL_TSTP: | |
620 | return SIGTSTP; | |
621 | #endif | |
622 | #if defined (SIGCONT) | |
623 | case TARGET_SIGNAL_CONT: | |
624 | return SIGCONT; | |
625 | #endif | |
626 | #if defined (SIGTTIN) | |
627 | case TARGET_SIGNAL_TTIN: | |
628 | return SIGTTIN; | |
629 | #endif | |
630 | #if defined (SIGTTOU) | |
631 | case TARGET_SIGNAL_TTOU: | |
632 | return SIGTTOU; | |
633 | #endif | |
634 | #if defined (SIGVTALRM) | |
635 | case TARGET_SIGNAL_VTALRM: | |
636 | return SIGVTALRM; | |
637 | #endif | |
638 | #if defined (SIGPROF) | |
639 | case TARGET_SIGNAL_PROF: | |
640 | return SIGPROF; | |
641 | #endif | |
642 | #if defined (SIGXCPU) | |
643 | case TARGET_SIGNAL_XCPU: | |
644 | return SIGXCPU; | |
645 | #endif | |
646 | #if defined (SIGXFSZ) | |
647 | case TARGET_SIGNAL_XFSZ: | |
648 | return SIGXFSZ; | |
649 | #endif | |
650 | #if defined (SIGWIND) | |
651 | case TARGET_SIGNAL_WIND: | |
652 | return SIGWIND; | |
653 | #endif | |
654 | #if defined (SIGPHONE) | |
655 | case TARGET_SIGNAL_PHONE: | |
656 | return SIGPHONE; | |
657 | #endif | |
658 | #if defined (SIGLOST) | |
659 | case TARGET_SIGNAL_LOST: | |
660 | return SIGLOST; | |
661 | #endif | |
662 | #if defined (SIGWAITING) | |
663 | case TARGET_SIGNAL_WAITING: | |
664 | return SIGWAITING; | |
665 | #endif | |
666 | #if defined (SIGCANCEL) | |
667 | case TARGET_SIGNAL_CANCEL: | |
668 | return SIGCANCEL; | |
669 | #endif | |
670 | #if defined (SIGLWP) | |
671 | case TARGET_SIGNAL_LWP: | |
672 | return SIGLWP; | |
673 | #endif | |
674 | #if defined (SIGDANGER) | |
675 | case TARGET_SIGNAL_DANGER: | |
676 | return SIGDANGER; | |
677 | #endif | |
678 | #if defined (SIGGRANT) | |
679 | case TARGET_SIGNAL_GRANT: | |
680 | return SIGGRANT; | |
681 | #endif | |
682 | #if defined (SIGRETRACT) | |
683 | case TARGET_SIGNAL_RETRACT: | |
684 | return SIGRETRACT; | |
685 | #endif | |
686 | #if defined (SIGMSG) | |
687 | case TARGET_SIGNAL_MSG: | |
688 | return SIGMSG; | |
689 | #endif | |
690 | #if defined (SIGSOUND) | |
691 | case TARGET_SIGNAL_SOUND: | |
692 | return SIGSOUND; | |
693 | #endif | |
694 | #if defined (SIGSAK) | |
695 | case TARGET_SIGNAL_SAK: | |
696 | return SIGSAK; | |
697 | #endif | |
698 | #if defined (SIGPRIO) | |
699 | case TARGET_SIGNAL_PRIO: | |
700 | return SIGPRIO; | |
701 | #endif | |
702 | ||
703 | /* Mach exceptions. Assumes that the values for EXC_ are positive! */ | |
704 | #if defined (EXC_BAD_ACCESS) && defined (_NSIG) | |
705 | case TARGET_EXC_BAD_ACCESS: | |
706 | return _NSIG + EXC_BAD_ACCESS; | |
707 | #endif | |
708 | #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) | |
709 | case TARGET_EXC_BAD_INSTRUCTION: | |
710 | return _NSIG + EXC_BAD_INSTRUCTION; | |
711 | #endif | |
712 | #if defined (EXC_ARITHMETIC) && defined (_NSIG) | |
713 | case TARGET_EXC_ARITHMETIC: | |
714 | return _NSIG + EXC_ARITHMETIC; | |
715 | #endif | |
716 | #if defined (EXC_EMULATION) && defined (_NSIG) | |
717 | case TARGET_EXC_EMULATION: | |
718 | return _NSIG + EXC_EMULATION; | |
719 | #endif | |
720 | #if defined (EXC_SOFTWARE) && defined (_NSIG) | |
721 | case TARGET_EXC_SOFTWARE: | |
722 | return _NSIG + EXC_SOFTWARE; | |
723 | #endif | |
724 | #if defined (EXC_BREAKPOINT) && defined (_NSIG) | |
725 | case TARGET_EXC_BREAKPOINT: | |
726 | return _NSIG + EXC_BREAKPOINT; | |
727 | #endif | |
728 | ||
729 | #if defined (SIGINFO) | |
730 | case TARGET_SIGNAL_INFO: | |
731 | return SIGINFO; | |
732 | #endif | |
733 | ||
734 | default: | |
735 | #if defined (REALTIME_LO) | |
736 | if (oursig >= TARGET_SIGNAL_REALTIME_33 | |
737 | && oursig <= TARGET_SIGNAL_REALTIME_63) | |
738 | { | |
739 | /* This block of signals is continuous, and | |
740 | TARGET_SIGNAL_REALTIME_33 is 33 by definition. */ | |
741 | int retsig = | |
742 | (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33; | |
743 | if (retsig >= REALTIME_LO && retsig < REALTIME_HI) | |
744 | return retsig; | |
745 | } | |
746 | #if (REALTIME_LO < 33) | |
747 | else if (oursig == TARGET_SIGNAL_REALTIME_32) | |
748 | { | |
749 | /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with | |
750 | TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */ | |
751 | return 32; | |
752 | } | |
753 | #endif | |
754 | #if (REALTIME_HI > 64) | |
755 | if (oursig >= TARGET_SIGNAL_REALTIME_64 | |
756 | && oursig <= TARGET_SIGNAL_REALTIME_127) | |
757 | { | |
758 | /* This block of signals is continuous, and | |
759 | TARGET_SIGNAL_REALTIME_64 is 64 by definition. */ | |
760 | int retsig = | |
761 | (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64; | |
762 | if (retsig >= REALTIME_LO && retsig < REALTIME_HI) | |
763 | return retsig; | |
764 | } | |
765 | ||
766 | #endif | |
767 | #endif | |
768 | ||
769 | #if defined (SIGRTMIN) | |
770 | if (oursig >= TARGET_SIGNAL_REALTIME_33 | |
771 | && oursig <= TARGET_SIGNAL_REALTIME_63) | |
772 | { | |
773 | /* This block of signals is continuous, and | |
774 | TARGET_SIGNAL_REALTIME_33 is 33 by definition. */ | |
775 | int retsig = | |
776 | (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33; | |
777 | if (retsig >= SIGRTMIN && retsig <= SIGRTMAX) | |
778 | return retsig; | |
779 | } | |
780 | else if (oursig == TARGET_SIGNAL_REALTIME_64) | |
781 | return 64; | |
782 | #endif | |
783 | *oursig_ok = 0; | |
784 | return 0; | |
785 | } | |
786 | } | |
787 | ||
788 | int | |
789 | target_signal_to_host_p (enum target_signal oursig) | |
790 | { | |
791 | int oursig_ok; | |
792 | do_target_signal_to_host (oursig, &oursig_ok); | |
793 | return oursig_ok; | |
794 | } | |
795 | ||
796 | int | |
797 | target_signal_to_host (enum target_signal oursig) | |
798 | { | |
799 | int oursig_ok; | |
800 | int targ_signo = do_target_signal_to_host (oursig, &oursig_ok); | |
801 | if (!oursig_ok) | |
802 | { | |
803 | /* The user might be trying to do "signal SIGSAK" where this system | |
804 | doesn't have SIGSAK. */ | |
805 | warning ("Signal %s does not exist on this system.\n", | |
806 | target_signal_to_name (oursig)); | |
807 | return 0; | |
808 | } | |
809 | else | |
810 | return targ_signo; | |
811 | } | |
812 | ||
813 | /* In some circumstances we allow a command to specify a numeric | |
814 | signal. The idea is to keep these circumstances limited so that | |
815 | users (and scripts) develop portable habits. For comparison, | |
816 | POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a | |
817 | numeric signal at all is obsolescent. We are slightly more | |
818 | lenient and allow 1-15 which should match host signal numbers on | |
819 | most systems. Use of symbolic signal names is strongly encouraged. */ | |
820 | ||
821 | enum target_signal | |
822 | target_signal_from_command (int num) | |
823 | { | |
824 | if (num >= 1 && num <= 15) | |
825 | return (enum target_signal) num; | |
826 | error ("Only signals 1-15 are valid as numeric signals.\n\ | |
827 | Use \"info signals\" for a list of symbolic signals."); | |
828 | } | |
829 | ||
830 | void | |
831 | _initialize_signals (void) | |
832 | { | |
833 | if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC")) | |
834 | internal_error (__FILE__, __LINE__, "failed internal consistency check"); | |
835 | } |