1 /* libqnxr - GPL - Copyright 2016 - madprogrammer, FSF Inc */
2
3 #include <signal.h>
4 #include "gdb_signals.h"
5 #include "sigutil.h"
6 #include "utils.h"
7
8 #define NTO_SIGHUP 1 /* hangup */
9 #define NTO_SIGINT 2 /* interrupt */
10 #define NTO_SIGQUIT 3 /* quit */
11 #define NTO_SIGILL 4 /* illegal instruction (not reset when caught) */
12 #define NTO_SIGTRAP 5 /* trace trap (not reset when caught) */
13 #define NTO_SIGIOT 6 /* IOT instruction */
14 #define NTO_SIGABRT 6 /* used by abort */
15 #define NTO_SIGEMT 7 /* EMT instruction */
16 #define NTO_SIGDEADLK 7 /* Mutex deadlock */
17 #define NTO_SIGFPE 8 /* floating point exception */
18 #define NTO_SIGKILL 9 /* kill (cannot be caught or ignored) */
19 #define NTO_SIGBUS 10 /* bus error */
20 #define NTO_SIGSEGV 11 /* segmentation violation */
21 #define NTO_SIGSYS 12 /* bad argument to system call */
22 #define NTO_SIGPIPE 13 /* write on pipe with no reader */
23 #define NTO_SIGALRM 14 /* real-time alarm clock */
24 #define NTO_SIGTERM 15 /* software termination signal from kill */
25 #define NTO_SIGUSR1 16 /* user defined signal 1 */
26 #define NTO_SIGUSR2 17 /* user defined signal 2 */
27 #define NTO_SIGCHLD 18 /* death of child */
28 #define NTO_SIGPWR 19 /* power-fail restart */
29 #define NTO_SIGWINCH 20 /* window change */
30 #define NTO_SIGURG 21 /* urgent condition on I/O channel */
31 #define NTO_SIGPOLL 22 /* System V name for NTO_SIGIO */
32 #define NTO_SIGIO NTO_SIGPOLL
33 #define NTO_SIGSTOP 23 /* sendable stop signal not from tty */
34 #define NTO_SIGTSTP 24 /* stop signal from tty */
35 #define NTO_SIGCONT 25 /* continue a stopped process */
36 #define NTO_SIGTTIN 26 /* attempted background tty read */
37 #define NTO_SIGTTOU 27 /* attempted background tty write */
38 #define NTO_SIGVTALRM 28 /* virtual timer expired */
39 #define NTO_SIGPROF 29 /* profileing timer expired */
40 #define NTO_SIGXCPU 30 /* exceded cpu limit */
41 #define NTO_SIGXFSZ 31 /* exceded file size limit */
42 #define NTO_SIGRTMIN 41 /* Realtime signal 41 (SIGRTMIN) */
43 #define NTO_SIGRTMAX 56 /* Realtime signal 56 (SIGRTMAX) */
44 #define NTO_SIGSELECT (NTO_SIGRTMAX + 1)
45 #define NTO_SIGPHOTON (NTO_SIGRTMAX + 2)
46
47 static struct
48 {
49 int nto_sig;
50 enum target_signal gdb_sig;
51 } sig_map[] =
52 {
53 {NTO_SIGHUP, TARGET_SIGNAL_HUP},
54 {NTO_SIGINT, TARGET_SIGNAL_INT},
55 {NTO_SIGQUIT, TARGET_SIGNAL_QUIT},
56 {NTO_SIGILL, TARGET_SIGNAL_ILL},
57 {NTO_SIGTRAP, TARGET_SIGNAL_TRAP},
58 {NTO_SIGABRT, TARGET_SIGNAL_ABRT},
59 {NTO_SIGEMT, TARGET_SIGNAL_EMT},
60 {NTO_SIGFPE, TARGET_SIGNAL_FPE},
61 {NTO_SIGKILL, TARGET_SIGNAL_KILL},
62 {NTO_SIGBUS, TARGET_SIGNAL_BUS},
63 {NTO_SIGSEGV, TARGET_SIGNAL_SEGV},
64 {NTO_SIGSYS, TARGET_SIGNAL_SYS},
65 {NTO_SIGPIPE, TARGET_SIGNAL_PIPE},
66 {NTO_SIGALRM, TARGET_SIGNAL_ALRM},
67 {NTO_SIGTERM, TARGET_SIGNAL_TERM},
68 {NTO_SIGUSR1, TARGET_SIGNAL_USR1},
69 {NTO_SIGUSR2, TARGET_SIGNAL_USR2},
70 {NTO_SIGCHLD, TARGET_SIGNAL_CHLD},
71 {NTO_SIGPWR, TARGET_SIGNAL_PWR},
72 {NTO_SIGWINCH, TARGET_SIGNAL_WINCH},
73 {NTO_SIGURG, TARGET_SIGNAL_URG},
74 {NTO_SIGPOLL, TARGET_SIGNAL_POLL},
75 {NTO_SIGSTOP, TARGET_SIGNAL_STOP},
76 {NTO_SIGTSTP, TARGET_SIGNAL_TSTP},
77 {NTO_SIGCONT, TARGET_SIGNAL_CONT},
78 {NTO_SIGTTIN, TARGET_SIGNAL_TTIN},
79 {NTO_SIGTTOU, TARGET_SIGNAL_TTOU},
80 {NTO_SIGVTALRM, TARGET_SIGNAL_VTALRM},
81 {NTO_SIGPROF, TARGET_SIGNAL_PROF},
82 {NTO_SIGXCPU, TARGET_SIGNAL_XCPU},
83 {NTO_SIGXFSZ, TARGET_SIGNAL_XFSZ}};
84
85 /* Convert host signal to our signals. */
86 enum target_signal
target_signal_from_host(int hostsig)87 target_signal_from_host (int hostsig) {
88 /* A switch statement would make sense but would require special kludges
89 to deal with the cases where more than one signal has the same number. */
90
91 if (hostsig == 0)
92 return TARGET_SIGNAL_0;
93
94 #if defined(SIGHUP)
95 if (hostsig == SIGHUP)
96 return TARGET_SIGNAL_HUP;
97 #endif
98 #if defined(SIGINT)
99 if (hostsig == SIGINT)
100 return TARGET_SIGNAL_INT;
101 #endif
102 #if defined(SIGQUIT)
103 if (hostsig == SIGQUIT)
104 return TARGET_SIGNAL_QUIT;
105 #endif
106 #if defined(SIGILL)
107 if (hostsig == SIGILL)
108 return TARGET_SIGNAL_ILL;
109 #endif
110 #if defined(SIGTRAP)
111 if (hostsig == SIGTRAP)
112 return TARGET_SIGNAL_TRAP;
113 #endif
114 #if defined(SIGABRT)
115 if (hostsig == SIGABRT)
116 return TARGET_SIGNAL_ABRT;
117 #endif
118 #if defined(SIGEMT)
119 if (hostsig == SIGEMT)
120 return TARGET_SIGNAL_EMT;
121 #endif
122 #if defined(SIGFPE)
123 if (hostsig == SIGFPE)
124 return TARGET_SIGNAL_FPE;
125 #endif
126 #if defined(SIGKILL)
127 if (hostsig == SIGKILL)
128 return TARGET_SIGNAL_KILL;
129 #endif
130 #if defined(SIGBUS)
131 if (hostsig == SIGBUS)
132 return TARGET_SIGNAL_BUS;
133 #endif
134 #if defined(SIGSEGV)
135 if (hostsig == SIGSEGV)
136 return TARGET_SIGNAL_SEGV;
137 #endif
138 #if defined(SIGSYS)
139 if (hostsig == SIGSYS)
140 return TARGET_SIGNAL_SYS;
141 #endif
142 #if defined(SIGPIPE)
143 if (hostsig == SIGPIPE)
144 return TARGET_SIGNAL_PIPE;
145 #endif
146 #if defined(SIGALRM)
147 if (hostsig == SIGALRM)
148 return TARGET_SIGNAL_ALRM;
149 #endif
150 #if defined(SIGTERM)
151 if (hostsig == SIGTERM)
152 return TARGET_SIGNAL_TERM;
153 #endif
154 #if defined(SIGUSR1)
155 if (hostsig == SIGUSR1)
156 return TARGET_SIGNAL_USR1;
157 #endif
158 #if defined(SIGUSR2)
159 if (hostsig == SIGUSR2)
160 return TARGET_SIGNAL_USR2;
161 #endif
162 #if defined(SIGCLD)
163 if (hostsig == SIGCLD)
164 return TARGET_SIGNAL_CHLD;
165 #endif
166 #if defined(SIGCHLD)
167 if (hostsig == SIGCHLD)
168 return TARGET_SIGNAL_CHLD;
169 #endif
170 #if defined(SIGPWR)
171 if (hostsig == SIGPWR)
172 return TARGET_SIGNAL_PWR;
173 #endif
174 #if defined(SIGWINCH)
175 if (hostsig == SIGWINCH)
176 return TARGET_SIGNAL_WINCH;
177 #endif
178 #if defined(SIGURG)
179 if (hostsig == SIGURG)
180 return TARGET_SIGNAL_URG;
181 #endif
182 #if defined(SIGIO)
183 if (hostsig == SIGIO)
184 return TARGET_SIGNAL_IO;
185 #endif
186 #if defined(SIGPOLL)
187 if (hostsig == SIGPOLL)
188 return TARGET_SIGNAL_POLL;
189 #endif
190 #if defined(SIGSTOP)
191 if (hostsig == SIGSTOP)
192 return TARGET_SIGNAL_STOP;
193 #endif
194 #if defined(SIGTSTP)
195 if (hostsig == SIGTSTP)
196 return TARGET_SIGNAL_TSTP;
197 #endif
198 #if defined(SIGCONT)
199 if (hostsig == SIGCONT)
200 return TARGET_SIGNAL_CONT;
201 #endif
202 #if defined(SIGTTIN)
203 if (hostsig == SIGTTIN)
204 return TARGET_SIGNAL_TTIN;
205 #endif
206 #if defined(SIGTTOU)
207 if (hostsig == SIGTTOU)
208 return TARGET_SIGNAL_TTOU;
209 #endif
210 #if defined(SIGVTALRM)
211 if (hostsig == SIGVTALRM)
212 return TARGET_SIGNAL_VTALRM;
213 #endif
214 #if defined(SIGPROF)
215 if (hostsig == SIGPROF)
216 return TARGET_SIGNAL_PROF;
217 #endif
218 #if defined(SIGXCPU)
219 if (hostsig == SIGXCPU)
220 return TARGET_SIGNAL_XCPU;
221 #endif
222 #if defined(SIGXFSZ)
223 if (hostsig == SIGXFSZ)
224 return TARGET_SIGNAL_XFSZ;
225 #endif
226 #if defined(SIGWIND)
227 if (hostsig == SIGWIND)
228 return TARGET_SIGNAL_WIND;
229 #endif
230 #if defined(SIGPHONE)
231 if (hostsig == SIGPHONE)
232 return TARGET_SIGNAL_PHONE;
233 #endif
234 #if defined(SIGLOST)
235 if (hostsig == SIGLOST)
236 return TARGET_SIGNAL_LOST;
237 #endif
238 #if defined(SIGWAITING)
239 if (hostsig == SIGWAITING)
240 return TARGET_SIGNAL_WAITING;
241 #endif
242 #if defined(SIGCANCEL)
243 if (hostsig == SIGCANCEL)
244 return TARGET_SIGNAL_CANCEL;
245 #endif
246 #if defined(SIGLWP)
247 if (hostsig == SIGLWP)
248 return TARGET_SIGNAL_LWP;
249 #endif
250 #if defined(SIGDANGER)
251 if (hostsig == SIGDANGER)
252 return TARGET_SIGNAL_DANGER;
253 #endif
254 #if defined(SIGGRANT)
255 if (hostsig == SIGGRANT)
256 return TARGET_SIGNAL_GRANT;
257 #endif
258 #if defined(SIGRETRACT)
259 if (hostsig == SIGRETRACT)
260 return TARGET_SIGNAL_RETRACT;
261 #endif
262 #if defined(SIGMSG)
263 if (hostsig == SIGMSG)
264 return TARGET_SIGNAL_MSG;
265 #endif
266 #if defined(SIGSOUND)
267 if (hostsig == SIGSOUND)
268 return TARGET_SIGNAL_SOUND;
269 #endif
270 #if defined(SIGSAK)
271 if (hostsig == SIGSAK)
272 return TARGET_SIGNAL_SAK;
273 #endif
274 #if defined(SIGPRIO)
275 if (hostsig == SIGPRIO)
276 return TARGET_SIGNAL_PRIO;
277 #endif
278
279 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
280 #if defined(EXC_BAD_ACCESS) && defined(_NSIG)
281 if (hostsig == _NSIG + EXC_BAD_ACCESS)
282 return TARGET_EXC_BAD_ACCESS;
283 #endif
284 #if defined(EXC_BAD_INSTRUCTION) && defined(_NSIG)
285 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
286 return TARGET_EXC_BAD_INSTRUCTION;
287 #endif
288 #if defined(EXC_ARITHMETIC) && defined(_NSIG)
289 if (hostsig == _NSIG + EXC_ARITHMETIC)
290 return TARGET_EXC_ARITHMETIC;
291 #endif
292 #if defined(EXC_EMULATION) && defined(_NSIG)
293 if (hostsig == _NSIG + EXC_EMULATION)
294 return TARGET_EXC_EMULATION;
295 #endif
296 #if defined(EXC_SOFTWARE) && defined(_NSIG)
297 if (hostsig == _NSIG + EXC_SOFTWARE)
298 return TARGET_EXC_SOFTWARE;
299 #endif
300 #if defined(EXC_BREAKPOINT) && defined(_NSIG)
301 if (hostsig == _NSIG + EXC_BREAKPOINT)
302 return TARGET_EXC_BREAKPOINT;
303 #endif
304
305 #if defined(SIGINFO)
306 if (hostsig == SIGINFO)
307 return TARGET_SIGNAL_INFO;
308 #endif
309
310 #if defined(REALTIME_LO)
311 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) {
312 /* This block of TARGET_SIGNAL_REALTIME value is in order. */
313 if (33 <= hostsig && hostsig <= 63)
314 return (enum target_signal)(hostsig - 33 + (int)TARGET_SIGNAL_REALTIME_33);
315 else if (hostsig == 32)
316 return TARGET_SIGNAL_REALTIME_32;
317 else if (64 <= hostsig && hostsig <= 127)
318 return (enum target_signal)(hostsig - 64 + (int)TARGET_SIGNAL_REALTIME_64);
319 else
320 error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
321 }
322 #endif
323
324 return TARGET_SIGNAL_UNKNOWN;
325 }
326
327 static int
do_target_signal_to_host(enum target_signal oursig,int * oursig_ok)328 do_target_signal_to_host (enum target_signal oursig,
329 int *oursig_ok) {
330 int retsig;
331 /* Silence the 'not used' warning, for targets that
332 do not support signals. */
333 (void)retsig;
334
335 *oursig_ok = 1;
336 switch (oursig) {
337 case TARGET_SIGNAL_0:
338 return 0;
339
340 #if defined(SIGHUP)
341 case TARGET_SIGNAL_HUP:
342 return SIGHUP;
343 #endif
344 #if defined(SIGINT)
345 case TARGET_SIGNAL_INT:
346 return SIGINT;
347 #endif
348 #if defined(SIGQUIT)
349 case TARGET_SIGNAL_QUIT:
350 return SIGQUIT;
351 #endif
352 #if defined(SIGILL)
353 case TARGET_SIGNAL_ILL:
354 return SIGILL;
355 #endif
356 #if defined(SIGTRAP)
357 case TARGET_SIGNAL_TRAP:
358 return SIGTRAP;
359 #endif
360 #if defined(SIGABRT)
361 case TARGET_SIGNAL_ABRT:
362 return SIGABRT;
363 #endif
364 #if defined(SIGEMT)
365 case TARGET_SIGNAL_EMT:
366 return SIGEMT;
367 #endif
368 #if defined(SIGFPE)
369 case TARGET_SIGNAL_FPE:
370 return SIGFPE;
371 #endif
372 #if defined(SIGKILL)
373 case TARGET_SIGNAL_KILL:
374 return SIGKILL;
375 #endif
376 #if defined(SIGBUS)
377 case TARGET_SIGNAL_BUS:
378 return SIGBUS;
379 #endif
380 #if defined(SIGSEGV)
381 case TARGET_SIGNAL_SEGV:
382 return SIGSEGV;
383 #endif
384 #if defined(SIGSYS)
385 case TARGET_SIGNAL_SYS:
386 return SIGSYS;
387 #endif
388 #if defined(SIGPIPE)
389 case TARGET_SIGNAL_PIPE:
390 return SIGPIPE;
391 #endif
392 #if defined(SIGALRM)
393 case TARGET_SIGNAL_ALRM:
394 return SIGALRM;
395 #endif
396 #if defined(SIGTERM)
397 case TARGET_SIGNAL_TERM:
398 return SIGTERM;
399 #endif
400 #if defined(SIGUSR1)
401 case TARGET_SIGNAL_USR1:
402 return SIGUSR1;
403 #endif
404 #if defined(SIGUSR2)
405 case TARGET_SIGNAL_USR2:
406 return SIGUSR2;
407 #endif
408 #if defined(SIGCHLD) || defined(SIGCLD)
409 case TARGET_SIGNAL_CHLD:
410 #if defined(SIGCHLD)
411 return SIGCHLD;
412 #else
413 return SIGCLD;
414 #endif
415 #endif /* SIGCLD or SIGCHLD */
416 #if defined(SIGPWR)
417 case TARGET_SIGNAL_PWR:
418 return SIGPWR;
419 #endif
420 #if defined(SIGWINCH)
421 case TARGET_SIGNAL_WINCH:
422 return SIGWINCH;
423 #endif
424 #if defined(SIGURG)
425 case TARGET_SIGNAL_URG:
426 return SIGURG;
427 #endif
428 #if defined(SIGIO)
429 case TARGET_SIGNAL_IO:
430 return SIGIO;
431 #endif
432 #if defined(SIGPOLL)
433 case TARGET_SIGNAL_POLL:
434 return SIGPOLL;
435 #endif
436 #if defined(SIGSTOP)
437 case TARGET_SIGNAL_STOP:
438 return SIGSTOP;
439 #endif
440 #if defined(SIGTSTP)
441 case TARGET_SIGNAL_TSTP:
442 return SIGTSTP;
443 #endif
444 #if defined(SIGCONT)
445 case TARGET_SIGNAL_CONT:
446 return SIGCONT;
447 #endif
448 #if defined(SIGTTIN)
449 case TARGET_SIGNAL_TTIN:
450 return SIGTTIN;
451 #endif
452 #if defined(SIGTTOU)
453 case TARGET_SIGNAL_TTOU:
454 return SIGTTOU;
455 #endif
456 #if defined(SIGVTALRM)
457 case TARGET_SIGNAL_VTALRM:
458 return SIGVTALRM;
459 #endif
460 #if defined(SIGPROF)
461 case TARGET_SIGNAL_PROF:
462 return SIGPROF;
463 #endif
464 #if defined(SIGXCPU)
465 case TARGET_SIGNAL_XCPU:
466 return SIGXCPU;
467 #endif
468 #if defined(SIGXFSZ)
469 case TARGET_SIGNAL_XFSZ:
470 return SIGXFSZ;
471 #endif
472 #if defined(SIGWIND)
473 case TARGET_SIGNAL_WIND:
474 return SIGWIND;
475 #endif
476 #if defined(SIGPHONE)
477 case TARGET_SIGNAL_PHONE:
478 return SIGPHONE;
479 #endif
480 #if defined(SIGLOST)
481 case TARGET_SIGNAL_LOST:
482 return SIGLOST;
483 #endif
484 #if defined(SIGWAITING)
485 case TARGET_SIGNAL_WAITING:
486 return SIGWAITING;
487 #endif
488 #if defined(SIGCANCEL)
489 case TARGET_SIGNAL_CANCEL:
490 return SIGCANCEL;
491 #endif
492 #if defined(SIGLWP)
493 case TARGET_SIGNAL_LWP:
494 return SIGLWP;
495 #endif
496 #if defined(SIGDANGER)
497 case TARGET_SIGNAL_DANGER:
498 return SIGDANGER;
499 #endif
500 #if defined(SIGGRANT)
501 case TARGET_SIGNAL_GRANT:
502 return SIGGRANT;
503 #endif
504 #if defined(SIGRETRACT)
505 case TARGET_SIGNAL_RETRACT:
506 return SIGRETRACT;
507 #endif
508 #if defined(SIGMSG)
509 case TARGET_SIGNAL_MSG:
510 return SIGMSG;
511 #endif
512 #if defined(SIGSOUND)
513 case TARGET_SIGNAL_SOUND:
514 return SIGSOUND;
515 #endif
516 #if defined(SIGSAK)
517 case TARGET_SIGNAL_SAK:
518 return SIGSAK;
519 #endif
520 #if defined(SIGPRIO)
521 case TARGET_SIGNAL_PRIO:
522 return SIGPRIO;
523 #endif
524
525 /* Mach exceptions. Assumes that the values for EXC_ are positive! */
526 #if defined(EXC_BAD_ACCESS) && defined(_NSIG)
527 case TARGET_EXC_BAD_ACCESS:
528 return _NSIG + EXC_BAD_ACCESS;
529 #endif
530 #if defined(EXC_BAD_INSTRUCTION) && defined(_NSIG)
531 case TARGET_EXC_BAD_INSTRUCTION:
532 return _NSIG + EXC_BAD_INSTRUCTION;
533 #endif
534 #if defined(EXC_ARITHMETIC) && defined(_NSIG)
535 case TARGET_EXC_ARITHMETIC:
536 return _NSIG + EXC_ARITHMETIC;
537 #endif
538 #if defined(EXC_EMULATION) && defined(_NSIG)
539 case TARGET_EXC_EMULATION:
540 return _NSIG + EXC_EMULATION;
541 #endif
542 #if defined(EXC_SOFTWARE) && defined(_NSIG)
543 case TARGET_EXC_SOFTWARE:
544 return _NSIG + EXC_SOFTWARE;
545 #endif
546 #if defined(EXC_BREAKPOINT) && defined(_NSIG)
547 case TARGET_EXC_BREAKPOINT:
548 return _NSIG + EXC_BREAKPOINT;
549 #endif
550
551 #if defined(SIGINFO)
552 case TARGET_SIGNAL_INFO:
553 return SIGINFO;
554 #endif
555
556 default:
557 #if defined(REALTIME_LO)
558 retsig = 0;
559
560 if (oursig >= TARGET_SIGNAL_REALTIME_33 && oursig <= TARGET_SIGNAL_REALTIME_63) {
561 /* This block of signals is continuous, and
562 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
563 retsig = (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + 33;
564 } else if (oursig == TARGET_SIGNAL_REALTIME_32) {
565 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
566 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
567 retsig = 32;
568 } else if (oursig >= TARGET_SIGNAL_REALTIME_64 && oursig <= TARGET_SIGNAL_REALTIME_127) {
569 /* This block of signals is continuous, and
570 TARGET_SIGNAL_REALTIME_64 is 64 by definition. */
571 retsig = (int)oursig - (int)TARGET_SIGNAL_REALTIME_64 + 64;
572 }
573
574 if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
575 return retsig;
576 #endif
577
578 *oursig_ok = 0;
579 return 0;
580 }
581 }
582
583 int
target_signal_to_host(enum target_signal oursig)584 target_signal_to_host (enum target_signal oursig) {
585 int oursig_ok;
586 int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
587 if (!oursig_ok)
588 return 0;
589 else
590 return targ_signo;
591 }
592
593 /* Convert nto signal to gdb signal. */
594 enum target_signal
target_signal_from_nto(int sig)595 target_signal_from_nto (int sig) {
596 int i;
597 if (sig == 0)
598 return 0;
599
600 for (i = 0; i != ARRAY_SIZE (sig_map); i++) {
601 if (sig_map[i].nto_sig == sig)
602 return sig_map[i].gdb_sig;
603 }
604
605 if (sig >= NTO_SIGRTMIN && sig <= NTO_SIGRTMAX)
606 return TARGET_SIGNAL_REALTIME_41 + sig - NTO_SIGRTMIN;
607 return target_signal_from_host (sig);
608 }
609
610 int
host_signal_from_nto(int sig)611 host_signal_from_nto (int sig) {
612 return target_signal_to_host (target_signal_to_host (sig));
613 }
614