projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2002-03-27 Daniel Jacobowitz <drow@mvista.com>
[deliverable/binutils-gdb.git] / gdb / signals / 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{
ade8f45e
AC		 213 if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST)
214 && signals[sig].name != NULL)
89c49e7a
AC		 215 return signals[sig].name;
216 else
ade8f45e
AC		 217 /* I think the code which prints this will always print it along
218 with the string, so no need to be verbose (very old comment). */
219 return "?";
0150732f
DJ		 220}
221
222/* Given a name, return its signal. */
223enum target_signal
224target_signal_from_name (char *name)
225{
226 enum target_signal sig;
227
228 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
229 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
230 questionable; seems like by now people should call it SIGABRT
231 instead. */
232
233 /* This ugly cast brought to you by the native VAX compiler. */
234 for (sig = TARGET_SIGNAL_HUP;
235 signals[sig].name != NULL;
236 sig = (enum target_signal) ((int) sig + 1))
237 if (STREQ (name, signals[sig].name))
238 return sig;
239 return TARGET_SIGNAL_UNKNOWN;
240}
241\f
242/* The following functions are to help certain targets deal
243 with the signal/waitstatus stuff. They could just as well be in
244 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
245
246/* Convert host signal to our signals. */
247enum target_signal
248target_signal_from_host (int hostsig)
249{
250 /* A switch statement would make sense but would require special kludges
251 to deal with the cases where more than one signal has the same number. */
252
253 if (hostsig == 0)
254 return TARGET_SIGNAL_0;
255
256#if defined (SIGHUP)
257 if (hostsig == SIGHUP)
258 return TARGET_SIGNAL_HUP;
259#endif
260#if defined (SIGINT)
261 if (hostsig == SIGINT)
262 return TARGET_SIGNAL_INT;
263#endif
264#if defined (SIGQUIT)
265 if (hostsig == SIGQUIT)
266 return TARGET_SIGNAL_QUIT;
267#endif
268#if defined (SIGILL)
269 if (hostsig == SIGILL)
270 return TARGET_SIGNAL_ILL;
271#endif
272#if defined (SIGTRAP)
273 if (hostsig == SIGTRAP)
274 return TARGET_SIGNAL_TRAP;
275#endif
276#if defined (SIGABRT)
277 if (hostsig == SIGABRT)
278 return TARGET_SIGNAL_ABRT;
279#endif
280#if defined (SIGEMT)
281 if (hostsig == SIGEMT)
282 return TARGET_SIGNAL_EMT;
283#endif
284#if defined (SIGFPE)
285 if (hostsig == SIGFPE)
286 return TARGET_SIGNAL_FPE;
287#endif
288#if defined (SIGKILL)
289 if (hostsig == SIGKILL)
290 return TARGET_SIGNAL_KILL;
291#endif
292#if defined (SIGBUS)
293 if (hostsig == SIGBUS)
294 return TARGET_SIGNAL_BUS;
295#endif
296#if defined (SIGSEGV)
297 if (hostsig == SIGSEGV)
298 return TARGET_SIGNAL_SEGV;
299#endif
300#if defined (SIGSYS)
301 if (hostsig == SIGSYS)
302 return TARGET_SIGNAL_SYS;
303#endif
304#if defined (SIGPIPE)
305 if (hostsig == SIGPIPE)
306 return TARGET_SIGNAL_PIPE;
307#endif
308#if defined (SIGALRM)
309 if (hostsig == SIGALRM)
310 return TARGET_SIGNAL_ALRM;
311#endif
312#if defined (SIGTERM)
313 if (hostsig == SIGTERM)
314 return TARGET_SIGNAL_TERM;
315#endif
316#if defined (SIGUSR1)
317 if (hostsig == SIGUSR1)
318 return TARGET_SIGNAL_USR1;
319#endif
320#if defined (SIGUSR2)
321 if (hostsig == SIGUSR2)
322 return TARGET_SIGNAL_USR2;
323#endif
324#if defined (SIGCLD)
325 if (hostsig == SIGCLD)
326 return TARGET_SIGNAL_CHLD;
327#endif
328#if defined (SIGCHLD)
329 if (hostsig == SIGCHLD)
330 return TARGET_SIGNAL_CHLD;
331#endif
332#if defined (SIGPWR)
333 if (hostsig == SIGPWR)
334 return TARGET_SIGNAL_PWR;
335#endif
336#if defined (SIGWINCH)
337 if (hostsig == SIGWINCH)
338 return TARGET_SIGNAL_WINCH;
339#endif
340#if defined (SIGURG)
341 if (hostsig == SIGURG)
342 return TARGET_SIGNAL_URG;
343#endif
344#if defined (SIGIO)
345 if (hostsig == SIGIO)
346 return TARGET_SIGNAL_IO;
347#endif
348#if defined (SIGPOLL)
349 if (hostsig == SIGPOLL)
350 return TARGET_SIGNAL_POLL;
351#endif
352#if defined (SIGSTOP)
353 if (hostsig == SIGSTOP)
354 return TARGET_SIGNAL_STOP;
355#endif
356#if defined (SIGTSTP)
357 if (hostsig == SIGTSTP)
358 return TARGET_SIGNAL_TSTP;
359#endif
360#if defined (SIGCONT)
361 if (hostsig == SIGCONT)
362 return TARGET_SIGNAL_CONT;
363#endif
364#if defined (SIGTTIN)
365 if (hostsig == SIGTTIN)
366 return TARGET_SIGNAL_TTIN;
367#endif
368#if defined (SIGTTOU)
369 if (hostsig == SIGTTOU)
370 return TARGET_SIGNAL_TTOU;
371#endif
372#if defined (SIGVTALRM)
373 if (hostsig == SIGVTALRM)
374 return TARGET_SIGNAL_VTALRM;
375#endif
376#if defined (SIGPROF)
377 if (hostsig == SIGPROF)
378 return TARGET_SIGNAL_PROF;
379#endif
380#if defined (SIGXCPU)
381 if (hostsig == SIGXCPU)
382 return TARGET_SIGNAL_XCPU;
383#endif
384#if defined (SIGXFSZ)
385 if (hostsig == SIGXFSZ)
386 return TARGET_SIGNAL_XFSZ;
387#endif
388#if defined (SIGWIND)
389 if (hostsig == SIGWIND)
390 return TARGET_SIGNAL_WIND;
391#endif
392#if defined (SIGPHONE)
393 if (hostsig == SIGPHONE)
394 return TARGET_SIGNAL_PHONE;
395#endif
396#if defined (SIGLOST)
397 if (hostsig == SIGLOST)
398 return TARGET_SIGNAL_LOST;
399#endif
400#if defined (SIGWAITING)
401 if (hostsig == SIGWAITING)
402 return TARGET_SIGNAL_WAITING;
403#endif
404#if defined (SIGCANCEL)
405 if (hostsig == SIGCANCEL)
406 return TARGET_SIGNAL_CANCEL;
407#endif
408#if defined (SIGLWP)
409 if (hostsig == SIGLWP)
410 return TARGET_SIGNAL_LWP;
411#endif
412#if defined (SIGDANGER)
413 if (hostsig == SIGDANGER)
414 return TARGET_SIGNAL_DANGER;
415#endif
416#if defined (SIGGRANT)
417 if (hostsig == SIGGRANT)
418 return TARGET_SIGNAL_GRANT;
419#endif
420#if defined (SIGRETRACT)
421 if (hostsig == SIGRETRACT)
422 return TARGET_SIGNAL_RETRACT;
423#endif
424#if defined (SIGMSG)
425 if (hostsig == SIGMSG)
426 return TARGET_SIGNAL_MSG;
427#endif
428#if defined (SIGSOUND)
429 if (hostsig == SIGSOUND)
430 return TARGET_SIGNAL_SOUND;
431#endif
432#if defined (SIGSAK)
433 if (hostsig == SIGSAK)
434 return TARGET_SIGNAL_SAK;
435#endif
436#if defined (SIGPRIO)
437 if (hostsig == SIGPRIO)
438 return TARGET_SIGNAL_PRIO;
439#endif
440
441 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
442#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
443 if (hostsig == _NSIG + EXC_BAD_ACCESS)
444 return TARGET_EXC_BAD_ACCESS;
445#endif
446#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
447 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
448 return TARGET_EXC_BAD_INSTRUCTION;
449#endif
450#if defined (EXC_ARITHMETIC) && defined (_NSIG)
451 if (hostsig == _NSIG + EXC_ARITHMETIC)
452 return TARGET_EXC_ARITHMETIC;
453#endif
454#if defined (EXC_EMULATION) && defined (_NSIG)
455 if (hostsig == _NSIG + EXC_EMULATION)
456 return TARGET_EXC_EMULATION;
457#endif
458#if defined (EXC_SOFTWARE) && defined (_NSIG)
459 if (hostsig == _NSIG + EXC_SOFTWARE)
460 return TARGET_EXC_SOFTWARE;
461#endif
462#if defined (EXC_BREAKPOINT) && defined (_NSIG)
463 if (hostsig == _NSIG + EXC_BREAKPOINT)
464 return TARGET_EXC_BREAKPOINT;
465#endif
466
467#if defined (SIGINFO)
468 if (hostsig == SIGINFO)
469 return TARGET_SIGNAL_INFO;
470#endif
471
472#if defined (REALTIME_LO)
473 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
474 {
475 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
476 if (33 <= hostsig && hostsig <= 63)
477 return (enum target_signal)
478 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
479 else if (hostsig == 32)
480 return TARGET_SIGNAL_REALTIME_32;
481 else if (64 <= hostsig && hostsig <= 127)
482 return (enum target_signal)
483 (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
484 else
485 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
486 }
487#endif
488
489#if defined (SIGRTMIN)
490 if (hostsig >= SIGRTMIN && hostsig <= SIGRTMAX)
491 {
492 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
493 if (33 <= hostsig && hostsig <= 63)
494 return (enum target_signal)
495 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
496 else if (hostsig == 64)
497 return TARGET_SIGNAL_REALTIME_64;
498 else
499 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
500 }
501#endif
502 return TARGET_SIGNAL_UNKNOWN;
503}
504
505/* Convert a OURSIG (an enum target_signal) to the form used by the
506 target operating system (refered to as the ``host'') or zero if the
507 equivalent host signal is not available. Set/clear OURSIG_OK
508 accordingly. */
509
510static int
511do_target_signal_to_host (enum target_signal oursig,
512 int *oursig_ok)
513{
514 *oursig_ok = 1;
515 switch (oursig)
516 {
517 case TARGET_SIGNAL_0:
518 return 0;
519
520#if defined (SIGHUP)
521 case TARGET_SIGNAL_HUP:
522 return SIGHUP;
523#endif
524#if defined (SIGINT)
525 case TARGET_SIGNAL_INT:
526 return SIGINT;
527#endif
528#if defined (SIGQUIT)
529 case TARGET_SIGNAL_QUIT:
530 return SIGQUIT;
531#endif
532#if defined (SIGILL)
533 case TARGET_SIGNAL_ILL:
534 return SIGILL;
535#endif
536#if defined (SIGTRAP)
537 case TARGET_SIGNAL_TRAP:
538 return SIGTRAP;
539#endif
540#if defined (SIGABRT)
541 case TARGET_SIGNAL_ABRT:
542 return SIGABRT;
543#endif
544#if defined (SIGEMT)
545 case TARGET_SIGNAL_EMT:
546 return SIGEMT;
547#endif
548#if defined (SIGFPE)
549 case TARGET_SIGNAL_FPE:
550 return SIGFPE;
551#endif
552#if defined (SIGKILL)
553 case TARGET_SIGNAL_KILL:
554 return SIGKILL;
555#endif
556#if defined (SIGBUS)
557 case TARGET_SIGNAL_BUS:
558 return SIGBUS;
559#endif
560#if defined (SIGSEGV)
561 case TARGET_SIGNAL_SEGV:
562 return SIGSEGV;
563#endif
564#if defined (SIGSYS)
565 case TARGET_SIGNAL_SYS:
566 return SIGSYS;
567#endif
568#if defined (SIGPIPE)
569 case TARGET_SIGNAL_PIPE:
570 return SIGPIPE;
571#endif
572#if defined (SIGALRM)
573 case TARGET_SIGNAL_ALRM:
574 return SIGALRM;
575#endif
576#if defined (SIGTERM)
577 case TARGET_SIGNAL_TERM:
578 return SIGTERM;
579#endif
580#if defined (SIGUSR1)
581 case TARGET_SIGNAL_USR1:
582 return SIGUSR1;
583#endif
584#if defined (SIGUSR2)
585 case TARGET_SIGNAL_USR2:
586 return SIGUSR2;
587#endif
588#if defined (SIGCHLD) || defined (SIGCLD)
589 case TARGET_SIGNAL_CHLD:
590#if defined (SIGCHLD)
591 return SIGCHLD;
592#else
593 return SIGCLD;
594#endif
595#endif /* SIGCLD or SIGCHLD */
596#if defined (SIGPWR)
597 case TARGET_SIGNAL_PWR:
598 return SIGPWR;
599#endif
600#if defined (SIGWINCH)
601 case TARGET_SIGNAL_WINCH:
602 return SIGWINCH;
603#endif
604#if defined (SIGURG)
605 case TARGET_SIGNAL_URG:
606 return SIGURG;
607#endif
608#if defined (SIGIO)
609 case TARGET_SIGNAL_IO:
610 return SIGIO;
611#endif
612#if defined (SIGPOLL)
613 case TARGET_SIGNAL_POLL:
614 return SIGPOLL;
615#endif
616#if defined (SIGSTOP)
617 case TARGET_SIGNAL_STOP:
618 return SIGSTOP;
619#endif
620#if defined (SIGTSTP)
621 case TARGET_SIGNAL_TSTP:
622 return SIGTSTP;
623#endif
624#if defined (SIGCONT)
625 case TARGET_SIGNAL_CONT:
626 return SIGCONT;
627#endif
628#if defined (SIGTTIN)
629 case TARGET_SIGNAL_TTIN:
630 return SIGTTIN;
631#endif
632#if defined (SIGTTOU)
633 case TARGET_SIGNAL_TTOU:
634 return SIGTTOU;
635#endif
636#if defined (SIGVTALRM)
637 case TARGET_SIGNAL_VTALRM:
638 return SIGVTALRM;
639#endif
640#if defined (SIGPROF)
641 case TARGET_SIGNAL_PROF:
642 return SIGPROF;
643#endif
644#if defined (SIGXCPU)
645 case TARGET_SIGNAL_XCPU:
646 return SIGXCPU;
647#endif
648#if defined (SIGXFSZ)
649 case TARGET_SIGNAL_XFSZ:
650 return SIGXFSZ;
651#endif
652#if defined (SIGWIND)
653 case TARGET_SIGNAL_WIND:
654 return SIGWIND;
655#endif
656#if defined (SIGPHONE)
657 case TARGET_SIGNAL_PHONE:
658 return SIGPHONE;
659#endif
660#if defined (SIGLOST)
661 case TARGET_SIGNAL_LOST:
662 return SIGLOST;
663#endif
664#if defined (SIGWAITING)
665 case TARGET_SIGNAL_WAITING:
666 return SIGWAITING;
667#endif
668#if defined (SIGCANCEL)
669 case TARGET_SIGNAL_CANCEL:
670 return SIGCANCEL;
671#endif
672#if defined (SIGLWP)
673 case TARGET_SIGNAL_LWP:
674 return SIGLWP;
675#endif
676#if defined (SIGDANGER)
677 case TARGET_SIGNAL_DANGER:
678 return SIGDANGER;
679#endif
680#if defined (SIGGRANT)
681 case TARGET_SIGNAL_GRANT:
682 return SIGGRANT;
683#endif
684#if defined (SIGRETRACT)
685 case TARGET_SIGNAL_RETRACT:
686 return SIGRETRACT;
687#endif
688#if defined (SIGMSG)
689 case TARGET_SIGNAL_MSG:
690 return SIGMSG;
691#endif
692#if defined (SIGSOUND)
693 case TARGET_SIGNAL_SOUND:
694 return SIGSOUND;
695#endif
696#if defined (SIGSAK)
697 case TARGET_SIGNAL_SAK:
698 return SIGSAK;
699#endif
700#if defined (SIGPRIO)
701 case TARGET_SIGNAL_PRIO:
702 return SIGPRIO;
703#endif
704
705 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
706#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
707 case TARGET_EXC_BAD_ACCESS:
708 return _NSIG + EXC_BAD_ACCESS;
709#endif
710#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
711 case TARGET_EXC_BAD_INSTRUCTION:
712 return _NSIG + EXC_BAD_INSTRUCTION;
713#endif
714#if defined (EXC_ARITHMETIC) && defined (_NSIG)
715 case TARGET_EXC_ARITHMETIC:
716 return _NSIG + EXC_ARITHMETIC;
717#endif
718#if defined (EXC_EMULATION) && defined (_NSIG)
719 case TARGET_EXC_EMULATION:
720 return _NSIG + EXC_EMULATION;
721#endif
722#if defined (EXC_SOFTWARE) && defined (_NSIG)
723 case TARGET_EXC_SOFTWARE:
724 return _NSIG + EXC_SOFTWARE;
725#endif
726#if defined (EXC_BREAKPOINT) && defined (_NSIG)
727 case TARGET_EXC_BREAKPOINT:
728 return _NSIG + EXC_BREAKPOINT;
729#endif
730
731#if defined (SIGINFO)
732 case TARGET_SIGNAL_INFO:
733 return SIGINFO;
734#endif
735
736 default:
737#if defined (REALTIME_LO)
738 if (oursig >= TARGET_SIGNAL_REALTIME_33
739 && oursig <= TARGET_SIGNAL_REALTIME_63)
740 {
741 /* This block of signals is continuous, and
742 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
743 int retsig =
744 (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
745 if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
746 return retsig;
747 }
748#if (REALTIME_LO < 33)
749 else if (oursig == TARGET_SIGNAL_REALTIME_32)
750 {
751 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
752 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
753 return 32;
754 }
755#endif
756#if (REALTIME_HI > 64)
757 if (oursig >= TARGET_SIGNAL_REALTIME_64
758 && oursig <= TARGET_SIGNAL_REALTIME_127)
759 {
760 /* This block of signals is continuous, and
761 TARGET_SIGNAL_REALTIME_64 is 64 by definition. */
762 int retsig =
763 (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64;
764 if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
765 return retsig;
766 }
767
768#endif
769#endif
770
771#if defined (SIGRTMIN)
772 if (oursig >= TARGET_SIGNAL_REALTIME_33
773 && oursig <= TARGET_SIGNAL_REALTIME_63)
774 {
775 /* This block of signals is continuous, and
776 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
777 int retsig =
778 (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
779 if (retsig >= SIGRTMIN && retsig <= SIGRTMAX)
780 return retsig;
781 }
782 else if (oursig == TARGET_SIGNAL_REALTIME_64)
783 return 64;
784#endif
785 *oursig_ok = 0;
786 return 0;
787 }
788}
789
790int
791target_signal_to_host_p (enum target_signal oursig)
792{
793 int oursig_ok;
794 do_target_signal_to_host (oursig, &oursig_ok);
795 return oursig_ok;
796}
797
798int
799target_signal_to_host (enum target_signal oursig)
800{
801 int oursig_ok;
802 int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
803 if (!oursig_ok)
804 {
805 /* The user might be trying to do "signal SIGSAK" where this system
806 doesn't have SIGSAK. */
807 warning ("Signal %s does not exist on this system.\n",
808 target_signal_to_name (oursig));
809 return 0;
810 }
811 else
812 return targ_signo;
813}
814
815/* In some circumstances we allow a command to specify a numeric
816 signal. The idea is to keep these circumstances limited so that
817 users (and scripts) develop portable habits. For comparison,
818 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
819 numeric signal at all is obsolescent. We are slightly more
820 lenient and allow 1-15 which should match host signal numbers on
821 most systems. Use of symbolic signal names is strongly encouraged. */
822
823enum target_signal
824target_signal_from_command (int num)
825{
826 if (num >= 1 && num <= 15)
827 return (enum target_signal) num;
828 error ("Only signals 1-15 are valid as numeric signals.\n\
829Use \"info signals\" for a list of symbolic signals.");
830}
831
832void
833_initialize_signals (void)
834{
835 if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
836 internal_error (__FILE__, __LINE__, "failed internal consistency check");
837}
GDB Binutils - Deliverables
This page took 0.138614 seconds and 4 git commands to generate.