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