projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* signals.c: New file.
[deliverable/binutils-gdb.git] / gdb / signals.c
CommitLineData
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* */
30static 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. */
200char *
201target_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. */
210char *
211target_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. */
221enum target_signal
222target_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. */
245enum target_signal
246target_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
508static int
509do_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
788int
789target_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
796int
797target_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
821enum target_signal
822target_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\
827Use \"info signals\" for a list of symbolic signals.");
828}
829
830void
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}
GDB Binutils - Deliverables
This page took 0.051437 seconds and 4 git commands to generate.