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