xref: /openbmc/qemu/linux-user/signal.c (revision 753d11f2)
1 /*
2  *  Emulation of Linux signals
3  *
4  *  Copyright (c) 2003 Fabrice Bellard
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <stdarg.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <assert.h>
26 #include <sys/ucontext.h>
27 #include <sys/resource.h>
28 
29 #include "qemu.h"
30 #include "qemu-common.h"
31 #include "target_signal.h"
32 
33 //#define DEBUG_SIGNAL
34 
35 static struct target_sigaltstack target_sigaltstack_used = {
36     .ss_sp = 0,
37     .ss_size = 0,
38     .ss_flags = TARGET_SS_DISABLE,
39 };
40 
41 static struct target_sigaction sigact_table[TARGET_NSIG];
42 
43 static void host_signal_handler(int host_signum, siginfo_t *info,
44                                 void *puc);
45 
46 static uint8_t host_to_target_signal_table[_NSIG] = {
47     [SIGHUP] = TARGET_SIGHUP,
48     [SIGINT] = TARGET_SIGINT,
49     [SIGQUIT] = TARGET_SIGQUIT,
50     [SIGILL] = TARGET_SIGILL,
51     [SIGTRAP] = TARGET_SIGTRAP,
52     [SIGABRT] = TARGET_SIGABRT,
53 /*    [SIGIOT] = TARGET_SIGIOT,*/
54     [SIGBUS] = TARGET_SIGBUS,
55     [SIGFPE] = TARGET_SIGFPE,
56     [SIGKILL] = TARGET_SIGKILL,
57     [SIGUSR1] = TARGET_SIGUSR1,
58     [SIGSEGV] = TARGET_SIGSEGV,
59     [SIGUSR2] = TARGET_SIGUSR2,
60     [SIGPIPE] = TARGET_SIGPIPE,
61     [SIGALRM] = TARGET_SIGALRM,
62     [SIGTERM] = TARGET_SIGTERM,
63 #ifdef SIGSTKFLT
64     [SIGSTKFLT] = TARGET_SIGSTKFLT,
65 #endif
66     [SIGCHLD] = TARGET_SIGCHLD,
67     [SIGCONT] = TARGET_SIGCONT,
68     [SIGSTOP] = TARGET_SIGSTOP,
69     [SIGTSTP] = TARGET_SIGTSTP,
70     [SIGTTIN] = TARGET_SIGTTIN,
71     [SIGTTOU] = TARGET_SIGTTOU,
72     [SIGURG] = TARGET_SIGURG,
73     [SIGXCPU] = TARGET_SIGXCPU,
74     [SIGXFSZ] = TARGET_SIGXFSZ,
75     [SIGVTALRM] = TARGET_SIGVTALRM,
76     [SIGPROF] = TARGET_SIGPROF,
77     [SIGWINCH] = TARGET_SIGWINCH,
78     [SIGIO] = TARGET_SIGIO,
79     [SIGPWR] = TARGET_SIGPWR,
80     [SIGSYS] = TARGET_SIGSYS,
81     /* next signals stay the same */
82     /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
83        host libpthread signals.  This assumes noone actually uses SIGRTMAX :-/
84        To fix this properly we need to do manual signal delivery multiplexed
85        over a single host signal.  */
86     [__SIGRTMIN] = __SIGRTMAX,
87     [__SIGRTMAX] = __SIGRTMIN,
88 };
89 static uint8_t target_to_host_signal_table[_NSIG];
90 
91 static inline int on_sig_stack(unsigned long sp)
92 {
93     return (sp - target_sigaltstack_used.ss_sp
94             < target_sigaltstack_used.ss_size);
95 }
96 
97 static inline int sas_ss_flags(unsigned long sp)
98 {
99     return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
100             : on_sig_stack(sp) ? SS_ONSTACK : 0);
101 }
102 
103 int host_to_target_signal(int sig)
104 {
105     if (sig >= _NSIG)
106         return sig;
107     return host_to_target_signal_table[sig];
108 }
109 
110 int target_to_host_signal(int sig)
111 {
112     if (sig >= _NSIG)
113         return sig;
114     return target_to_host_signal_table[sig];
115 }
116 
117 static inline void target_sigemptyset(target_sigset_t *set)
118 {
119     memset(set, 0, sizeof(*set));
120 }
121 
122 static inline void target_sigaddset(target_sigset_t *set, int signum)
123 {
124     signum--;
125     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
126     set->sig[signum / TARGET_NSIG_BPW] |= mask;
127 }
128 
129 static inline int target_sigismember(const target_sigset_t *set, int signum)
130 {
131     signum--;
132     abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
133     return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
134 }
135 
136 static void host_to_target_sigset_internal(target_sigset_t *d,
137                                            const sigset_t *s)
138 {
139     int i;
140     target_sigemptyset(d);
141     for (i = 1; i <= TARGET_NSIG; i++) {
142         if (sigismember(s, i)) {
143             target_sigaddset(d, host_to_target_signal(i));
144         }
145     }
146 }
147 
148 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
149 {
150     target_sigset_t d1;
151     int i;
152 
153     host_to_target_sigset_internal(&d1, s);
154     for(i = 0;i < TARGET_NSIG_WORDS; i++)
155         d->sig[i] = tswapl(d1.sig[i]);
156 }
157 
158 static void target_to_host_sigset_internal(sigset_t *d,
159                                            const target_sigset_t *s)
160 {
161     int i;
162     sigemptyset(d);
163     for (i = 1; i <= TARGET_NSIG; i++) {
164         if (target_sigismember(s, i)) {
165             sigaddset(d, target_to_host_signal(i));
166         }
167      }
168 }
169 
170 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
171 {
172     target_sigset_t s1;
173     int i;
174 
175     for(i = 0;i < TARGET_NSIG_WORDS; i++)
176         s1.sig[i] = tswapl(s->sig[i]);
177     target_to_host_sigset_internal(d, &s1);
178 }
179 
180 void host_to_target_old_sigset(abi_ulong *old_sigset,
181                                const sigset_t *sigset)
182 {
183     target_sigset_t d;
184     host_to_target_sigset(&d, sigset);
185     *old_sigset = d.sig[0];
186 }
187 
188 void target_to_host_old_sigset(sigset_t *sigset,
189                                const abi_ulong *old_sigset)
190 {
191     target_sigset_t d;
192     int i;
193 
194     d.sig[0] = *old_sigset;
195     for(i = 1;i < TARGET_NSIG_WORDS; i++)
196         d.sig[i] = 0;
197     target_to_host_sigset(sigset, &d);
198 }
199 
200 /* siginfo conversion */
201 
202 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
203                                                  const siginfo_t *info)
204 {
205     int sig;
206     sig = host_to_target_signal(info->si_signo);
207     tinfo->si_signo = sig;
208     tinfo->si_errno = 0;
209     tinfo->si_code = info->si_code;
210     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
211         sig == SIGBUS || sig == SIGTRAP) {
212         /* should never come here, but who knows. The information for
213            the target is irrelevant */
214         tinfo->_sifields._sigfault._addr = 0;
215     } else if (sig == SIGIO) {
216 	tinfo->_sifields._sigpoll._fd = info->si_fd;
217     } else if (sig >= TARGET_SIGRTMIN) {
218         tinfo->_sifields._rt._pid = info->si_pid;
219         tinfo->_sifields._rt._uid = info->si_uid;
220         /* XXX: potential problem if 64 bit */
221         tinfo->_sifields._rt._sigval.sival_ptr =
222             (abi_ulong)(unsigned long)info->si_value.sival_ptr;
223     }
224 }
225 
226 static void tswap_siginfo(target_siginfo_t *tinfo,
227                           const target_siginfo_t *info)
228 {
229     int sig;
230     sig = info->si_signo;
231     tinfo->si_signo = tswap32(sig);
232     tinfo->si_errno = tswap32(info->si_errno);
233     tinfo->si_code = tswap32(info->si_code);
234     if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
235         sig == SIGBUS || sig == SIGTRAP) {
236         tinfo->_sifields._sigfault._addr =
237             tswapl(info->_sifields._sigfault._addr);
238     } else if (sig == SIGIO) {
239 	tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
240     } else if (sig >= TARGET_SIGRTMIN) {
241         tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
242         tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
243         tinfo->_sifields._rt._sigval.sival_ptr =
244             tswapl(info->_sifields._rt._sigval.sival_ptr);
245     }
246 }
247 
248 
249 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
250 {
251     host_to_target_siginfo_noswap(tinfo, info);
252     tswap_siginfo(tinfo, tinfo);
253 }
254 
255 /* XXX: we support only POSIX RT signals are used. */
256 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
257 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
258 {
259     info->si_signo = tswap32(tinfo->si_signo);
260     info->si_errno = tswap32(tinfo->si_errno);
261     info->si_code = tswap32(tinfo->si_code);
262     info->si_pid = tswap32(tinfo->_sifields._rt._pid);
263     info->si_uid = tswap32(tinfo->_sifields._rt._uid);
264     info->si_value.sival_ptr =
265             (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
266 }
267 
268 static int fatal_signal (int sig)
269 {
270     switch (sig) {
271     case TARGET_SIGCHLD:
272     case TARGET_SIGURG:
273     case TARGET_SIGWINCH:
274         /* Ignored by default.  */
275         return 0;
276     case TARGET_SIGCONT:
277     case TARGET_SIGSTOP:
278     case TARGET_SIGTSTP:
279     case TARGET_SIGTTIN:
280     case TARGET_SIGTTOU:
281         /* Job control signals.  */
282         return 0;
283     default:
284         return 1;
285     }
286 }
287 
288 /* returns 1 if given signal should dump core if not handled */
289 static int core_dump_signal(int sig)
290 {
291     switch (sig) {
292     case TARGET_SIGABRT:
293     case TARGET_SIGFPE:
294     case TARGET_SIGILL:
295     case TARGET_SIGQUIT:
296     case TARGET_SIGSEGV:
297     case TARGET_SIGTRAP:
298     case TARGET_SIGBUS:
299         return (1);
300     default:
301         return (0);
302     }
303 }
304 
305 void signal_init(void)
306 {
307     struct sigaction act;
308     struct sigaction oact;
309     int i, j;
310     int host_sig;
311 
312     /* generate signal conversion tables */
313     for(i = 1; i < _NSIG; i++) {
314         if (host_to_target_signal_table[i] == 0)
315             host_to_target_signal_table[i] = i;
316     }
317     for(i = 1; i < _NSIG; i++) {
318         j = host_to_target_signal_table[i];
319         target_to_host_signal_table[j] = i;
320     }
321 
322     /* set all host signal handlers. ALL signals are blocked during
323        the handlers to serialize them. */
324     memset(sigact_table, 0, sizeof(sigact_table));
325 
326     sigfillset(&act.sa_mask);
327     act.sa_flags = SA_SIGINFO;
328     act.sa_sigaction = host_signal_handler;
329     for(i = 1; i <= TARGET_NSIG; i++) {
330         host_sig = target_to_host_signal(i);
331         sigaction(host_sig, NULL, &oact);
332         if (oact.sa_sigaction == (void *)SIG_IGN) {
333             sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
334         } else if (oact.sa_sigaction == (void *)SIG_DFL) {
335             sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
336         }
337         /* If there's already a handler installed then something has
338            gone horribly wrong, so don't even try to handle that case.  */
339         /* Install some handlers for our own use.  We need at least
340            SIGSEGV and SIGBUS, to detect exceptions.  We can not just
341            trap all signals because it affects syscall interrupt
342            behavior.  But do trap all default-fatal signals.  */
343         if (fatal_signal (i))
344             sigaction(host_sig, &act, NULL);
345     }
346 }
347 
348 /* signal queue handling */
349 
350 static inline struct sigqueue *alloc_sigqueue(CPUState *env)
351 {
352     TaskState *ts = env->opaque;
353     struct sigqueue *q = ts->first_free;
354     if (!q)
355         return NULL;
356     ts->first_free = q->next;
357     return q;
358 }
359 
360 static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
361 {
362     TaskState *ts = env->opaque;
363     q->next = ts->first_free;
364     ts->first_free = q;
365 }
366 
367 /* abort execution with signal */
368 static void QEMU_NORETURN force_sig(int target_sig)
369 {
370     TaskState *ts = (TaskState *)thread_env->opaque;
371     int host_sig, core_dumped = 0;
372     struct sigaction act;
373     host_sig = target_to_host_signal(target_sig);
374     gdb_signalled(thread_env, target_sig);
375 
376     /* dump core if supported by target binary format */
377     if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
378         stop_all_tasks();
379         core_dumped =
380             ((*ts->bprm->core_dump)(target_sig, thread_env) == 0);
381     }
382     if (core_dumped) {
383         /* we already dumped the core of target process, we don't want
384          * a coredump of qemu itself */
385         struct rlimit nodump;
386         getrlimit(RLIMIT_CORE, &nodump);
387         nodump.rlim_cur=0;
388         setrlimit(RLIMIT_CORE, &nodump);
389         (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
390             target_sig, strsignal(host_sig), "core dumped" );
391     }
392 
393     /* The proper exit code for dying from an uncaught signal is
394      * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
395      * a negative value.  To get the proper exit code we need to
396      * actually die from an uncaught signal.  Here the default signal
397      * handler is installed, we send ourself a signal and we wait for
398      * it to arrive. */
399     sigfillset(&act.sa_mask);
400     act.sa_handler = SIG_DFL;
401     sigaction(host_sig, &act, NULL);
402 
403     /* For some reason raise(host_sig) doesn't send the signal when
404      * statically linked on x86-64. */
405     kill(getpid(), host_sig);
406 
407     /* Make sure the signal isn't masked (just reuse the mask inside
408     of act) */
409     sigdelset(&act.sa_mask, host_sig);
410     sigsuspend(&act.sa_mask);
411 
412     /* unreachable */
413     abort();
414 }
415 
416 /* queue a signal so that it will be send to the virtual CPU as soon
417    as possible */
418 int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
419 {
420     TaskState *ts = env->opaque;
421     struct emulated_sigtable *k;
422     struct sigqueue *q, **pq;
423     abi_ulong handler;
424     int queue;
425 
426 #if defined(DEBUG_SIGNAL)
427     fprintf(stderr, "queue_signal: sig=%d\n",
428             sig);
429 #endif
430     k = &ts->sigtab[sig - 1];
431     queue = gdb_queuesig ();
432     handler = sigact_table[sig - 1]._sa_handler;
433     if (!queue && handler == TARGET_SIG_DFL) {
434         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
435             kill(getpid(),SIGSTOP);
436             return 0;
437         } else
438         /* default handler : ignore some signal. The other are fatal */
439         if (sig != TARGET_SIGCHLD &&
440             sig != TARGET_SIGURG &&
441             sig != TARGET_SIGWINCH &&
442             sig != TARGET_SIGCONT) {
443             force_sig(sig);
444         } else {
445             return 0; /* indicate ignored */
446         }
447     } else if (!queue && handler == TARGET_SIG_IGN) {
448         /* ignore signal */
449         return 0;
450     } else if (!queue && handler == TARGET_SIG_ERR) {
451         force_sig(sig);
452     } else {
453         pq = &k->first;
454         if (sig < TARGET_SIGRTMIN) {
455             /* if non real time signal, we queue exactly one signal */
456             if (!k->pending)
457                 q = &k->info;
458             else
459                 return 0;
460         } else {
461             if (!k->pending) {
462                 /* first signal */
463                 q = &k->info;
464             } else {
465                 q = alloc_sigqueue(env);
466                 if (!q)
467                     return -EAGAIN;
468                 while (*pq != NULL)
469                     pq = &(*pq)->next;
470             }
471         }
472         *pq = q;
473         q->info = *info;
474         q->next = NULL;
475         k->pending = 1;
476         /* signal that a new signal is pending */
477         ts->signal_pending = 1;
478         return 1; /* indicates that the signal was queued */
479     }
480 }
481 
482 static void host_signal_handler(int host_signum, siginfo_t *info,
483                                 void *puc)
484 {
485     int sig;
486     target_siginfo_t tinfo;
487 
488     /* the CPU emulator uses some host signals to detect exceptions,
489        we forward to it some signals */
490     if ((host_signum == SIGSEGV || host_signum == SIGBUS)
491         && info->si_code > 0) {
492         if (cpu_signal_handler(host_signum, info, puc))
493             return;
494     }
495 
496     /* get target signal number */
497     sig = host_to_target_signal(host_signum);
498     if (sig < 1 || sig > TARGET_NSIG)
499         return;
500 #if defined(DEBUG_SIGNAL)
501     fprintf(stderr, "qemu: got signal %d\n", sig);
502 #endif
503     host_to_target_siginfo_noswap(&tinfo, info);
504     if (queue_signal(thread_env, sig, &tinfo) == 1) {
505         /* interrupt the virtual CPU as soon as possible */
506         cpu_exit(thread_env);
507     }
508 }
509 
510 /* do_sigaltstack() returns target values and errnos. */
511 /* compare linux/kernel/signal.c:do_sigaltstack() */
512 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
513 {
514     int ret;
515     struct target_sigaltstack oss;
516 
517     /* XXX: test errors */
518     if(uoss_addr)
519     {
520         __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
521         __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
522         __put_user(sas_ss_flags(sp), &oss.ss_flags);
523     }
524 
525     if(uss_addr)
526     {
527         struct target_sigaltstack *uss;
528         struct target_sigaltstack ss;
529 
530 	ret = -TARGET_EFAULT;
531         if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
532 	    || __get_user(ss.ss_sp, &uss->ss_sp)
533 	    || __get_user(ss.ss_size, &uss->ss_size)
534 	    || __get_user(ss.ss_flags, &uss->ss_flags))
535             goto out;
536         unlock_user_struct(uss, uss_addr, 0);
537 
538 	ret = -TARGET_EPERM;
539 	if (on_sig_stack(sp))
540             goto out;
541 
542 	ret = -TARGET_EINVAL;
543 	if (ss.ss_flags != TARGET_SS_DISABLE
544             && ss.ss_flags != TARGET_SS_ONSTACK
545             && ss.ss_flags != 0)
546             goto out;
547 
548 	if (ss.ss_flags == TARGET_SS_DISABLE) {
549             ss.ss_size = 0;
550             ss.ss_sp = 0;
551 	} else {
552             ret = -TARGET_ENOMEM;
553             if (ss.ss_size < MINSIGSTKSZ)
554                 goto out;
555 	}
556 
557         target_sigaltstack_used.ss_sp = ss.ss_sp;
558         target_sigaltstack_used.ss_size = ss.ss_size;
559     }
560 
561     if (uoss_addr) {
562         ret = -TARGET_EFAULT;
563         if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
564             goto out;
565     }
566 
567     ret = 0;
568 out:
569     return ret;
570 }
571 
572 /* do_sigaction() return host values and errnos */
573 int do_sigaction(int sig, const struct target_sigaction *act,
574                  struct target_sigaction *oact)
575 {
576     struct target_sigaction *k;
577     struct sigaction act1;
578     int host_sig;
579     int ret = 0;
580 
581     if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
582         return -EINVAL;
583     k = &sigact_table[sig - 1];
584 #if defined(DEBUG_SIGNAL)
585     fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n",
586             sig, act, oact);
587 #endif
588     if (oact) {
589         oact->_sa_handler = tswapl(k->_sa_handler);
590         oact->sa_flags = tswapl(k->sa_flags);
591 #if !defined(TARGET_MIPS)
592         oact->sa_restorer = tswapl(k->sa_restorer);
593 #endif
594         oact->sa_mask = k->sa_mask;
595     }
596     if (act) {
597         /* FIXME: This is not threadsafe.  */
598         k->_sa_handler = tswapl(act->_sa_handler);
599         k->sa_flags = tswapl(act->sa_flags);
600 #if !defined(TARGET_MIPS)
601         k->sa_restorer = tswapl(act->sa_restorer);
602 #endif
603         k->sa_mask = act->sa_mask;
604 
605         /* we update the host linux signal state */
606         host_sig = target_to_host_signal(sig);
607         if (host_sig != SIGSEGV && host_sig != SIGBUS) {
608             sigfillset(&act1.sa_mask);
609             act1.sa_flags = SA_SIGINFO;
610             if (k->sa_flags & TARGET_SA_RESTART)
611                 act1.sa_flags |= SA_RESTART;
612             /* NOTE: it is important to update the host kernel signal
613                ignore state to avoid getting unexpected interrupted
614                syscalls */
615             if (k->_sa_handler == TARGET_SIG_IGN) {
616                 act1.sa_sigaction = (void *)SIG_IGN;
617             } else if (k->_sa_handler == TARGET_SIG_DFL) {
618                 if (fatal_signal (sig))
619                     act1.sa_sigaction = host_signal_handler;
620                 else
621                     act1.sa_sigaction = (void *)SIG_DFL;
622             } else {
623                 act1.sa_sigaction = host_signal_handler;
624             }
625             ret = sigaction(host_sig, &act1, NULL);
626         }
627     }
628     return ret;
629 }
630 
631 static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
632                                        const target_siginfo_t *info)
633 {
634     tswap_siginfo(tinfo, info);
635     return 0;
636 }
637 
638 static inline int current_exec_domain_sig(int sig)
639 {
640     return /* current->exec_domain && current->exec_domain->signal_invmap
641 	      && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
642 }
643 
644 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
645 
646 /* from the Linux kernel */
647 
648 struct target_fpreg {
649 	uint16_t significand[4];
650 	uint16_t exponent;
651 };
652 
653 struct target_fpxreg {
654 	uint16_t significand[4];
655 	uint16_t exponent;
656 	uint16_t padding[3];
657 };
658 
659 struct target_xmmreg {
660 	abi_ulong element[4];
661 };
662 
663 struct target_fpstate {
664 	/* Regular FPU environment */
665         abi_ulong       cw;
666         abi_ulong       sw;
667         abi_ulong       tag;
668         abi_ulong       ipoff;
669         abi_ulong       cssel;
670         abi_ulong       dataoff;
671         abi_ulong       datasel;
672 	struct target_fpreg	_st[8];
673 	uint16_t	status;
674 	uint16_t	magic;		/* 0xffff = regular FPU data only */
675 
676 	/* FXSR FPU environment */
677         abi_ulong       _fxsr_env[6];   /* FXSR FPU env is ignored */
678         abi_ulong       mxcsr;
679         abi_ulong       reserved;
680 	struct target_fpxreg	_fxsr_st[8];	/* FXSR FPU reg data is ignored */
681 	struct target_xmmreg	_xmm[8];
682         abi_ulong       padding[56];
683 };
684 
685 #define X86_FXSR_MAGIC		0x0000
686 
687 struct target_sigcontext {
688 	uint16_t gs, __gsh;
689 	uint16_t fs, __fsh;
690 	uint16_t es, __esh;
691 	uint16_t ds, __dsh;
692         abi_ulong edi;
693         abi_ulong esi;
694         abi_ulong ebp;
695         abi_ulong esp;
696         abi_ulong ebx;
697         abi_ulong edx;
698         abi_ulong ecx;
699         abi_ulong eax;
700         abi_ulong trapno;
701         abi_ulong err;
702         abi_ulong eip;
703 	uint16_t cs, __csh;
704         abi_ulong eflags;
705         abi_ulong esp_at_signal;
706 	uint16_t ss, __ssh;
707         abi_ulong fpstate; /* pointer */
708         abi_ulong oldmask;
709         abi_ulong cr2;
710 };
711 
712 struct target_ucontext {
713         abi_ulong         tuc_flags;
714         abi_ulong         tuc_link;
715 	target_stack_t	  tuc_stack;
716 	struct target_sigcontext tuc_mcontext;
717 	target_sigset_t	  tuc_sigmask;	/* mask last for extensibility */
718 };
719 
720 struct sigframe
721 {
722     abi_ulong pretcode;
723     int sig;
724     struct target_sigcontext sc;
725     struct target_fpstate fpstate;
726     abi_ulong extramask[TARGET_NSIG_WORDS-1];
727     char retcode[8];
728 };
729 
730 struct rt_sigframe
731 {
732     abi_ulong pretcode;
733     int sig;
734     abi_ulong pinfo;
735     abi_ulong puc;
736     struct target_siginfo info;
737     struct target_ucontext uc;
738     struct target_fpstate fpstate;
739     char retcode[8];
740 };
741 
742 /*
743  * Set up a signal frame.
744  */
745 
746 /* XXX: save x87 state */
747 static int
748 setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
749 		 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
750 {
751 	int err = 0;
752         uint16_t magic;
753 
754 	/* already locked in setup_frame() */
755 	err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
756 	err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
757 	err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
758 	err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
759 	err |= __put_user(env->regs[R_EDI], &sc->edi);
760 	err |= __put_user(env->regs[R_ESI], &sc->esi);
761 	err |= __put_user(env->regs[R_EBP], &sc->ebp);
762 	err |= __put_user(env->regs[R_ESP], &sc->esp);
763 	err |= __put_user(env->regs[R_EBX], &sc->ebx);
764 	err |= __put_user(env->regs[R_EDX], &sc->edx);
765 	err |= __put_user(env->regs[R_ECX], &sc->ecx);
766 	err |= __put_user(env->regs[R_EAX], &sc->eax);
767 	err |= __put_user(env->exception_index, &sc->trapno);
768 	err |= __put_user(env->error_code, &sc->err);
769 	err |= __put_user(env->eip, &sc->eip);
770 	err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
771 	err |= __put_user(env->eflags, &sc->eflags);
772 	err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
773 	err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
774 
775         cpu_x86_fsave(env, fpstate_addr, 1);
776         fpstate->status = fpstate->sw;
777         magic = 0xffff;
778         err |= __put_user(magic, &fpstate->magic);
779         err |= __put_user(fpstate_addr, &sc->fpstate);
780 
781 	/* non-iBCS2 extensions.. */
782 	err |= __put_user(mask, &sc->oldmask);
783 	err |= __put_user(env->cr[2], &sc->cr2);
784 	return err;
785 }
786 
787 /*
788  * Determine which stack to use..
789  */
790 
791 static inline abi_ulong
792 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
793 {
794 	unsigned long esp;
795 
796 	/* Default to using normal stack */
797 	esp = env->regs[R_ESP];
798 	/* This is the X/Open sanctioned signal stack switching.  */
799         if (ka->sa_flags & TARGET_SA_ONSTACK) {
800             if (sas_ss_flags(esp) == 0)
801                 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
802         }
803 
804 	/* This is the legacy signal stack switching. */
805 	else
806         if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
807             !(ka->sa_flags & TARGET_SA_RESTORER) &&
808             ka->sa_restorer) {
809             esp = (unsigned long) ka->sa_restorer;
810 	}
811         return (esp - frame_size) & -8ul;
812 }
813 
814 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
815 static void setup_frame(int sig, struct target_sigaction *ka,
816 			target_sigset_t *set, CPUX86State *env)
817 {
818 	abi_ulong frame_addr;
819 	struct sigframe *frame;
820 	int i, err = 0;
821 
822 	frame_addr = get_sigframe(ka, env, sizeof(*frame));
823 
824 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
825 		goto give_sigsegv;
826 
827 	err |= __put_user(current_exec_domain_sig(sig),
828 		          &frame->sig);
829 	if (err)
830 		goto give_sigsegv;
831 
832 	setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
833                          frame_addr + offsetof(struct sigframe, fpstate));
834 	if (err)
835 		goto give_sigsegv;
836 
837         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
838             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
839                 goto give_sigsegv;
840         }
841 
842 	/* Set up to return from userspace.  If provided, use a stub
843 	   already in userspace.  */
844 	if (ka->sa_flags & TARGET_SA_RESTORER) {
845 		err |= __put_user(ka->sa_restorer, &frame->pretcode);
846 	} else {
847                 uint16_t val16;
848                 abi_ulong retcode_addr;
849                 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
850 		err |= __put_user(retcode_addr, &frame->pretcode);
851 		/* This is popl %eax ; movl $,%eax ; int $0x80 */
852                 val16 = 0xb858;
853 		err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
854 		err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
855                 val16 = 0x80cd;
856 		err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
857 	}
858 
859 	if (err)
860 		goto give_sigsegv;
861 
862 	/* Set up registers for signal handler */
863 	env->regs[R_ESP] = frame_addr;
864 	env->eip = ka->_sa_handler;
865 
866         cpu_x86_load_seg(env, R_DS, __USER_DS);
867         cpu_x86_load_seg(env, R_ES, __USER_DS);
868         cpu_x86_load_seg(env, R_SS, __USER_DS);
869         cpu_x86_load_seg(env, R_CS, __USER_CS);
870 	env->eflags &= ~TF_MASK;
871 
872 	unlock_user_struct(frame, frame_addr, 1);
873 
874 	return;
875 
876 give_sigsegv:
877 	unlock_user_struct(frame, frame_addr, 1);
878 	if (sig == TARGET_SIGSEGV)
879 		ka->_sa_handler = TARGET_SIG_DFL;
880 	force_sig(TARGET_SIGSEGV /* , current */);
881 }
882 
883 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
884 static void setup_rt_frame(int sig, struct target_sigaction *ka,
885                            target_siginfo_t *info,
886 			   target_sigset_t *set, CPUX86State *env)
887 {
888         abi_ulong frame_addr, addr;
889 	struct rt_sigframe *frame;
890 	int i, err = 0;
891 
892 	frame_addr = get_sigframe(ka, env, sizeof(*frame));
893 
894 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
895 		goto give_sigsegv;
896 
897 	err |= __put_user(current_exec_domain_sig(sig),
898 			  &frame->sig);
899         addr = frame_addr + offsetof(struct rt_sigframe, info);
900 	err |= __put_user(addr, &frame->pinfo);
901         addr = frame_addr + offsetof(struct rt_sigframe, uc);
902 	err |= __put_user(addr, &frame->puc);
903 	err |= copy_siginfo_to_user(&frame->info, info);
904 	if (err)
905 		goto give_sigsegv;
906 
907 	/* Create the ucontext.  */
908 	err |= __put_user(0, &frame->uc.tuc_flags);
909 	err |= __put_user(0, &frame->uc.tuc_link);
910 	err |= __put_user(target_sigaltstack_used.ss_sp,
911 			  &frame->uc.tuc_stack.ss_sp);
912 	err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
913 			  &frame->uc.tuc_stack.ss_flags);
914 	err |= __put_user(target_sigaltstack_used.ss_size,
915 			  &frame->uc.tuc_stack.ss_size);
916 	err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
917 			        env, set->sig[0],
918                                 frame_addr + offsetof(struct rt_sigframe, fpstate));
919         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
920             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
921                 goto give_sigsegv;
922         }
923 
924 	/* Set up to return from userspace.  If provided, use a stub
925 	   already in userspace.  */
926 	if (ka->sa_flags & TARGET_SA_RESTORER) {
927 		err |= __put_user(ka->sa_restorer, &frame->pretcode);
928 	} else {
929                 uint16_t val16;
930                 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
931 		err |= __put_user(addr, &frame->pretcode);
932 		/* This is movl $,%eax ; int $0x80 */
933                 err |= __put_user(0xb8, (char *)(frame->retcode+0));
934 		err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
935                 val16 = 0x80cd;
936                 err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
937 	}
938 
939 	if (err)
940 		goto give_sigsegv;
941 
942 	/* Set up registers for signal handler */
943 	env->regs[R_ESP] = frame_addr;
944 	env->eip = ka->_sa_handler;
945 
946         cpu_x86_load_seg(env, R_DS, __USER_DS);
947         cpu_x86_load_seg(env, R_ES, __USER_DS);
948         cpu_x86_load_seg(env, R_SS, __USER_DS);
949         cpu_x86_load_seg(env, R_CS, __USER_CS);
950 	env->eflags &= ~TF_MASK;
951 
952 	unlock_user_struct(frame, frame_addr, 1);
953 
954 	return;
955 
956 give_sigsegv:
957 	unlock_user_struct(frame, frame_addr, 1);
958 	if (sig == TARGET_SIGSEGV)
959 		ka->_sa_handler = TARGET_SIG_DFL;
960 	force_sig(TARGET_SIGSEGV /* , current */);
961 }
962 
963 static int
964 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
965 {
966 	unsigned int err = 0;
967         abi_ulong fpstate_addr;
968         unsigned int tmpflags;
969 
970         cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
971         cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
972         cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
973         cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
974 
975         env->regs[R_EDI] = tswapl(sc->edi);
976         env->regs[R_ESI] = tswapl(sc->esi);
977         env->regs[R_EBP] = tswapl(sc->ebp);
978         env->regs[R_ESP] = tswapl(sc->esp);
979         env->regs[R_EBX] = tswapl(sc->ebx);
980         env->regs[R_EDX] = tswapl(sc->edx);
981         env->regs[R_ECX] = tswapl(sc->ecx);
982         env->eip = tswapl(sc->eip);
983 
984         cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
985         cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
986 
987         tmpflags = tswapl(sc->eflags);
988         env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
989         //		regs->orig_eax = -1;		/* disable syscall checks */
990 
991         fpstate_addr = tswapl(sc->fpstate);
992 	if (fpstate_addr != 0) {
993                 if (!access_ok(VERIFY_READ, fpstate_addr,
994                                sizeof(struct target_fpstate)))
995                         goto badframe;
996                 cpu_x86_frstor(env, fpstate_addr, 1);
997 	}
998 
999         *peax = tswapl(sc->eax);
1000 	return err;
1001 badframe:
1002 	return 1;
1003 }
1004 
1005 long do_sigreturn(CPUX86State *env)
1006 {
1007     struct sigframe *frame;
1008     abi_ulong frame_addr = env->regs[R_ESP] - 8;
1009     target_sigset_t target_set;
1010     sigset_t set;
1011     int eax, i;
1012 
1013 #if defined(DEBUG_SIGNAL)
1014     fprintf(stderr, "do_sigreturn\n");
1015 #endif
1016     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1017         goto badframe;
1018     /* set blocked signals */
1019     if (__get_user(target_set.sig[0], &frame->sc.oldmask))
1020         goto badframe;
1021     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1022         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
1023             goto badframe;
1024     }
1025 
1026     target_to_host_sigset_internal(&set, &target_set);
1027     sigprocmask(SIG_SETMASK, &set, NULL);
1028 
1029     /* restore registers */
1030     if (restore_sigcontext(env, &frame->sc, &eax))
1031         goto badframe;
1032     unlock_user_struct(frame, frame_addr, 0);
1033     return eax;
1034 
1035 badframe:
1036     unlock_user_struct(frame, frame_addr, 0);
1037     force_sig(TARGET_SIGSEGV);
1038     return 0;
1039 }
1040 
1041 long do_rt_sigreturn(CPUX86State *env)
1042 {
1043         abi_ulong frame_addr;
1044 	struct rt_sigframe *frame;
1045         sigset_t set;
1046 	int eax;
1047 
1048         frame_addr = env->regs[R_ESP] - 4;
1049         if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1050                 goto badframe;
1051         target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1052         sigprocmask(SIG_SETMASK, &set, NULL);
1053 
1054 	if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
1055 		goto badframe;
1056 
1057 	if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1058                            get_sp_from_cpustate(env)) == -EFAULT)
1059 		goto badframe;
1060 
1061         unlock_user_struct(frame, frame_addr, 0);
1062 	return eax;
1063 
1064 badframe:
1065         unlock_user_struct(frame, frame_addr, 0);
1066         force_sig(TARGET_SIGSEGV);
1067 	return 0;
1068 }
1069 
1070 #elif defined(TARGET_ARM)
1071 
1072 struct target_sigcontext {
1073 	abi_ulong trap_no;
1074 	abi_ulong error_code;
1075 	abi_ulong oldmask;
1076 	abi_ulong arm_r0;
1077 	abi_ulong arm_r1;
1078 	abi_ulong arm_r2;
1079 	abi_ulong arm_r3;
1080 	abi_ulong arm_r4;
1081 	abi_ulong arm_r5;
1082 	abi_ulong arm_r6;
1083 	abi_ulong arm_r7;
1084 	abi_ulong arm_r8;
1085 	abi_ulong arm_r9;
1086 	abi_ulong arm_r10;
1087 	abi_ulong arm_fp;
1088 	abi_ulong arm_ip;
1089 	abi_ulong arm_sp;
1090 	abi_ulong arm_lr;
1091 	abi_ulong arm_pc;
1092 	abi_ulong arm_cpsr;
1093 	abi_ulong fault_address;
1094 };
1095 
1096 struct target_ucontext_v1 {
1097     abi_ulong tuc_flags;
1098     abi_ulong tuc_link;
1099     target_stack_t tuc_stack;
1100     struct target_sigcontext tuc_mcontext;
1101     target_sigset_t  tuc_sigmask;	/* mask last for extensibility */
1102 };
1103 
1104 struct target_ucontext_v2 {
1105     abi_ulong tuc_flags;
1106     abi_ulong tuc_link;
1107     target_stack_t tuc_stack;
1108     struct target_sigcontext tuc_mcontext;
1109     target_sigset_t  tuc_sigmask;	/* mask last for extensibility */
1110     char __unused[128 - sizeof(target_sigset_t)];
1111     abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1112 };
1113 
1114 struct target_user_vfp {
1115     uint64_t fpregs[32];
1116     abi_ulong fpscr;
1117 };
1118 
1119 struct target_user_vfp_exc {
1120     abi_ulong fpexc;
1121     abi_ulong fpinst;
1122     abi_ulong fpinst2;
1123 };
1124 
1125 struct target_vfp_sigframe {
1126     abi_ulong magic;
1127     abi_ulong size;
1128     struct target_user_vfp ufp;
1129     struct target_user_vfp_exc ufp_exc;
1130 } __attribute__((__aligned__(8)));
1131 
1132 struct target_iwmmxt_sigframe {
1133     abi_ulong magic;
1134     abi_ulong size;
1135     uint64_t regs[16];
1136     /* Note that not all the coprocessor control registers are stored here */
1137     uint32_t wcssf;
1138     uint32_t wcasf;
1139     uint32_t wcgr0;
1140     uint32_t wcgr1;
1141     uint32_t wcgr2;
1142     uint32_t wcgr3;
1143 } __attribute__((__aligned__(8)));
1144 
1145 #define TARGET_VFP_MAGIC 0x56465001
1146 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1147 
1148 struct sigframe_v1
1149 {
1150     struct target_sigcontext sc;
1151     abi_ulong extramask[TARGET_NSIG_WORDS-1];
1152     abi_ulong retcode;
1153 };
1154 
1155 struct sigframe_v2
1156 {
1157     struct target_ucontext_v2 uc;
1158     abi_ulong retcode;
1159 };
1160 
1161 struct rt_sigframe_v1
1162 {
1163     abi_ulong pinfo;
1164     abi_ulong puc;
1165     struct target_siginfo info;
1166     struct target_ucontext_v1 uc;
1167     abi_ulong retcode;
1168 };
1169 
1170 struct rt_sigframe_v2
1171 {
1172     struct target_siginfo info;
1173     struct target_ucontext_v2 uc;
1174     abi_ulong retcode;
1175 };
1176 
1177 #define TARGET_CONFIG_CPU_32 1
1178 
1179 /*
1180  * For ARM syscalls, we encode the syscall number into the instruction.
1181  */
1182 #define SWI_SYS_SIGRETURN	(0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1183 #define SWI_SYS_RT_SIGRETURN	(0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1184 
1185 /*
1186  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
1187  * need two 16-bit instructions.
1188  */
1189 #define SWI_THUMB_SIGRETURN	(0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1190 #define SWI_THUMB_RT_SIGRETURN	(0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1191 
1192 static const abi_ulong retcodes[4] = {
1193 	SWI_SYS_SIGRETURN,	SWI_THUMB_SIGRETURN,
1194 	SWI_SYS_RT_SIGRETURN,	SWI_THUMB_RT_SIGRETURN
1195 };
1196 
1197 
1198 #define __get_user_error(x,p,e) __get_user(x, p)
1199 
1200 static inline int valid_user_regs(CPUState *regs)
1201 {
1202     return 1;
1203 }
1204 
1205 static void
1206 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1207 		 CPUState *env, abi_ulong mask)
1208 {
1209 	__put_user(env->regs[0], &sc->arm_r0);
1210 	__put_user(env->regs[1], &sc->arm_r1);
1211 	__put_user(env->regs[2], &sc->arm_r2);
1212 	__put_user(env->regs[3], &sc->arm_r3);
1213 	__put_user(env->regs[4], &sc->arm_r4);
1214 	__put_user(env->regs[5], &sc->arm_r5);
1215 	__put_user(env->regs[6], &sc->arm_r6);
1216 	__put_user(env->regs[7], &sc->arm_r7);
1217 	__put_user(env->regs[8], &sc->arm_r8);
1218 	__put_user(env->regs[9], &sc->arm_r9);
1219 	__put_user(env->regs[10], &sc->arm_r10);
1220 	__put_user(env->regs[11], &sc->arm_fp);
1221 	__put_user(env->regs[12], &sc->arm_ip);
1222 	__put_user(env->regs[13], &sc->arm_sp);
1223 	__put_user(env->regs[14], &sc->arm_lr);
1224 	__put_user(env->regs[15], &sc->arm_pc);
1225 #ifdef TARGET_CONFIG_CPU_32
1226 	__put_user(cpsr_read(env), &sc->arm_cpsr);
1227 #endif
1228 
1229 	__put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1230 	__put_user(/* current->thread.error_code */ 0, &sc->error_code);
1231 	__put_user(/* current->thread.address */ 0, &sc->fault_address);
1232 	__put_user(mask, &sc->oldmask);
1233 }
1234 
1235 static inline abi_ulong
1236 get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
1237 {
1238 	unsigned long sp = regs->regs[13];
1239 
1240 	/*
1241 	 * This is the X/Open sanctioned signal stack switching.
1242 	 */
1243 	if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1244             sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1245 	/*
1246 	 * ATPCS B01 mandates 8-byte alignment
1247 	 */
1248 	return (sp - framesize) & ~7;
1249 }
1250 
1251 static int
1252 setup_return(CPUState *env, struct target_sigaction *ka,
1253 	     abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1254 {
1255 	abi_ulong handler = ka->_sa_handler;
1256 	abi_ulong retcode;
1257 	int thumb = handler & 1;
1258 	uint32_t cpsr = cpsr_read(env);
1259 
1260 	cpsr &= ~CPSR_IT;
1261 	if (thumb) {
1262 		cpsr |= CPSR_T;
1263 	} else {
1264 		cpsr &= ~CPSR_T;
1265 	}
1266 
1267 	if (ka->sa_flags & TARGET_SA_RESTORER) {
1268 		retcode = ka->sa_restorer;
1269 	} else {
1270 		unsigned int idx = thumb;
1271 
1272 		if (ka->sa_flags & TARGET_SA_SIGINFO)
1273 			idx += 2;
1274 
1275 		if (__put_user(retcodes[idx], rc))
1276 			return 1;
1277 #if 0
1278 		flush_icache_range((abi_ulong)rc,
1279 				   (abi_ulong)(rc + 1));
1280 #endif
1281 		retcode = rc_addr + thumb;
1282 	}
1283 
1284 	env->regs[0] = usig;
1285 	env->regs[13] = frame_addr;
1286 	env->regs[14] = retcode;
1287 	env->regs[15] = handler & (thumb ? ~1 : ~3);
1288 	cpsr_write(env, cpsr, 0xffffffff);
1289 
1290 	return 0;
1291 }
1292 
1293 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUState *env)
1294 {
1295     int i;
1296     struct target_vfp_sigframe *vfpframe;
1297     vfpframe = (struct target_vfp_sigframe *)regspace;
1298     __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1299     __put_user(sizeof(*vfpframe), &vfpframe->size);
1300     for (i = 0; i < 32; i++) {
1301         __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1302     }
1303     __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1304     __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1305     __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1306     __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1307     return (abi_ulong*)(vfpframe+1);
1308 }
1309 
1310 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace, CPUState *env)
1311 {
1312     int i;
1313     struct target_iwmmxt_sigframe *iwmmxtframe;
1314     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1315     __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1316     __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1317     for (i = 0; i < 16; i++) {
1318         __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1319     }
1320     __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1321     __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1322     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1323     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1324     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1325     __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1326     return (abi_ulong*)(iwmmxtframe+1);
1327 }
1328 
1329 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1330                               target_sigset_t *set, CPUState *env)
1331 {
1332     struct target_sigaltstack stack;
1333     int i;
1334     abi_ulong *regspace;
1335 
1336     /* Clear all the bits of the ucontext we don't use.  */
1337     memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1338 
1339     memset(&stack, 0, sizeof(stack));
1340     __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1341     __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1342     __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1343     memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1344 
1345     setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1346     /* Save coprocessor signal frame.  */
1347     regspace = uc->tuc_regspace;
1348     if (arm_feature(env, ARM_FEATURE_VFP)) {
1349         regspace = setup_sigframe_v2_vfp(regspace, env);
1350     }
1351     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1352         regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1353     }
1354 
1355     /* Write terminating magic word */
1356     __put_user(0, regspace);
1357 
1358     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1359         __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1360     }
1361 }
1362 
1363 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1364 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1365 			   target_sigset_t *set, CPUState *regs)
1366 {
1367 	struct sigframe_v1 *frame;
1368 	abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1369 	int i;
1370 
1371 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1372 		return;
1373 
1374 	setup_sigcontext(&frame->sc, regs, set->sig[0]);
1375 
1376         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1377             if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1378                 goto end;
1379 	}
1380 
1381         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1382                      frame_addr + offsetof(struct sigframe_v1, retcode));
1383 
1384 end:
1385 	unlock_user_struct(frame, frame_addr, 1);
1386 }
1387 
1388 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1389 			   target_sigset_t *set, CPUState *regs)
1390 {
1391 	struct sigframe_v2 *frame;
1392 	abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1393 
1394 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1395 		return;
1396 
1397         setup_sigframe_v2(&frame->uc, set, regs);
1398 
1399         setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1400                      frame_addr + offsetof(struct sigframe_v2, retcode));
1401 
1402 	unlock_user_struct(frame, frame_addr, 1);
1403 }
1404 
1405 static void setup_frame(int usig, struct target_sigaction *ka,
1406 			target_sigset_t *set, CPUState *regs)
1407 {
1408     if (get_osversion() >= 0x020612) {
1409         setup_frame_v2(usig, ka, set, regs);
1410     } else {
1411         setup_frame_v1(usig, ka, set, regs);
1412     }
1413 }
1414 
1415 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1416 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1417                               target_siginfo_t *info,
1418 			      target_sigset_t *set, CPUState *env)
1419 {
1420 	struct rt_sigframe_v1 *frame;
1421 	abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1422 	struct target_sigaltstack stack;
1423 	int i;
1424         abi_ulong info_addr, uc_addr;
1425 
1426 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1427             return /* 1 */;
1428 
1429         info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1430 	__put_user(info_addr, &frame->pinfo);
1431         uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1432 	__put_user(uc_addr, &frame->puc);
1433 	copy_siginfo_to_user(&frame->info, info);
1434 
1435 	/* Clear all the bits of the ucontext we don't use.  */
1436 	memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1437 
1438         memset(&stack, 0, sizeof(stack));
1439         __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1440         __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1441         __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1442         memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1443 
1444 	setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1445         for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1446             if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1447                 goto end;
1448         }
1449 
1450         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1451                      frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1452 
1453         env->regs[1] = info_addr;
1454         env->regs[2] = uc_addr;
1455 
1456 end:
1457 	unlock_user_struct(frame, frame_addr, 1);
1458 }
1459 
1460 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1461                               target_siginfo_t *info,
1462                               target_sigset_t *set, CPUState *env)
1463 {
1464 	struct rt_sigframe_v2 *frame;
1465 	abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1466         abi_ulong info_addr, uc_addr;
1467 
1468 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1469             return /* 1 */;
1470 
1471         info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1472         uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1473 	copy_siginfo_to_user(&frame->info, info);
1474 
1475         setup_sigframe_v2(&frame->uc, set, env);
1476 
1477         setup_return(env, ka, &frame->retcode, frame_addr, usig,
1478                      frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1479 
1480         env->regs[1] = info_addr;
1481         env->regs[2] = uc_addr;
1482 
1483 	unlock_user_struct(frame, frame_addr, 1);
1484 }
1485 
1486 static void setup_rt_frame(int usig, struct target_sigaction *ka,
1487                            target_siginfo_t *info,
1488 			   target_sigset_t *set, CPUState *env)
1489 {
1490     if (get_osversion() >= 0x020612) {
1491         setup_rt_frame_v2(usig, ka, info, set, env);
1492     } else {
1493         setup_rt_frame_v1(usig, ka, info, set, env);
1494     }
1495 }
1496 
1497 static int
1498 restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1499 {
1500 	int err = 0;
1501         uint32_t cpsr;
1502 
1503 	__get_user_error(env->regs[0], &sc->arm_r0, err);
1504 	__get_user_error(env->regs[1], &sc->arm_r1, err);
1505 	__get_user_error(env->regs[2], &sc->arm_r2, err);
1506 	__get_user_error(env->regs[3], &sc->arm_r3, err);
1507 	__get_user_error(env->regs[4], &sc->arm_r4, err);
1508 	__get_user_error(env->regs[5], &sc->arm_r5, err);
1509 	__get_user_error(env->regs[6], &sc->arm_r6, err);
1510 	__get_user_error(env->regs[7], &sc->arm_r7, err);
1511 	__get_user_error(env->regs[8], &sc->arm_r8, err);
1512 	__get_user_error(env->regs[9], &sc->arm_r9, err);
1513 	__get_user_error(env->regs[10], &sc->arm_r10, err);
1514 	__get_user_error(env->regs[11], &sc->arm_fp, err);
1515 	__get_user_error(env->regs[12], &sc->arm_ip, err);
1516 	__get_user_error(env->regs[13], &sc->arm_sp, err);
1517 	__get_user_error(env->regs[14], &sc->arm_lr, err);
1518 	__get_user_error(env->regs[15], &sc->arm_pc, err);
1519 #ifdef TARGET_CONFIG_CPU_32
1520 	__get_user_error(cpsr, &sc->arm_cpsr, err);
1521         cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
1522 #endif
1523 
1524 	err |= !valid_user_regs(env);
1525 
1526 	return err;
1527 }
1528 
1529 static long do_sigreturn_v1(CPUState *env)
1530 {
1531         abi_ulong frame_addr;
1532 	struct sigframe_v1 *frame;
1533 	target_sigset_t set;
1534         sigset_t host_set;
1535         int i;
1536 
1537 	/*
1538 	 * Since we stacked the signal on a 64-bit boundary,
1539 	 * then 'sp' should be word aligned here.  If it's
1540 	 * not, then the user is trying to mess with us.
1541 	 */
1542 	if (env->regs[13] & 7)
1543 		goto badframe;
1544 
1545         frame_addr = env->regs[13];
1546 	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1547                 goto badframe;
1548 
1549 	if (__get_user(set.sig[0], &frame->sc.oldmask))
1550             goto badframe;
1551         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1552             if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1553                 goto badframe;
1554         }
1555 
1556         target_to_host_sigset_internal(&host_set, &set);
1557         sigprocmask(SIG_SETMASK, &host_set, NULL);
1558 
1559 	if (restore_sigcontext(env, &frame->sc))
1560 		goto badframe;
1561 
1562 #if 0
1563 	/* Send SIGTRAP if we're single-stepping */
1564 	if (ptrace_cancel_bpt(current))
1565 		send_sig(SIGTRAP, current, 1);
1566 #endif
1567 	unlock_user_struct(frame, frame_addr, 0);
1568         return env->regs[0];
1569 
1570 badframe:
1571 	unlock_user_struct(frame, frame_addr, 0);
1572         force_sig(TARGET_SIGSEGV /* , current */);
1573 	return 0;
1574 }
1575 
1576 static abi_ulong *restore_sigframe_v2_vfp(CPUState *env, abi_ulong *regspace)
1577 {
1578     int i;
1579     abi_ulong magic, sz;
1580     uint32_t fpscr, fpexc;
1581     struct target_vfp_sigframe *vfpframe;
1582     vfpframe = (struct target_vfp_sigframe *)regspace;
1583 
1584     __get_user(magic, &vfpframe->magic);
1585     __get_user(sz, &vfpframe->size);
1586     if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1587         return 0;
1588     }
1589     for (i = 0; i < 32; i++) {
1590         __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1591     }
1592     __get_user(fpscr, &vfpframe->ufp.fpscr);
1593     vfp_set_fpscr(env, fpscr);
1594     __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1595     /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1596      * and the exception flag is cleared
1597      */
1598     fpexc |= (1 << 30);
1599     fpexc &= ~((1 << 31) | (1 << 28));
1600     env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1601     __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1602     __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1603     return (abi_ulong*)(vfpframe + 1);
1604 }
1605 
1606 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUState *env, abi_ulong *regspace)
1607 {
1608     int i;
1609     abi_ulong magic, sz;
1610     struct target_iwmmxt_sigframe *iwmmxtframe;
1611     iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1612 
1613     __get_user(magic, &iwmmxtframe->magic);
1614     __get_user(sz, &iwmmxtframe->size);
1615     if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1616         return 0;
1617     }
1618     for (i = 0; i < 16; i++) {
1619         __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1620     }
1621     __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1622     __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1623     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1624     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1625     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1626     __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1627     return (abi_ulong*)(iwmmxtframe + 1);
1628 }
1629 
1630 static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1631                                  struct target_ucontext_v2 *uc)
1632 {
1633     sigset_t host_set;
1634     abi_ulong *regspace;
1635 
1636     target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1637     sigprocmask(SIG_SETMASK, &host_set, NULL);
1638 
1639     if (restore_sigcontext(env, &uc->tuc_mcontext))
1640         return 1;
1641 
1642     /* Restore coprocessor signal frame */
1643     regspace = uc->tuc_regspace;
1644     if (arm_feature(env, ARM_FEATURE_VFP)) {
1645         regspace = restore_sigframe_v2_vfp(env, regspace);
1646         if (!regspace) {
1647             return 1;
1648         }
1649     }
1650     if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1651         regspace = restore_sigframe_v2_iwmmxt(env, regspace);
1652         if (!regspace) {
1653             return 1;
1654         }
1655     }
1656 
1657     if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1658         return 1;
1659 
1660 #if 0
1661     /* Send SIGTRAP if we're single-stepping */
1662     if (ptrace_cancel_bpt(current))
1663             send_sig(SIGTRAP, current, 1);
1664 #endif
1665 
1666     return 0;
1667 }
1668 
1669 static long do_sigreturn_v2(CPUState *env)
1670 {
1671         abi_ulong frame_addr;
1672 	struct sigframe_v2 *frame;
1673 
1674 	/*
1675 	 * Since we stacked the signal on a 64-bit boundary,
1676 	 * then 'sp' should be word aligned here.  If it's
1677 	 * not, then the user is trying to mess with us.
1678 	 */
1679 	if (env->regs[13] & 7)
1680 		goto badframe;
1681 
1682         frame_addr = env->regs[13];
1683 	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1684                 goto badframe;
1685 
1686         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1687                 goto badframe;
1688 
1689 	unlock_user_struct(frame, frame_addr, 0);
1690 	return env->regs[0];
1691 
1692 badframe:
1693 	unlock_user_struct(frame, frame_addr, 0);
1694         force_sig(TARGET_SIGSEGV /* , current */);
1695 	return 0;
1696 }
1697 
1698 long do_sigreturn(CPUState *env)
1699 {
1700     if (get_osversion() >= 0x020612) {
1701         return do_sigreturn_v2(env);
1702     } else {
1703         return do_sigreturn_v1(env);
1704     }
1705 }
1706 
1707 static long do_rt_sigreturn_v1(CPUState *env)
1708 {
1709         abi_ulong frame_addr;
1710 	struct rt_sigframe_v1 *frame;
1711         sigset_t host_set;
1712 
1713 	/*
1714 	 * Since we stacked the signal on a 64-bit boundary,
1715 	 * then 'sp' should be word aligned here.  If it's
1716 	 * not, then the user is trying to mess with us.
1717 	 */
1718 	if (env->regs[13] & 7)
1719 		goto badframe;
1720 
1721         frame_addr = env->regs[13];
1722 	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1723                 goto badframe;
1724 
1725         target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1726         sigprocmask(SIG_SETMASK, &host_set, NULL);
1727 
1728 	if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1729 		goto badframe;
1730 
1731 	if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1732 		goto badframe;
1733 
1734 #if 0
1735 	/* Send SIGTRAP if we're single-stepping */
1736 	if (ptrace_cancel_bpt(current))
1737 		send_sig(SIGTRAP, current, 1);
1738 #endif
1739 	unlock_user_struct(frame, frame_addr, 0);
1740 	return env->regs[0];
1741 
1742 badframe:
1743 	unlock_user_struct(frame, frame_addr, 0);
1744         force_sig(TARGET_SIGSEGV /* , current */);
1745 	return 0;
1746 }
1747 
1748 static long do_rt_sigreturn_v2(CPUState *env)
1749 {
1750         abi_ulong frame_addr;
1751 	struct rt_sigframe_v2 *frame;
1752 
1753 	/*
1754 	 * Since we stacked the signal on a 64-bit boundary,
1755 	 * then 'sp' should be word aligned here.  If it's
1756 	 * not, then the user is trying to mess with us.
1757 	 */
1758 	if (env->regs[13] & 7)
1759 		goto badframe;
1760 
1761         frame_addr = env->regs[13];
1762 	if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1763                 goto badframe;
1764 
1765         if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1766                 goto badframe;
1767 
1768 	unlock_user_struct(frame, frame_addr, 0);
1769 	return env->regs[0];
1770 
1771 badframe:
1772 	unlock_user_struct(frame, frame_addr, 0);
1773         force_sig(TARGET_SIGSEGV /* , current */);
1774 	return 0;
1775 }
1776 
1777 long do_rt_sigreturn(CPUState *env)
1778 {
1779     if (get_osversion() >= 0x020612) {
1780         return do_rt_sigreturn_v2(env);
1781     } else {
1782         return do_rt_sigreturn_v1(env);
1783     }
1784 }
1785 
1786 #elif defined(TARGET_SPARC)
1787 
1788 #define __SUNOS_MAXWIN   31
1789 
1790 /* This is what SunOS does, so shall I. */
1791 struct target_sigcontext {
1792         abi_ulong sigc_onstack;      /* state to restore */
1793 
1794         abi_ulong sigc_mask;         /* sigmask to restore */
1795         abi_ulong sigc_sp;           /* stack pointer */
1796         abi_ulong sigc_pc;           /* program counter */
1797         abi_ulong sigc_npc;          /* next program counter */
1798         abi_ulong sigc_psr;          /* for condition codes etc */
1799         abi_ulong sigc_g1;           /* User uses these two registers */
1800         abi_ulong sigc_o0;           /* within the trampoline code. */
1801 
1802         /* Now comes information regarding the users window set
1803          * at the time of the signal.
1804          */
1805         abi_ulong sigc_oswins;       /* outstanding windows */
1806 
1807         /* stack ptrs for each regwin buf */
1808         char *sigc_spbuf[__SUNOS_MAXWIN];
1809 
1810         /* Windows to restore after signal */
1811         struct {
1812                 abi_ulong locals[8];
1813                 abi_ulong ins[8];
1814         } sigc_wbuf[__SUNOS_MAXWIN];
1815 };
1816 /* A Sparc stack frame */
1817 struct sparc_stackf {
1818         abi_ulong locals[8];
1819         abi_ulong ins[8];
1820         /* It's simpler to treat fp and callers_pc as elements of ins[]
1821          * since we never need to access them ourselves.
1822          */
1823         char *structptr;
1824         abi_ulong xargs[6];
1825         abi_ulong xxargs[1];
1826 };
1827 
1828 typedef struct {
1829         struct {
1830                 abi_ulong psr;
1831                 abi_ulong pc;
1832                 abi_ulong npc;
1833                 abi_ulong y;
1834                 abi_ulong u_regs[16]; /* globals and ins */
1835         }               si_regs;
1836         int             si_mask;
1837 } __siginfo_t;
1838 
1839 typedef struct {
1840         unsigned   long si_float_regs [32];
1841         unsigned   long si_fsr;
1842         unsigned   long si_fpqdepth;
1843         struct {
1844                 unsigned long *insn_addr;
1845                 unsigned long insn;
1846         } si_fpqueue [16];
1847 } qemu_siginfo_fpu_t;
1848 
1849 
1850 struct target_signal_frame {
1851 	struct sparc_stackf	ss;
1852 	__siginfo_t		info;
1853 	abi_ulong               fpu_save;
1854 	abi_ulong		insns[2] __attribute__ ((aligned (8)));
1855 	abi_ulong		extramask[TARGET_NSIG_WORDS - 1];
1856 	abi_ulong		extra_size; /* Should be 0 */
1857 	qemu_siginfo_fpu_t	fpu_state;
1858 };
1859 struct target_rt_signal_frame {
1860 	struct sparc_stackf	ss;
1861 	siginfo_t		info;
1862 	abi_ulong		regs[20];
1863 	sigset_t		mask;
1864 	abi_ulong               fpu_save;
1865 	unsigned int		insns[2];
1866 	stack_t			stack;
1867 	unsigned int		extra_size; /* Should be 0 */
1868 	qemu_siginfo_fpu_t	fpu_state;
1869 };
1870 
1871 #define UREG_O0        16
1872 #define UREG_O6        22
1873 #define UREG_I0        0
1874 #define UREG_I1        1
1875 #define UREG_I2        2
1876 #define UREG_I3        3
1877 #define UREG_I4        4
1878 #define UREG_I5        5
1879 #define UREG_I6        6
1880 #define UREG_I7        7
1881 #define UREG_L0	       8
1882 #define UREG_FP        UREG_I6
1883 #define UREG_SP        UREG_O6
1884 
1885 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
1886                                      CPUState *env, unsigned long framesize)
1887 {
1888 	abi_ulong sp;
1889 
1890 	sp = env->regwptr[UREG_FP];
1891 
1892 	/* This is the X/Open sanctioned signal stack switching.  */
1893 	if (sa->sa_flags & TARGET_SA_ONSTACK) {
1894             if (!on_sig_stack(sp)
1895                 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1896                 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1897 	}
1898 	return sp - framesize;
1899 }
1900 
1901 static int
1902 setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1903 {
1904 	int err = 0, i;
1905 
1906 	err |= __put_user(env->psr, &si->si_regs.psr);
1907 	err |= __put_user(env->pc, &si->si_regs.pc);
1908 	err |= __put_user(env->npc, &si->si_regs.npc);
1909 	err |= __put_user(env->y, &si->si_regs.y);
1910 	for (i=0; i < 8; i++) {
1911 		err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1912 	}
1913 	for (i=0; i < 8; i++) {
1914 		err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1915 	}
1916 	err |= __put_user(mask, &si->si_mask);
1917 	return err;
1918 }
1919 
1920 #if 0
1921 static int
1922 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1923 		 CPUState *env, unsigned long mask)
1924 {
1925 	int err = 0;
1926 
1927 	err |= __put_user(mask, &sc->sigc_mask);
1928 	err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1929 	err |= __put_user(env->pc, &sc->sigc_pc);
1930 	err |= __put_user(env->npc, &sc->sigc_npc);
1931 	err |= __put_user(env->psr, &sc->sigc_psr);
1932 	err |= __put_user(env->gregs[1], &sc->sigc_g1);
1933 	err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1934 
1935 	return err;
1936 }
1937 #endif
1938 #define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1939 
1940 static void setup_frame(int sig, struct target_sigaction *ka,
1941 			target_sigset_t *set, CPUState *env)
1942 {
1943         abi_ulong sf_addr;
1944 	struct target_signal_frame *sf;
1945 	int sigframe_size, err, i;
1946 
1947 	/* 1. Make sure everything is clean */
1948 	//synchronize_user_stack();
1949 
1950         sigframe_size = NF_ALIGNEDSZ;
1951 	sf_addr = get_sigframe(ka, env, sigframe_size);
1952 
1953         sf = lock_user(VERIFY_WRITE, sf_addr,
1954                        sizeof(struct target_signal_frame), 0);
1955         if (!sf)
1956 		goto sigsegv;
1957 
1958 	//fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1959 #if 0
1960 	if (invalid_frame_pointer(sf, sigframe_size))
1961 		goto sigill_and_return;
1962 #endif
1963 	/* 2. Save the current process state */
1964 	err = setup___siginfo(&sf->info, env, set->sig[0]);
1965 	err |= __put_user(0, &sf->extra_size);
1966 
1967 	//err |= save_fpu_state(regs, &sf->fpu_state);
1968 	//err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1969 
1970 	err |= __put_user(set->sig[0], &sf->info.si_mask);
1971 	for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1972 		err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1973 	}
1974 
1975 	for (i = 0; i < 8; i++) {
1976 	  	err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1977 	}
1978 	for (i = 0; i < 8; i++) {
1979 	  	err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1980 	}
1981 	if (err)
1982 		goto sigsegv;
1983 
1984 	/* 3. signal handler back-trampoline and parameters */
1985 	env->regwptr[UREG_FP] = sf_addr;
1986 	env->regwptr[UREG_I0] = sig;
1987 	env->regwptr[UREG_I1] = sf_addr +
1988                 offsetof(struct target_signal_frame, info);
1989 	env->regwptr[UREG_I2] = sf_addr +
1990                 offsetof(struct target_signal_frame, info);
1991 
1992 	/* 4. signal handler */
1993 	env->pc = ka->_sa_handler;
1994 	env->npc = (env->pc + 4);
1995 	/* 5. return to kernel instructions */
1996 	if (ka->sa_restorer)
1997 		env->regwptr[UREG_I7] = ka->sa_restorer;
1998 	else {
1999                 uint32_t val32;
2000 
2001 		env->regwptr[UREG_I7] = sf_addr +
2002                         offsetof(struct target_signal_frame, insns) - 2 * 4;
2003 
2004 		/* mov __NR_sigreturn, %g1 */
2005                 val32 = 0x821020d8;
2006 		err |= __put_user(val32, &sf->insns[0]);
2007 
2008 		/* t 0x10 */
2009                 val32 = 0x91d02010;
2010 		err |= __put_user(val32, &sf->insns[1]);
2011 		if (err)
2012 			goto sigsegv;
2013 
2014 		/* Flush instruction space. */
2015 		//flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2016                 //		tb_flush(env);
2017 	}
2018         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2019 	return;
2020 #if 0
2021 sigill_and_return:
2022 	force_sig(TARGET_SIGILL);
2023 #endif
2024 sigsegv:
2025 	//fprintf(stderr, "force_sig\n");
2026         unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2027 	force_sig(TARGET_SIGSEGV);
2028 }
2029 static inline int
2030 restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
2031 {
2032         int err;
2033 #if 0
2034 #ifdef CONFIG_SMP
2035         if (current->flags & PF_USEDFPU)
2036                 regs->psr &= ~PSR_EF;
2037 #else
2038         if (current == last_task_used_math) {
2039                 last_task_used_math = 0;
2040                 regs->psr &= ~PSR_EF;
2041         }
2042 #endif
2043         current->used_math = 1;
2044         current->flags &= ~PF_USEDFPU;
2045 #endif
2046 #if 0
2047         if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
2048                 return -EFAULT;
2049 #endif
2050 
2051 #if 0
2052         /* XXX: incorrect */
2053         err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
2054 	                             (sizeof(unsigned long) * 32));
2055 #endif
2056         err |= __get_user(env->fsr, &fpu->si_fsr);
2057 #if 0
2058         err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
2059         if (current->thread.fpqdepth != 0)
2060                 err |= __copy_from_user(&current->thread.fpqueue[0],
2061                                         &fpu->si_fpqueue[0],
2062                                         ((sizeof(unsigned long) +
2063                                         (sizeof(unsigned long *)))*16));
2064 #endif
2065         return err;
2066 }
2067 
2068 
2069 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2070                            target_siginfo_t *info,
2071 			   target_sigset_t *set, CPUState *env)
2072 {
2073     fprintf(stderr, "setup_rt_frame: not implemented\n");
2074 }
2075 
2076 long do_sigreturn(CPUState *env)
2077 {
2078         abi_ulong sf_addr;
2079         struct target_signal_frame *sf;
2080         uint32_t up_psr, pc, npc;
2081         target_sigset_t set;
2082         sigset_t host_set;
2083         int err, i;
2084 
2085         sf_addr = env->regwptr[UREG_FP];
2086         if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
2087                 goto segv_and_exit;
2088 #if 0
2089 	fprintf(stderr, "sigreturn\n");
2090 	fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
2091 #endif
2092 	//cpu_dump_state(env, stderr, fprintf, 0);
2093 
2094         /* 1. Make sure we are not getting garbage from the user */
2095 
2096         if (sf_addr & 3)
2097                 goto segv_and_exit;
2098 
2099         err = __get_user(pc,  &sf->info.si_regs.pc);
2100         err |= __get_user(npc, &sf->info.si_regs.npc);
2101 
2102         if ((pc | npc) & 3)
2103                 goto segv_and_exit;
2104 
2105         /* 2. Restore the state */
2106         err |= __get_user(up_psr, &sf->info.si_regs.psr);
2107 
2108         /* User can only change condition codes and FPU enabling in %psr. */
2109         env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2110                   | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2111 
2112 	env->pc = pc;
2113 	env->npc = npc;
2114         err |= __get_user(env->y, &sf->info.si_regs.y);
2115 	for (i=0; i < 8; i++) {
2116 		err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2117 	}
2118 	for (i=0; i < 8; i++) {
2119 		err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2120 	}
2121 
2122         /* FIXME: implement FPU save/restore:
2123          * __get_user(fpu_save, &sf->fpu_save);
2124          * if (fpu_save)
2125          *        err |= restore_fpu_state(env, fpu_save);
2126          */
2127 
2128         /* This is pretty much atomic, no amount locking would prevent
2129          * the races which exist anyways.
2130          */
2131         err |= __get_user(set.sig[0], &sf->info.si_mask);
2132         for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2133             err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
2134         }
2135 
2136         target_to_host_sigset_internal(&host_set, &set);
2137         sigprocmask(SIG_SETMASK, &host_set, NULL);
2138 
2139         if (err)
2140                 goto segv_and_exit;
2141         unlock_user_struct(sf, sf_addr, 0);
2142         return env->regwptr[0];
2143 
2144 segv_and_exit:
2145         unlock_user_struct(sf, sf_addr, 0);
2146 	force_sig(TARGET_SIGSEGV);
2147 }
2148 
2149 long do_rt_sigreturn(CPUState *env)
2150 {
2151     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2152     return -TARGET_ENOSYS;
2153 }
2154 
2155 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2156 #define MC_TSTATE 0
2157 #define MC_PC 1
2158 #define MC_NPC 2
2159 #define MC_Y 3
2160 #define MC_G1 4
2161 #define MC_G2 5
2162 #define MC_G3 6
2163 #define MC_G4 7
2164 #define MC_G5 8
2165 #define MC_G6 9
2166 #define MC_G7 10
2167 #define MC_O0 11
2168 #define MC_O1 12
2169 #define MC_O2 13
2170 #define MC_O3 14
2171 #define MC_O4 15
2172 #define MC_O5 16
2173 #define MC_O6 17
2174 #define MC_O7 18
2175 #define MC_NGREG 19
2176 
2177 typedef abi_ulong target_mc_greg_t;
2178 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2179 
2180 struct target_mc_fq {
2181     abi_ulong *mcfq_addr;
2182     uint32_t mcfq_insn;
2183 };
2184 
2185 struct target_mc_fpu {
2186     union {
2187         uint32_t sregs[32];
2188         uint64_t dregs[32];
2189         //uint128_t qregs[16];
2190     } mcfpu_fregs;
2191     abi_ulong mcfpu_fsr;
2192     abi_ulong mcfpu_fprs;
2193     abi_ulong mcfpu_gsr;
2194     struct target_mc_fq *mcfpu_fq;
2195     unsigned char mcfpu_qcnt;
2196     unsigned char mcfpu_qentsz;
2197     unsigned char mcfpu_enab;
2198 };
2199 typedef struct target_mc_fpu target_mc_fpu_t;
2200 
2201 typedef struct {
2202     target_mc_gregset_t mc_gregs;
2203     target_mc_greg_t mc_fp;
2204     target_mc_greg_t mc_i7;
2205     target_mc_fpu_t mc_fpregs;
2206 } target_mcontext_t;
2207 
2208 struct target_ucontext {
2209     struct target_ucontext *tuc_link;
2210     abi_ulong tuc_flags;
2211     target_sigset_t tuc_sigmask;
2212     target_mcontext_t tuc_mcontext;
2213 };
2214 
2215 /* A V9 register window */
2216 struct target_reg_window {
2217     abi_ulong locals[8];
2218     abi_ulong ins[8];
2219 };
2220 
2221 #define TARGET_STACK_BIAS 2047
2222 
2223 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2224 void sparc64_set_context(CPUSPARCState *env)
2225 {
2226     abi_ulong ucp_addr;
2227     struct target_ucontext *ucp;
2228     target_mc_gregset_t *grp;
2229     abi_ulong pc, npc, tstate;
2230     abi_ulong fp, i7, w_addr;
2231     int err;
2232     unsigned int i;
2233 
2234     ucp_addr = env->regwptr[UREG_I0];
2235     if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2236         goto do_sigsegv;
2237     grp  = &ucp->tuc_mcontext.mc_gregs;
2238     err  = __get_user(pc, &((*grp)[MC_PC]));
2239     err |= __get_user(npc, &((*grp)[MC_NPC]));
2240     if (err || ((pc | npc) & 3))
2241         goto do_sigsegv;
2242     if (env->regwptr[UREG_I1]) {
2243         target_sigset_t target_set;
2244         sigset_t set;
2245 
2246         if (TARGET_NSIG_WORDS == 1) {
2247             if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
2248                 goto do_sigsegv;
2249         } else {
2250             abi_ulong *src, *dst;
2251             src = ucp->tuc_sigmask.sig;
2252             dst = target_set.sig;
2253             for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2254                  i++, dst++, src++)
2255                 err |= __get_user(*dst, src);
2256             if (err)
2257                 goto do_sigsegv;
2258         }
2259         target_to_host_sigset_internal(&set, &target_set);
2260         sigprocmask(SIG_SETMASK, &set, NULL);
2261     }
2262     env->pc = pc;
2263     env->npc = npc;
2264     err |= __get_user(env->y, &((*grp)[MC_Y]));
2265     err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
2266     env->asi = (tstate >> 24) & 0xff;
2267     cpu_put_ccr(env, tstate >> 32);
2268     cpu_put_cwp64(env, tstate & 0x1f);
2269     err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2270     err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2271     err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2272     err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2273     err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2274     err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2275     err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2276     err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2277     err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2278     err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2279     err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2280     err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2281     err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2282     err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2283     err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2284 
2285     err |= __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2286     err |= __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2287 
2288     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2289     if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2290                  abi_ulong) != 0)
2291         goto do_sigsegv;
2292     if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2293                  abi_ulong) != 0)
2294         goto do_sigsegv;
2295     /* FIXME this does not match how the kernel handles the FPU in
2296      * its sparc64_set_context implementation. In particular the FPU
2297      * is only restored if fenab is non-zero in:
2298      *   __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2299      */
2300     err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2301     {
2302         uint32_t *src, *dst;
2303         src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2304         dst = env->fpr;
2305         /* XXX: check that the CPU storage is the same as user context */
2306         for (i = 0; i < 64; i++, dst++, src++)
2307             err |= __get_user(*dst, src);
2308     }
2309     err |= __get_user(env->fsr,
2310                       &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2311     err |= __get_user(env->gsr,
2312                       &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2313     if (err)
2314         goto do_sigsegv;
2315     unlock_user_struct(ucp, ucp_addr, 0);
2316     return;
2317  do_sigsegv:
2318     unlock_user_struct(ucp, ucp_addr, 0);
2319     force_sig(TARGET_SIGSEGV);
2320 }
2321 
2322 void sparc64_get_context(CPUSPARCState *env)
2323 {
2324     abi_ulong ucp_addr;
2325     struct target_ucontext *ucp;
2326     target_mc_gregset_t *grp;
2327     target_mcontext_t *mcp;
2328     abi_ulong fp, i7, w_addr;
2329     int err;
2330     unsigned int i;
2331     target_sigset_t target_set;
2332     sigset_t set;
2333 
2334     ucp_addr = env->regwptr[UREG_I0];
2335     if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2336         goto do_sigsegv;
2337 
2338     mcp = &ucp->tuc_mcontext;
2339     grp = &mcp->mc_gregs;
2340 
2341     /* Skip over the trap instruction, first. */
2342     env->pc = env->npc;
2343     env->npc += 4;
2344 
2345     err = 0;
2346 
2347     sigprocmask(0, NULL, &set);
2348     host_to_target_sigset_internal(&target_set, &set);
2349     if (TARGET_NSIG_WORDS == 1) {
2350         err |= __put_user(target_set.sig[0],
2351                           (abi_ulong *)&ucp->tuc_sigmask);
2352     } else {
2353         abi_ulong *src, *dst;
2354         src = target_set.sig;
2355         dst = ucp->tuc_sigmask.sig;
2356         for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2357              i++, dst++, src++)
2358             err |= __put_user(*src, dst);
2359         if (err)
2360             goto do_sigsegv;
2361     }
2362 
2363     /* XXX: tstate must be saved properly */
2364     //    err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2365     err |= __put_user(env->pc, &((*grp)[MC_PC]));
2366     err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2367     err |= __put_user(env->y, &((*grp)[MC_Y]));
2368     err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2369     err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2370     err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2371     err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2372     err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2373     err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2374     err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2375     err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2376     err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2377     err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2378     err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2379     err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2380     err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2381     err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2382     err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2383 
2384     w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2385     fp = i7 = 0;
2386     if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2387                  abi_ulong) != 0)
2388         goto do_sigsegv;
2389     if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2390                  abi_ulong) != 0)
2391         goto do_sigsegv;
2392     err |= __put_user(fp, &(mcp->mc_fp));
2393     err |= __put_user(i7, &(mcp->mc_i7));
2394 
2395     {
2396         uint32_t *src, *dst;
2397         src = env->fpr;
2398         dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2399         /* XXX: check that the CPU storage is the same as user context */
2400         for (i = 0; i < 64; i++, dst++, src++)
2401             err |= __put_user(*src, dst);
2402     }
2403     err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2404     err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2405     err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2406 
2407     if (err)
2408         goto do_sigsegv;
2409     unlock_user_struct(ucp, ucp_addr, 1);
2410     return;
2411  do_sigsegv:
2412     unlock_user_struct(ucp, ucp_addr, 1);
2413     force_sig(TARGET_SIGSEGV);
2414 }
2415 #endif
2416 #elif defined(TARGET_ABI_MIPSN64)
2417 
2418 # warning signal handling not implemented
2419 
2420 static void setup_frame(int sig, struct target_sigaction *ka,
2421 			target_sigset_t *set, CPUState *env)
2422 {
2423     fprintf(stderr, "setup_frame: not implemented\n");
2424 }
2425 
2426 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2427                            target_siginfo_t *info,
2428 			   target_sigset_t *set, CPUState *env)
2429 {
2430     fprintf(stderr, "setup_rt_frame: not implemented\n");
2431 }
2432 
2433 long do_sigreturn(CPUState *env)
2434 {
2435     fprintf(stderr, "do_sigreturn: not implemented\n");
2436     return -TARGET_ENOSYS;
2437 }
2438 
2439 long do_rt_sigreturn(CPUState *env)
2440 {
2441     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2442     return -TARGET_ENOSYS;
2443 }
2444 
2445 #elif defined(TARGET_ABI_MIPSN32)
2446 
2447 # warning signal handling not implemented
2448 
2449 static void setup_frame(int sig, struct target_sigaction *ka,
2450 			target_sigset_t *set, CPUState *env)
2451 {
2452     fprintf(stderr, "setup_frame: not implemented\n");
2453 }
2454 
2455 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2456                            target_siginfo_t *info,
2457 			   target_sigset_t *set, CPUState *env)
2458 {
2459     fprintf(stderr, "setup_rt_frame: not implemented\n");
2460 }
2461 
2462 long do_sigreturn(CPUState *env)
2463 {
2464     fprintf(stderr, "do_sigreturn: not implemented\n");
2465     return -TARGET_ENOSYS;
2466 }
2467 
2468 long do_rt_sigreturn(CPUState *env)
2469 {
2470     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2471     return -TARGET_ENOSYS;
2472 }
2473 
2474 #elif defined(TARGET_ABI_MIPSO32)
2475 
2476 struct target_sigcontext {
2477     uint32_t   sc_regmask;     /* Unused */
2478     uint32_t   sc_status;
2479     uint64_t   sc_pc;
2480     uint64_t   sc_regs[32];
2481     uint64_t   sc_fpregs[32];
2482     uint32_t   sc_ownedfp;     /* Unused */
2483     uint32_t   sc_fpc_csr;
2484     uint32_t   sc_fpc_eir;     /* Unused */
2485     uint32_t   sc_used_math;
2486     uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
2487     uint32_t   pad0;
2488     uint64_t   sc_mdhi;
2489     uint64_t   sc_mdlo;
2490     target_ulong   sc_hi1;         /* Was sc_cause */
2491     target_ulong   sc_lo1;         /* Was sc_badvaddr */
2492     target_ulong   sc_hi2;         /* Was sc_sigset[4] */
2493     target_ulong   sc_lo2;
2494     target_ulong   sc_hi3;
2495     target_ulong   sc_lo3;
2496 };
2497 
2498 struct sigframe {
2499     uint32_t sf_ass[4];			/* argument save space for o32 */
2500     uint32_t sf_code[2];			/* signal trampoline */
2501     struct target_sigcontext sf_sc;
2502     target_sigset_t sf_mask;
2503 };
2504 
2505 struct target_ucontext {
2506     target_ulong tuc_flags;
2507     target_ulong tuc_link;
2508     target_stack_t tuc_stack;
2509     target_ulong pad0;
2510     struct target_sigcontext tuc_mcontext;
2511     target_sigset_t tuc_sigmask;
2512 };
2513 
2514 struct target_rt_sigframe {
2515     uint32_t rs_ass[4];               /* argument save space for o32 */
2516     uint32_t rs_code[2];              /* signal trampoline */
2517     struct target_siginfo rs_info;
2518     struct target_ucontext rs_uc;
2519 };
2520 
2521 /* Install trampoline to jump back from signal handler */
2522 static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
2523 {
2524     int err;
2525 
2526     /*
2527     * Set up the return code ...
2528     *
2529     *         li      v0, __NR__foo_sigreturn
2530     *         syscall
2531     */
2532 
2533     err = __put_user(0x24020000 + syscall, tramp + 0);
2534     err |= __put_user(0x0000000c          , tramp + 1);
2535     /* flush_cache_sigtramp((unsigned long) tramp); */
2536     return err;
2537 }
2538 
2539 static inline int
2540 setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2541 {
2542     int err = 0;
2543 
2544     err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
2545 
2546 #define save_gp_reg(i) do {   						\
2547         err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);	\
2548     } while(0)
2549     __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2550     save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2551     save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2552     save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2553     save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2554     save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2555     save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2556     save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2557     save_gp_reg(31);
2558 #undef save_gp_reg
2559 
2560     err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2561     err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2562 
2563     /* Not used yet, but might be useful if we ever have DSP suppport */
2564 #if 0
2565     if (cpu_has_dsp) {
2566 	err |= __put_user(mfhi1(), &sc->sc_hi1);
2567 	err |= __put_user(mflo1(), &sc->sc_lo1);
2568 	err |= __put_user(mfhi2(), &sc->sc_hi2);
2569 	err |= __put_user(mflo2(), &sc->sc_lo2);
2570 	err |= __put_user(mfhi3(), &sc->sc_hi3);
2571 	err |= __put_user(mflo3(), &sc->sc_lo3);
2572 	err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2573     }
2574     /* same with 64 bit */
2575 #ifdef CONFIG_64BIT
2576     err |= __put_user(regs->hi, &sc->sc_hi[0]);
2577     err |= __put_user(regs->lo, &sc->sc_lo[0]);
2578     if (cpu_has_dsp) {
2579 	err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2580 	err |= __put_user(mflo1(), &sc->sc_lo[1]);
2581 	err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2582 	err |= __put_user(mflo2(), &sc->sc_lo[2]);
2583 	err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2584 	err |= __put_user(mflo3(), &sc->sc_lo[3]);
2585 	err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2586     }
2587 #endif
2588 #endif
2589 
2590 #if 0
2591     err |= __put_user(!!used_math(), &sc->sc_used_math);
2592 
2593     if (!used_math())
2594 	goto out;
2595 
2596     /*
2597     * Save FPU state to signal context.  Signal handler will "inherit"
2598     * current FPU state.
2599     */
2600     preempt_disable();
2601 
2602     if (!is_fpu_owner()) {
2603 	own_fpu();
2604 	restore_fp(current);
2605     }
2606     err |= save_fp_context(sc);
2607 
2608     preempt_enable();
2609     out:
2610 #endif
2611     return err;
2612 }
2613 
2614 static inline int
2615 restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2616 {
2617     int err = 0;
2618 
2619     err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2620 
2621     err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2622     err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2623 
2624 #define restore_gp_reg(i) do {   							\
2625         err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);		\
2626     } while(0)
2627     restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2628     restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2629     restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2630     restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2631     restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2632     restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2633     restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2634     restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2635     restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2636     restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2637     restore_gp_reg(31);
2638 #undef restore_gp_reg
2639 
2640 #if 0
2641     if (cpu_has_dsp) {
2642 	err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2643 	err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2644 	err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2645 	err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2646 	err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2647 	err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2648 	err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2649     }
2650 #ifdef CONFIG_64BIT
2651     err |= __get_user(regs->hi, &sc->sc_hi[0]);
2652     err |= __get_user(regs->lo, &sc->sc_lo[0]);
2653     if (cpu_has_dsp) {
2654 	err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2655 	err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2656 	err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2657 	err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2658 	err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2659 	err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2660 	err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2661     }
2662 #endif
2663 
2664     err |= __get_user(used_math, &sc->sc_used_math);
2665     conditional_used_math(used_math);
2666 
2667     preempt_disable();
2668 
2669     if (used_math()) {
2670 	/* restore fpu context if we have used it before */
2671 	own_fpu();
2672 	err |= restore_fp_context(sc);
2673     } else {
2674 	/* signal handler may have used FPU.  Give it up. */
2675 	lose_fpu();
2676     }
2677 
2678     preempt_enable();
2679 #endif
2680     return err;
2681 }
2682 /*
2683  * Determine which stack to use..
2684  */
2685 static inline abi_ulong
2686 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
2687 {
2688     unsigned long sp;
2689 
2690     /* Default to using normal stack */
2691     sp = regs->active_tc.gpr[29];
2692 
2693     /*
2694      * FPU emulator may have it's own trampoline active just
2695      * above the user stack, 16-bytes before the next lowest
2696      * 16 byte boundary.  Try to avoid trashing it.
2697      */
2698     sp -= 32;
2699 
2700     /* This is the X/Open sanctioned signal stack switching.  */
2701     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2702         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2703     }
2704 
2705     return (sp - frame_size) & ~7;
2706 }
2707 
2708 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2709 static void setup_frame(int sig, struct target_sigaction * ka,
2710                         target_sigset_t *set, CPUState *regs)
2711 {
2712     struct sigframe *frame;
2713     abi_ulong frame_addr;
2714     int i;
2715 
2716     frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2717     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2718 	goto give_sigsegv;
2719 
2720     install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2721 
2722     if(setup_sigcontext(regs, &frame->sf_sc))
2723 	goto give_sigsegv;
2724 
2725     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2726 	if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2727 	    goto give_sigsegv;
2728     }
2729 
2730     /*
2731     * Arguments to signal handler:
2732     *
2733     *   a0 = signal number
2734     *   a1 = 0 (should be cause)
2735     *   a2 = pointer to struct sigcontext
2736     *
2737     * $25 and PC point to the signal handler, $29 points to the
2738     * struct sigframe.
2739     */
2740     regs->active_tc.gpr[ 4] = sig;
2741     regs->active_tc.gpr[ 5] = 0;
2742     regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2743     regs->active_tc.gpr[29] = frame_addr;
2744     regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2745     /* The original kernel code sets CP0_EPC to the handler
2746     * since it returns to userland using eret
2747     * we cannot do this here, and we must set PC directly */
2748     regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2749     unlock_user_struct(frame, frame_addr, 1);
2750     return;
2751 
2752 give_sigsegv:
2753     unlock_user_struct(frame, frame_addr, 1);
2754     force_sig(TARGET_SIGSEGV/*, current*/);
2755     return;
2756 }
2757 
2758 long do_sigreturn(CPUState *regs)
2759 {
2760     struct sigframe *frame;
2761     abi_ulong frame_addr;
2762     sigset_t blocked;
2763     target_sigset_t target_set;
2764     int i;
2765 
2766 #if defined(DEBUG_SIGNAL)
2767     fprintf(stderr, "do_sigreturn\n");
2768 #endif
2769     frame_addr = regs->active_tc.gpr[29];
2770     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2771    	goto badframe;
2772 
2773     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2774    	if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2775 	    goto badframe;
2776     }
2777 
2778     target_to_host_sigset_internal(&blocked, &target_set);
2779     sigprocmask(SIG_SETMASK, &blocked, NULL);
2780 
2781     if (restore_sigcontext(regs, &frame->sf_sc))
2782    	goto badframe;
2783 
2784 #if 0
2785     /*
2786      * Don't let your children do this ...
2787      */
2788     __asm__ __volatile__(
2789    	"move\t$29, %0\n\t"
2790    	"j\tsyscall_exit"
2791    	:/* no outputs */
2792    	:"r" (&regs));
2793     /* Unreached */
2794 #endif
2795 
2796     regs->active_tc.PC = regs->CP0_EPC;
2797     /* I am not sure this is right, but it seems to work
2798     * maybe a problem with nested signals ? */
2799     regs->CP0_EPC = 0;
2800     return -TARGET_QEMU_ESIGRETURN;
2801 
2802 badframe:
2803     force_sig(TARGET_SIGSEGV/*, current*/);
2804     return 0;
2805 }
2806 
2807 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2808                            target_siginfo_t *info,
2809 			   target_sigset_t *set, CPUState *env)
2810 {
2811     struct target_rt_sigframe *frame;
2812     abi_ulong frame_addr;
2813     int i;
2814 
2815     frame_addr = get_sigframe(ka, env, sizeof(*frame));
2816     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2817 	goto give_sigsegv;
2818 
2819     install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
2820 
2821     copy_siginfo_to_user(&frame->rs_info, info);
2822 
2823     __put_user(0, &frame->rs_uc.tuc_flags);
2824     __put_user(0, &frame->rs_uc.tuc_link);
2825     __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
2826     __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
2827     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
2828                &frame->rs_uc.tuc_stack.ss_flags);
2829 
2830     setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
2831 
2832     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2833         __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
2834     }
2835 
2836     /*
2837     * Arguments to signal handler:
2838     *
2839     *   a0 = signal number
2840     *   a1 = pointer to struct siginfo
2841     *   a2 = pointer to struct ucontext
2842     *
2843     * $25 and PC point to the signal handler, $29 points to the
2844     * struct sigframe.
2845     */
2846     env->active_tc.gpr[ 4] = sig;
2847     env->active_tc.gpr[ 5] = frame_addr
2848                              + offsetof(struct target_rt_sigframe, rs_info);
2849     env->active_tc.gpr[ 6] = frame_addr
2850                              + offsetof(struct target_rt_sigframe, rs_uc);
2851     env->active_tc.gpr[29] = frame_addr;
2852     env->active_tc.gpr[31] = frame_addr
2853                              + offsetof(struct target_rt_sigframe, rs_code);
2854     /* The original kernel code sets CP0_EPC to the handler
2855     * since it returns to userland using eret
2856     * we cannot do this here, and we must set PC directly */
2857     env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
2858     unlock_user_struct(frame, frame_addr, 1);
2859     return;
2860 
2861 give_sigsegv:
2862     unlock_user_struct(frame, frame_addr, 1);
2863     force_sig(TARGET_SIGSEGV/*, current*/);
2864     return;
2865 }
2866 
2867 long do_rt_sigreturn(CPUState *env)
2868 {
2869     struct target_rt_sigframe *frame;
2870     abi_ulong frame_addr;
2871     sigset_t blocked;
2872 
2873 #if defined(DEBUG_SIGNAL)
2874     fprintf(stderr, "do_rt_sigreturn\n");
2875 #endif
2876     frame_addr = env->active_tc.gpr[29];
2877     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2878    	goto badframe;
2879 
2880     target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
2881     sigprocmask(SIG_SETMASK, &blocked, NULL);
2882 
2883     if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
2884         goto badframe;
2885 
2886     if (do_sigaltstack(frame_addr +
2887 		       offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
2888 		       0, get_sp_from_cpustate(env)) == -EFAULT)
2889         goto badframe;
2890 
2891     env->active_tc.PC = env->CP0_EPC;
2892     /* I am not sure this is right, but it seems to work
2893     * maybe a problem with nested signals ? */
2894     env->CP0_EPC = 0;
2895     return -TARGET_QEMU_ESIGRETURN;
2896 
2897 badframe:
2898     force_sig(TARGET_SIGSEGV/*, current*/);
2899     return 0;
2900 }
2901 
2902 #elif defined(TARGET_SH4)
2903 
2904 /*
2905  * code and data structures from linux kernel:
2906  * include/asm-sh/sigcontext.h
2907  * arch/sh/kernel/signal.c
2908  */
2909 
2910 struct target_sigcontext {
2911     target_ulong  oldmask;
2912 
2913     /* CPU registers */
2914     target_ulong  sc_gregs[16];
2915     target_ulong  sc_pc;
2916     target_ulong  sc_pr;
2917     target_ulong  sc_sr;
2918     target_ulong  sc_gbr;
2919     target_ulong  sc_mach;
2920     target_ulong  sc_macl;
2921 
2922     /* FPU registers */
2923     target_ulong  sc_fpregs[16];
2924     target_ulong  sc_xfpregs[16];
2925     unsigned int sc_fpscr;
2926     unsigned int sc_fpul;
2927     unsigned int sc_ownedfp;
2928 };
2929 
2930 struct target_sigframe
2931 {
2932     struct target_sigcontext sc;
2933     target_ulong extramask[TARGET_NSIG_WORDS-1];
2934     uint16_t retcode[3];
2935 };
2936 
2937 
2938 struct target_ucontext {
2939     target_ulong tuc_flags;
2940     struct target_ucontext *tuc_link;
2941     target_stack_t tuc_stack;
2942     struct target_sigcontext tuc_mcontext;
2943     target_sigset_t tuc_sigmask;	/* mask last for extensibility */
2944 };
2945 
2946 struct target_rt_sigframe
2947 {
2948     struct target_siginfo info;
2949     struct target_ucontext uc;
2950     uint16_t retcode[3];
2951 };
2952 
2953 
2954 #define MOVW(n)  (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2955 #define TRAP_NOARG 0xc310         /* Syscall w/no args (NR in R3) SH3/4 */
2956 
2957 static abi_ulong get_sigframe(struct target_sigaction *ka,
2958                          unsigned long sp, size_t frame_size)
2959 {
2960     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
2961         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2962     }
2963 
2964     return (sp - frame_size) & -8ul;
2965 }
2966 
2967 static int setup_sigcontext(struct target_sigcontext *sc,
2968 			    CPUState *regs, unsigned long mask)
2969 {
2970     int err = 0;
2971     int i;
2972 
2973 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
2974     COPY(gregs[0]); COPY(gregs[1]);
2975     COPY(gregs[2]); COPY(gregs[3]);
2976     COPY(gregs[4]); COPY(gregs[5]);
2977     COPY(gregs[6]); COPY(gregs[7]);
2978     COPY(gregs[8]); COPY(gregs[9]);
2979     COPY(gregs[10]); COPY(gregs[11]);
2980     COPY(gregs[12]); COPY(gregs[13]);
2981     COPY(gregs[14]); COPY(gregs[15]);
2982     COPY(gbr); COPY(mach);
2983     COPY(macl); COPY(pr);
2984     COPY(sr); COPY(pc);
2985 #undef COPY
2986 
2987     for (i=0; i<16; i++) {
2988         err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
2989     }
2990     err |= __put_user(regs->fpscr, &sc->sc_fpscr);
2991     err |= __put_user(regs->fpul, &sc->sc_fpul);
2992 
2993     /* non-iBCS2 extensions.. */
2994     err |= __put_user(mask, &sc->oldmask);
2995 
2996     return err;
2997 }
2998 
2999 static int restore_sigcontext(CPUState *regs, struct target_sigcontext *sc,
3000                               target_ulong *r0_p)
3001 {
3002     unsigned int err = 0;
3003     int i;
3004 
3005 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
3006     COPY(gregs[1]);
3007     COPY(gregs[2]); COPY(gregs[3]);
3008     COPY(gregs[4]); COPY(gregs[5]);
3009     COPY(gregs[6]); COPY(gregs[7]);
3010     COPY(gregs[8]); COPY(gregs[9]);
3011     COPY(gregs[10]); COPY(gregs[11]);
3012     COPY(gregs[12]); COPY(gregs[13]);
3013     COPY(gregs[14]); COPY(gregs[15]);
3014     COPY(gbr); COPY(mach);
3015     COPY(macl); COPY(pr);
3016     COPY(sr); COPY(pc);
3017 #undef COPY
3018 
3019     for (i=0; i<16; i++) {
3020         err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3021     }
3022     err |= __get_user(regs->fpscr, &sc->sc_fpscr);
3023     err |= __get_user(regs->fpul, &sc->sc_fpul);
3024 
3025     regs->tra = -1;         /* disable syscall checks */
3026     err |= __get_user(*r0_p, &sc->sc_gregs[0]);
3027     return err;
3028 }
3029 
3030 static void setup_frame(int sig, struct target_sigaction *ka,
3031 			target_sigset_t *set, CPUState *regs)
3032 {
3033     struct target_sigframe *frame;
3034     abi_ulong frame_addr;
3035     int i;
3036     int err = 0;
3037     int signal;
3038 
3039     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3040     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3041 	goto give_sigsegv;
3042 
3043     signal = current_exec_domain_sig(sig);
3044 
3045     err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
3046 
3047     for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3048         err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
3049     }
3050 
3051     /* Set up to return from userspace.  If provided, use a stub
3052        already in userspace.  */
3053     if (ka->sa_flags & TARGET_SA_RESTORER) {
3054         regs->pr = (unsigned long) ka->sa_restorer;
3055     } else {
3056         /* Generate return code (system call to sigreturn) */
3057         err |= __put_user(MOVW(2), &frame->retcode[0]);
3058         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3059         err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3060         regs->pr = (unsigned long) frame->retcode;
3061     }
3062 
3063     if (err)
3064         goto give_sigsegv;
3065 
3066     /* Set up registers for signal handler */
3067     regs->gregs[15] = frame_addr;
3068     regs->gregs[4] = signal; /* Arg for signal handler */
3069     regs->gregs[5] = 0;
3070     regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
3071     regs->pc = (unsigned long) ka->_sa_handler;
3072 
3073     unlock_user_struct(frame, frame_addr, 1);
3074     return;
3075 
3076 give_sigsegv:
3077     unlock_user_struct(frame, frame_addr, 1);
3078     force_sig(TARGET_SIGSEGV);
3079 }
3080 
3081 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3082                            target_siginfo_t *info,
3083 			   target_sigset_t *set, CPUState *regs)
3084 {
3085     struct target_rt_sigframe *frame;
3086     abi_ulong frame_addr;
3087     int i;
3088     int err = 0;
3089     int signal;
3090 
3091     frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3092     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3093 	goto give_sigsegv;
3094 
3095     signal = current_exec_domain_sig(sig);
3096 
3097     err |= copy_siginfo_to_user(&frame->info, info);
3098 
3099     /* Create the ucontext.  */
3100     err |= __put_user(0, &frame->uc.tuc_flags);
3101     err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3102     err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3103 		      &frame->uc.tuc_stack.ss_sp);
3104     err |= __put_user(sas_ss_flags(regs->gregs[15]),
3105 		      &frame->uc.tuc_stack.ss_flags);
3106     err |= __put_user(target_sigaltstack_used.ss_size,
3107 		      &frame->uc.tuc_stack.ss_size);
3108     err |= setup_sigcontext(&frame->uc.tuc_mcontext,
3109 			    regs, set->sig[0]);
3110     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3111         err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
3112     }
3113 
3114     /* Set up to return from userspace.  If provided, use a stub
3115        already in userspace.  */
3116     if (ka->sa_flags & TARGET_SA_RESTORER) {
3117         regs->pr = (unsigned long) ka->sa_restorer;
3118     } else {
3119         /* Generate return code (system call to sigreturn) */
3120         err |= __put_user(MOVW(2), &frame->retcode[0]);
3121         err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
3122         err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3123         regs->pr = (unsigned long) frame->retcode;
3124     }
3125 
3126     if (err)
3127         goto give_sigsegv;
3128 
3129     /* Set up registers for signal handler */
3130     regs->gregs[15] = frame_addr;
3131     regs->gregs[4] = signal; /* Arg for signal handler */
3132     regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3133     regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
3134     regs->pc = (unsigned long) ka->_sa_handler;
3135 
3136     unlock_user_struct(frame, frame_addr, 1);
3137     return;
3138 
3139 give_sigsegv:
3140     unlock_user_struct(frame, frame_addr, 1);
3141     force_sig(TARGET_SIGSEGV);
3142 }
3143 
3144 long do_sigreturn(CPUState *regs)
3145 {
3146     struct target_sigframe *frame;
3147     abi_ulong frame_addr;
3148     sigset_t blocked;
3149     target_sigset_t target_set;
3150     target_ulong r0;
3151     int i;
3152     int err = 0;
3153 
3154 #if defined(DEBUG_SIGNAL)
3155     fprintf(stderr, "do_sigreturn\n");
3156 #endif
3157     frame_addr = regs->gregs[15];
3158     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3159    	goto badframe;
3160 
3161     err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
3162     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3163         err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
3164     }
3165 
3166     if (err)
3167         goto badframe;
3168 
3169     target_to_host_sigset_internal(&blocked, &target_set);
3170     sigprocmask(SIG_SETMASK, &blocked, NULL);
3171 
3172     if (restore_sigcontext(regs, &frame->sc, &r0))
3173         goto badframe;
3174 
3175     unlock_user_struct(frame, frame_addr, 0);
3176     return r0;
3177 
3178 badframe:
3179     unlock_user_struct(frame, frame_addr, 0);
3180     force_sig(TARGET_SIGSEGV);
3181     return 0;
3182 }
3183 
3184 long do_rt_sigreturn(CPUState *regs)
3185 {
3186     struct target_rt_sigframe *frame;
3187     abi_ulong frame_addr;
3188     sigset_t blocked;
3189     target_ulong r0;
3190 
3191 #if defined(DEBUG_SIGNAL)
3192     fprintf(stderr, "do_rt_sigreturn\n");
3193 #endif
3194     frame_addr = regs->gregs[15];
3195     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3196    	goto badframe;
3197 
3198     target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3199     sigprocmask(SIG_SETMASK, &blocked, NULL);
3200 
3201     if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
3202         goto badframe;
3203 
3204     if (do_sigaltstack(frame_addr +
3205 		       offsetof(struct target_rt_sigframe, uc.tuc_stack),
3206 		       0, get_sp_from_cpustate(regs)) == -EFAULT)
3207         goto badframe;
3208 
3209     unlock_user_struct(frame, frame_addr, 0);
3210     return r0;
3211 
3212 badframe:
3213     unlock_user_struct(frame, frame_addr, 0);
3214     force_sig(TARGET_SIGSEGV);
3215     return 0;
3216 }
3217 #elif defined(TARGET_MICROBLAZE)
3218 
3219 struct target_sigcontext {
3220     struct target_pt_regs regs;  /* needs to be first */
3221     uint32_t oldmask;
3222 };
3223 
3224 struct target_stack_t {
3225     abi_ulong ss_sp;
3226     int ss_flags;
3227     unsigned int ss_size;
3228 };
3229 
3230 struct target_ucontext {
3231     abi_ulong tuc_flags;
3232     abi_ulong tuc_link;
3233     struct target_stack_t tuc_stack;
3234     struct target_sigcontext tuc_mcontext;
3235     uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
3236 };
3237 
3238 /* Signal frames. */
3239 struct target_signal_frame {
3240     struct target_ucontext uc;
3241     uint32_t extramask[TARGET_NSIG_WORDS - 1];
3242     uint32_t tramp[2];
3243 };
3244 
3245 struct rt_signal_frame {
3246     struct siginfo info;
3247     struct ucontext uc;
3248     uint32_t tramp[2];
3249 };
3250 
3251 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3252 {
3253     __put_user(env->regs[0], &sc->regs.r0);
3254     __put_user(env->regs[1], &sc->regs.r1);
3255     __put_user(env->regs[2], &sc->regs.r2);
3256     __put_user(env->regs[3], &sc->regs.r3);
3257     __put_user(env->regs[4], &sc->regs.r4);
3258     __put_user(env->regs[5], &sc->regs.r5);
3259     __put_user(env->regs[6], &sc->regs.r6);
3260     __put_user(env->regs[7], &sc->regs.r7);
3261     __put_user(env->regs[8], &sc->regs.r8);
3262     __put_user(env->regs[9], &sc->regs.r9);
3263     __put_user(env->regs[10], &sc->regs.r10);
3264     __put_user(env->regs[11], &sc->regs.r11);
3265     __put_user(env->regs[12], &sc->regs.r12);
3266     __put_user(env->regs[13], &sc->regs.r13);
3267     __put_user(env->regs[14], &sc->regs.r14);
3268     __put_user(env->regs[15], &sc->regs.r15);
3269     __put_user(env->regs[16], &sc->regs.r16);
3270     __put_user(env->regs[17], &sc->regs.r17);
3271     __put_user(env->regs[18], &sc->regs.r18);
3272     __put_user(env->regs[19], &sc->regs.r19);
3273     __put_user(env->regs[20], &sc->regs.r20);
3274     __put_user(env->regs[21], &sc->regs.r21);
3275     __put_user(env->regs[22], &sc->regs.r22);
3276     __put_user(env->regs[23], &sc->regs.r23);
3277     __put_user(env->regs[24], &sc->regs.r24);
3278     __put_user(env->regs[25], &sc->regs.r25);
3279     __put_user(env->regs[26], &sc->regs.r26);
3280     __put_user(env->regs[27], &sc->regs.r27);
3281     __put_user(env->regs[28], &sc->regs.r28);
3282     __put_user(env->regs[29], &sc->regs.r29);
3283     __put_user(env->regs[30], &sc->regs.r30);
3284     __put_user(env->regs[31], &sc->regs.r31);
3285     __put_user(env->sregs[SR_PC], &sc->regs.pc);
3286 }
3287 
3288 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3289 {
3290     __get_user(env->regs[0], &sc->regs.r0);
3291     __get_user(env->regs[1], &sc->regs.r1);
3292     __get_user(env->regs[2], &sc->regs.r2);
3293     __get_user(env->regs[3], &sc->regs.r3);
3294     __get_user(env->regs[4], &sc->regs.r4);
3295     __get_user(env->regs[5], &sc->regs.r5);
3296     __get_user(env->regs[6], &sc->regs.r6);
3297     __get_user(env->regs[7], &sc->regs.r7);
3298     __get_user(env->regs[8], &sc->regs.r8);
3299     __get_user(env->regs[9], &sc->regs.r9);
3300     __get_user(env->regs[10], &sc->regs.r10);
3301     __get_user(env->regs[11], &sc->regs.r11);
3302     __get_user(env->regs[12], &sc->regs.r12);
3303     __get_user(env->regs[13], &sc->regs.r13);
3304     __get_user(env->regs[14], &sc->regs.r14);
3305     __get_user(env->regs[15], &sc->regs.r15);
3306     __get_user(env->regs[16], &sc->regs.r16);
3307     __get_user(env->regs[17], &sc->regs.r17);
3308     __get_user(env->regs[18], &sc->regs.r18);
3309     __get_user(env->regs[19], &sc->regs.r19);
3310     __get_user(env->regs[20], &sc->regs.r20);
3311     __get_user(env->regs[21], &sc->regs.r21);
3312     __get_user(env->regs[22], &sc->regs.r22);
3313     __get_user(env->regs[23], &sc->regs.r23);
3314     __get_user(env->regs[24], &sc->regs.r24);
3315     __get_user(env->regs[25], &sc->regs.r25);
3316     __get_user(env->regs[26], &sc->regs.r26);
3317     __get_user(env->regs[27], &sc->regs.r27);
3318     __get_user(env->regs[28], &sc->regs.r28);
3319     __get_user(env->regs[29], &sc->regs.r29);
3320     __get_user(env->regs[30], &sc->regs.r30);
3321     __get_user(env->regs[31], &sc->regs.r31);
3322     __get_user(env->sregs[SR_PC], &sc->regs.pc);
3323 }
3324 
3325 static abi_ulong get_sigframe(struct target_sigaction *ka,
3326                               CPUState *env, int frame_size)
3327 {
3328     abi_ulong sp = env->regs[1];
3329 
3330     if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3331         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3332 
3333     return ((sp - frame_size) & -8UL);
3334 }
3335 
3336 static void setup_frame(int sig, struct target_sigaction *ka,
3337 			target_sigset_t *set, CPUState *env)
3338 {
3339     struct target_signal_frame *frame;
3340     abi_ulong frame_addr;
3341     int err = 0;
3342     int i;
3343 
3344     frame_addr = get_sigframe(ka, env, sizeof *frame);
3345     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3346         goto badframe;
3347 
3348     /* Save the mask.  */
3349     err |= __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
3350     if (err)
3351         goto badframe;
3352 
3353     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3354         if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3355             goto badframe;
3356     }
3357 
3358     setup_sigcontext(&frame->uc.tuc_mcontext, env);
3359 
3360     /* Set up to return from userspace. If provided, use a stub
3361        already in userspace. */
3362     /* minus 8 is offset to cater for "rtsd r15,8" offset */
3363     if (ka->sa_flags & TARGET_SA_RESTORER) {
3364         env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3365     } else {
3366         uint32_t t;
3367         /* Note, these encodings are _big endian_! */
3368         /* addi r12, r0, __NR_sigreturn */
3369         t = 0x31800000UL | TARGET_NR_sigreturn;
3370         err |= __put_user(t, frame->tramp + 0);
3371         /* brki r14, 0x8 */
3372         t = 0xb9cc0008UL;
3373         err |= __put_user(t, frame->tramp + 1);
3374 
3375         /* Return from sighandler will jump to the tramp.
3376            Negative 8 offset because return is rtsd r15, 8 */
3377         env->regs[15] = ((unsigned long)frame->tramp) - 8;
3378     }
3379 
3380     if (err)
3381         goto badframe;
3382 
3383     /* Set up registers for signal handler */
3384     env->regs[1] = frame_addr;
3385     /* Signal handler args: */
3386     env->regs[5] = sig; /* Arg 0: signum */
3387     env->regs[6] = 0;
3388     /* arg 1: sigcontext */
3389     env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
3390 
3391     /* Offset of 4 to handle microblaze rtid r14, 0 */
3392     env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3393 
3394     unlock_user_struct(frame, frame_addr, 1);
3395     return;
3396   badframe:
3397     unlock_user_struct(frame, frame_addr, 1);
3398     force_sig(TARGET_SIGSEGV);
3399 }
3400 
3401 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3402                            target_siginfo_t *info,
3403 			   target_sigset_t *set, CPUState *env)
3404 {
3405     fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3406 }
3407 
3408 long do_sigreturn(CPUState *env)
3409 {
3410     struct target_signal_frame *frame;
3411     abi_ulong frame_addr;
3412     target_sigset_t target_set;
3413     sigset_t set;
3414     int i;
3415 
3416     frame_addr = env->regs[R_SP];
3417     /* Make sure the guest isn't playing games.  */
3418     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3419         goto badframe;
3420 
3421     /* Restore blocked signals */
3422     if (__get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask))
3423         goto badframe;
3424     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3425         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3426             goto badframe;
3427     }
3428     target_to_host_sigset_internal(&set, &target_set);
3429     sigprocmask(SIG_SETMASK, &set, NULL);
3430 
3431     restore_sigcontext(&frame->uc.tuc_mcontext, env);
3432     /* We got here through a sigreturn syscall, our path back is via an
3433        rtb insn so setup r14 for that.  */
3434     env->regs[14] = env->sregs[SR_PC];
3435 
3436     unlock_user_struct(frame, frame_addr, 0);
3437     return env->regs[10];
3438   badframe:
3439     unlock_user_struct(frame, frame_addr, 0);
3440     force_sig(TARGET_SIGSEGV);
3441 }
3442 
3443 long do_rt_sigreturn(CPUState *env)
3444 {
3445     fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3446     return -TARGET_ENOSYS;
3447 }
3448 
3449 #elif defined(TARGET_CRIS)
3450 
3451 struct target_sigcontext {
3452         struct target_pt_regs regs;  /* needs to be first */
3453         uint32_t oldmask;
3454         uint32_t usp;    /* usp before stacking this gunk on it */
3455 };
3456 
3457 /* Signal frames. */
3458 struct target_signal_frame {
3459         struct target_sigcontext sc;
3460         uint32_t extramask[TARGET_NSIG_WORDS - 1];
3461         uint8_t retcode[8];       /* Trampoline code. */
3462 };
3463 
3464 struct rt_signal_frame {
3465         struct siginfo *pinfo;
3466         void *puc;
3467         struct siginfo info;
3468         struct ucontext uc;
3469         uint8_t retcode[8];       /* Trampoline code. */
3470 };
3471 
3472 static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3473 {
3474 	__put_user(env->regs[0], &sc->regs.r0);
3475 	__put_user(env->regs[1], &sc->regs.r1);
3476 	__put_user(env->regs[2], &sc->regs.r2);
3477 	__put_user(env->regs[3], &sc->regs.r3);
3478 	__put_user(env->regs[4], &sc->regs.r4);
3479 	__put_user(env->regs[5], &sc->regs.r5);
3480 	__put_user(env->regs[6], &sc->regs.r6);
3481 	__put_user(env->regs[7], &sc->regs.r7);
3482 	__put_user(env->regs[8], &sc->regs.r8);
3483 	__put_user(env->regs[9], &sc->regs.r9);
3484 	__put_user(env->regs[10], &sc->regs.r10);
3485 	__put_user(env->regs[11], &sc->regs.r11);
3486 	__put_user(env->regs[12], &sc->regs.r12);
3487 	__put_user(env->regs[13], &sc->regs.r13);
3488 	__put_user(env->regs[14], &sc->usp);
3489 	__put_user(env->regs[15], &sc->regs.acr);
3490 	__put_user(env->pregs[PR_MOF], &sc->regs.mof);
3491 	__put_user(env->pregs[PR_SRP], &sc->regs.srp);
3492 	__put_user(env->pc, &sc->regs.erp);
3493 }
3494 
3495 static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3496 {
3497 	__get_user(env->regs[0], &sc->regs.r0);
3498 	__get_user(env->regs[1], &sc->regs.r1);
3499 	__get_user(env->regs[2], &sc->regs.r2);
3500 	__get_user(env->regs[3], &sc->regs.r3);
3501 	__get_user(env->regs[4], &sc->regs.r4);
3502 	__get_user(env->regs[5], &sc->regs.r5);
3503 	__get_user(env->regs[6], &sc->regs.r6);
3504 	__get_user(env->regs[7], &sc->regs.r7);
3505 	__get_user(env->regs[8], &sc->regs.r8);
3506 	__get_user(env->regs[9], &sc->regs.r9);
3507 	__get_user(env->regs[10], &sc->regs.r10);
3508 	__get_user(env->regs[11], &sc->regs.r11);
3509 	__get_user(env->regs[12], &sc->regs.r12);
3510 	__get_user(env->regs[13], &sc->regs.r13);
3511 	__get_user(env->regs[14], &sc->usp);
3512 	__get_user(env->regs[15], &sc->regs.acr);
3513 	__get_user(env->pregs[PR_MOF], &sc->regs.mof);
3514 	__get_user(env->pregs[PR_SRP], &sc->regs.srp);
3515 	__get_user(env->pc, &sc->regs.erp);
3516 }
3517 
3518 static abi_ulong get_sigframe(CPUState *env, int framesize)
3519 {
3520 	abi_ulong sp;
3521 	/* Align the stack downwards to 4.  */
3522 	sp = (env->regs[R_SP] & ~3);
3523 	return sp - framesize;
3524 }
3525 
3526 static void setup_frame(int sig, struct target_sigaction *ka,
3527 			target_sigset_t *set, CPUState *env)
3528 {
3529 	struct target_signal_frame *frame;
3530 	abi_ulong frame_addr;
3531 	int err = 0;
3532 	int i;
3533 
3534 	frame_addr = get_sigframe(env, sizeof *frame);
3535 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3536 		goto badframe;
3537 
3538 	/*
3539 	 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3540 	 * use this trampoline anymore but it sets it up for GDB.
3541 	 * In QEMU, using the trampoline simplifies things a bit so we use it.
3542 	 *
3543 	 * This is movu.w __NR_sigreturn, r9; break 13;
3544 	 */
3545 	err |= __put_user(0x9c5f, frame->retcode+0);
3546 	err |= __put_user(TARGET_NR_sigreturn,
3547 			  frame->retcode+2);
3548 	err |= __put_user(0xe93d, frame->retcode+4);
3549 
3550 	/* Save the mask.  */
3551 	err |= __put_user(set->sig[0], &frame->sc.oldmask);
3552 	if (err)
3553 		goto badframe;
3554 
3555 	for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3556 		if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3557 			goto badframe;
3558 	}
3559 
3560 	setup_sigcontext(&frame->sc, env);
3561 
3562 	/* Move the stack and setup the arguments for the handler.  */
3563 	env->regs[R_SP] = frame_addr;
3564 	env->regs[10] = sig;
3565 	env->pc = (unsigned long) ka->_sa_handler;
3566 	/* Link SRP so the guest returns through the trampoline.  */
3567 	env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
3568 
3569 	unlock_user_struct(frame, frame_addr, 1);
3570 	return;
3571   badframe:
3572 	unlock_user_struct(frame, frame_addr, 1);
3573 	force_sig(TARGET_SIGSEGV);
3574 }
3575 
3576 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3577                            target_siginfo_t *info,
3578 			   target_sigset_t *set, CPUState *env)
3579 {
3580     fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3581 }
3582 
3583 long do_sigreturn(CPUState *env)
3584 {
3585 	struct target_signal_frame *frame;
3586 	abi_ulong frame_addr;
3587 	target_sigset_t target_set;
3588 	sigset_t set;
3589 	int i;
3590 
3591 	frame_addr = env->regs[R_SP];
3592 	/* Make sure the guest isn't playing games.  */
3593 	if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3594 		goto badframe;
3595 
3596 	/* Restore blocked signals */
3597 	if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3598 		goto badframe;
3599 	for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3600 		if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3601 			goto badframe;
3602 	}
3603 	target_to_host_sigset_internal(&set, &target_set);
3604 	sigprocmask(SIG_SETMASK, &set, NULL);
3605 
3606 	restore_sigcontext(&frame->sc, env);
3607 	unlock_user_struct(frame, frame_addr, 0);
3608 	return env->regs[10];
3609   badframe:
3610 	unlock_user_struct(frame, frame_addr, 0);
3611 	force_sig(TARGET_SIGSEGV);
3612 }
3613 
3614 long do_rt_sigreturn(CPUState *env)
3615 {
3616     fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3617     return -TARGET_ENOSYS;
3618 }
3619 
3620 #elif defined(TARGET_S390X)
3621 
3622 #define __NUM_GPRS 16
3623 #define __NUM_FPRS 16
3624 #define __NUM_ACRS 16
3625 
3626 #define S390_SYSCALL_SIZE   2
3627 #define __SIGNAL_FRAMESIZE      160 /* FIXME: 31-bit mode -> 96 */
3628 
3629 #define _SIGCONTEXT_NSIG        64
3630 #define _SIGCONTEXT_NSIG_BPW    64 /* FIXME: 31-bit mode -> 32 */
3631 #define _SIGCONTEXT_NSIG_WORDS  (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
3632 #define _SIGMASK_COPY_SIZE    (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
3633 #define PSW_ADDR_AMODE            0x0000000000000000UL /* 0x80000000UL for 31-bit */
3634 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
3635 
3636 typedef struct {
3637     target_psw_t psw;
3638     target_ulong gprs[__NUM_GPRS];
3639     unsigned int acrs[__NUM_ACRS];
3640 } target_s390_regs_common;
3641 
3642 typedef struct {
3643     unsigned int fpc;
3644     double   fprs[__NUM_FPRS];
3645 } target_s390_fp_regs;
3646 
3647 typedef struct {
3648     target_s390_regs_common regs;
3649     target_s390_fp_regs     fpregs;
3650 } target_sigregs;
3651 
3652 struct target_sigcontext {
3653     target_ulong   oldmask[_SIGCONTEXT_NSIG_WORDS];
3654     target_sigregs *sregs;
3655 };
3656 
3657 typedef struct {
3658     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
3659     struct target_sigcontext sc;
3660     target_sigregs sregs;
3661     int signo;
3662     uint8_t retcode[S390_SYSCALL_SIZE];
3663 } sigframe;
3664 
3665 struct target_ucontext {
3666     target_ulong tuc_flags;
3667     struct target_ucontext *tuc_link;
3668     target_stack_t tuc_stack;
3669     target_sigregs tuc_mcontext;
3670     target_sigset_t tuc_sigmask;   /* mask last for extensibility */
3671 };
3672 
3673 typedef struct {
3674     uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
3675     uint8_t retcode[S390_SYSCALL_SIZE];
3676     struct target_siginfo info;
3677     struct target_ucontext uc;
3678 } rt_sigframe;
3679 
3680 static inline abi_ulong
3681 get_sigframe(struct target_sigaction *ka, CPUState *env, size_t frame_size)
3682 {
3683     abi_ulong sp;
3684 
3685     /* Default to using normal stack */
3686     sp = env->regs[15];
3687 
3688     /* This is the X/Open sanctioned signal stack switching.  */
3689     if (ka->sa_flags & TARGET_SA_ONSTACK) {
3690         if (!sas_ss_flags(sp)) {
3691             sp = target_sigaltstack_used.ss_sp +
3692                  target_sigaltstack_used.ss_size;
3693         }
3694     }
3695 
3696     /* This is the legacy signal stack switching. */
3697     else if (/* FIXME !user_mode(regs) */ 0 &&
3698              !(ka->sa_flags & TARGET_SA_RESTORER) &&
3699              ka->sa_restorer) {
3700         sp = (abi_ulong) ka->sa_restorer;
3701     }
3702 
3703     return (sp - frame_size) & -8ul;
3704 }
3705 
3706 static void save_sigregs(CPUState *env, target_sigregs *sregs)
3707 {
3708     int i;
3709     //save_access_regs(current->thread.acrs); FIXME
3710 
3711     /* Copy a 'clean' PSW mask to the user to avoid leaking
3712        information about whether PER is currently on.  */
3713     __put_user(env->psw.mask, &sregs->regs.psw.mask);
3714     __put_user(env->psw.addr, &sregs->regs.psw.addr);
3715     for (i = 0; i < 16; i++) {
3716         __put_user(env->regs[i], &sregs->regs.gprs[i]);
3717     }
3718     for (i = 0; i < 16; i++) {
3719         __put_user(env->aregs[i], &sregs->regs.acrs[i]);
3720     }
3721     /*
3722      * We have to store the fp registers to current->thread.fp_regs
3723      * to merge them with the emulated registers.
3724      */
3725     //save_fp_regs(&current->thread.fp_regs); FIXME
3726     for (i = 0; i < 16; i++) {
3727         __put_user(env->fregs[i].ll, &sregs->fpregs.fprs[i]);
3728     }
3729 }
3730 
3731 static void setup_frame(int sig, struct target_sigaction *ka,
3732 			target_sigset_t *set, CPUState *env)
3733 {
3734     sigframe *frame;
3735     abi_ulong frame_addr;
3736 
3737     frame_addr = get_sigframe(ka, env, sizeof(*frame));
3738     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3739              (unsigned long long)frame_addr);
3740     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3741             goto give_sigsegv;
3742     }
3743 
3744     qemu_log("%s: 1\n", __FUNCTION__);
3745     if (__put_user(set->sig[0], &frame->sc.oldmask[0])) {
3746               goto give_sigsegv;
3747     }
3748 
3749     save_sigregs(env, &frame->sregs);
3750 
3751     __put_user((abi_ulong)(unsigned long)&frame->sregs,
3752                (abi_ulong *)&frame->sc.sregs);
3753 
3754     /* Set up to return from userspace.  If provided, use a stub
3755        already in userspace.  */
3756     if (ka->sa_flags & TARGET_SA_RESTORER) {
3757             env->regs[14] = (unsigned long)
3758                     ka->sa_restorer | PSW_ADDR_AMODE;
3759     } else {
3760             env->regs[14] = (unsigned long)
3761                     frame->retcode | PSW_ADDR_AMODE;
3762             if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
3763                            (uint16_t *)(frame->retcode)))
3764                     goto give_sigsegv;
3765     }
3766 
3767     /* Set up backchain. */
3768     if (__put_user(env->regs[15], (abi_ulong *) frame)) {
3769             goto give_sigsegv;
3770     }
3771 
3772     /* Set up registers for signal handler */
3773     env->regs[15] = frame_addr;
3774     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
3775 
3776     env->regs[2] = sig; //map_signal(sig);
3777     env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
3778 
3779     /* We forgot to include these in the sigcontext.
3780        To avoid breaking binary compatibility, they are passed as args. */
3781     env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
3782     env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
3783 
3784     /* Place signal number on stack to allow backtrace from handler.  */
3785     if (__put_user(env->regs[2], (int *) &frame->signo)) {
3786             goto give_sigsegv;
3787     }
3788     unlock_user_struct(frame, frame_addr, 1);
3789     return;
3790 
3791 give_sigsegv:
3792     qemu_log("%s: give_sigsegv\n", __FUNCTION__);
3793     unlock_user_struct(frame, frame_addr, 1);
3794     force_sig(TARGET_SIGSEGV);
3795 }
3796 
3797 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3798                            target_siginfo_t *info,
3799                            target_sigset_t *set, CPUState *env)
3800 {
3801     int i;
3802     rt_sigframe *frame;
3803     abi_ulong frame_addr;
3804 
3805     frame_addr = get_sigframe(ka, env, sizeof *frame);
3806     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3807              (unsigned long long)frame_addr);
3808     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3809         goto give_sigsegv;
3810     }
3811 
3812     qemu_log("%s: 1\n", __FUNCTION__);
3813     if (copy_siginfo_to_user(&frame->info, info)) {
3814         goto give_sigsegv;
3815     }
3816 
3817     /* Create the ucontext.  */
3818     __put_user(0, &frame->uc.tuc_flags);
3819     __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
3820     __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
3821     __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
3822                       &frame->uc.tuc_stack.ss_flags);
3823     __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
3824     save_sigregs(env, &frame->uc.tuc_mcontext);
3825     for (i = 0; i < TARGET_NSIG_WORDS; i++) {
3826         __put_user((abi_ulong)set->sig[i],
3827         (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
3828     }
3829 
3830     /* Set up to return from userspace.  If provided, use a stub
3831        already in userspace.  */
3832     if (ka->sa_flags & TARGET_SA_RESTORER) {
3833         env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
3834     } else {
3835         env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
3836         if (__put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
3837                        (uint16_t *)(frame->retcode))) {
3838             goto give_sigsegv;
3839         }
3840     }
3841 
3842     /* Set up backchain. */
3843     if (__put_user(env->regs[15], (abi_ulong *) frame)) {
3844         goto give_sigsegv;
3845     }
3846 
3847     /* Set up registers for signal handler */
3848     env->regs[15] = frame_addr;
3849     env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
3850 
3851     env->regs[2] = sig; //map_signal(sig);
3852     env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
3853     env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
3854     return;
3855 
3856 give_sigsegv:
3857     qemu_log("%s: give_sigsegv\n", __FUNCTION__);
3858     unlock_user_struct(frame, frame_addr, 1);
3859     force_sig(TARGET_SIGSEGV);
3860 }
3861 
3862 static int
3863 restore_sigregs(CPUState *env, target_sigregs *sc)
3864 {
3865     int err = 0;
3866     int i;
3867 
3868     for (i = 0; i < 16; i++) {
3869         err |= __get_user(env->regs[i], &sc->regs.gprs[i]);
3870     }
3871 
3872     err |= __get_user(env->psw.mask, &sc->regs.psw.mask);
3873     qemu_log("%s: sc->regs.psw.addr 0x%llx env->psw.addr 0x%llx\n",
3874              __FUNCTION__, (unsigned long long)sc->regs.psw.addr,
3875              (unsigned long long)env->psw.addr);
3876     err |= __get_user(env->psw.addr, &sc->regs.psw.addr);
3877     /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
3878 
3879     for (i = 0; i < 16; i++) {
3880         err |= __get_user(env->aregs[i], &sc->regs.acrs[i]);
3881     }
3882     for (i = 0; i < 16; i++) {
3883         err |= __get_user(env->fregs[i].ll, &sc->fpregs.fprs[i]);
3884     }
3885 
3886     return err;
3887 }
3888 
3889 long do_sigreturn(CPUState *env)
3890 {
3891     sigframe *frame;
3892     abi_ulong frame_addr = env->regs[15];
3893     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3894              (unsigned long long)frame_addr);
3895     target_sigset_t target_set;
3896     sigset_t set;
3897 
3898     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3899         goto badframe;
3900     }
3901     if (__get_user(target_set.sig[0], &frame->sc.oldmask[0])) {
3902         goto badframe;
3903     }
3904 
3905     target_to_host_sigset_internal(&set, &target_set);
3906     sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
3907 
3908     if (restore_sigregs(env, &frame->sregs)) {
3909         goto badframe;
3910     }
3911 
3912     unlock_user_struct(frame, frame_addr, 0);
3913     return env->regs[2];
3914 
3915 badframe:
3916     unlock_user_struct(frame, frame_addr, 0);
3917     force_sig(TARGET_SIGSEGV);
3918     return 0;
3919 }
3920 
3921 long do_rt_sigreturn(CPUState *env)
3922 {
3923     rt_sigframe *frame;
3924     abi_ulong frame_addr = env->regs[15];
3925     qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
3926              (unsigned long long)frame_addr);
3927     sigset_t set;
3928 
3929     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3930         goto badframe;
3931     }
3932     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
3933 
3934     sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
3935 
3936     if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
3937         goto badframe;
3938     }
3939 
3940     if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
3941                        get_sp_from_cpustate(env)) == -EFAULT) {
3942         goto badframe;
3943     }
3944     unlock_user_struct(frame, frame_addr, 0);
3945     return env->regs[2];
3946 
3947 badframe:
3948     unlock_user_struct(frame, frame_addr, 0);
3949     force_sig(TARGET_SIGSEGV);
3950     return 0;
3951 }
3952 
3953 #elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3954 
3955 /* FIXME: Many of the structures are defined for both PPC and PPC64, but
3956    the signal handling is different enough that we haven't implemented
3957    support for PPC64 yet.  Hence the restriction above.
3958 
3959    There are various #if'd blocks for code for TARGET_PPC64.  These
3960    blocks should go away so that we can successfully run 32-bit and
3961    64-bit binaries on a QEMU configured for PPC64.  */
3962 
3963 /* Size of dummy stack frame allocated when calling signal handler.
3964    See arch/powerpc/include/asm/ptrace.h.  */
3965 #if defined(TARGET_PPC64)
3966 #define SIGNAL_FRAMESIZE 128
3967 #else
3968 #define SIGNAL_FRAMESIZE 64
3969 #endif
3970 
3971 /* See arch/powerpc/include/asm/sigcontext.h.  */
3972 struct target_sigcontext {
3973     target_ulong _unused[4];
3974     int32_t signal;
3975 #if defined(TARGET_PPC64)
3976     int32_t pad0;
3977 #endif
3978     target_ulong handler;
3979     target_ulong oldmask;
3980     target_ulong regs;      /* struct pt_regs __user * */
3981     /* TODO: PPC64 includes extra bits here.  */
3982 };
3983 
3984 /* Indices for target_mcontext.mc_gregs, below.
3985    See arch/powerpc/include/asm/ptrace.h for details.  */
3986 enum {
3987     TARGET_PT_R0 = 0,
3988     TARGET_PT_R1 = 1,
3989     TARGET_PT_R2 = 2,
3990     TARGET_PT_R3 = 3,
3991     TARGET_PT_R4 = 4,
3992     TARGET_PT_R5 = 5,
3993     TARGET_PT_R6 = 6,
3994     TARGET_PT_R7 = 7,
3995     TARGET_PT_R8 = 8,
3996     TARGET_PT_R9 = 9,
3997     TARGET_PT_R10 = 10,
3998     TARGET_PT_R11 = 11,
3999     TARGET_PT_R12 = 12,
4000     TARGET_PT_R13 = 13,
4001     TARGET_PT_R14 = 14,
4002     TARGET_PT_R15 = 15,
4003     TARGET_PT_R16 = 16,
4004     TARGET_PT_R17 = 17,
4005     TARGET_PT_R18 = 18,
4006     TARGET_PT_R19 = 19,
4007     TARGET_PT_R20 = 20,
4008     TARGET_PT_R21 = 21,
4009     TARGET_PT_R22 = 22,
4010     TARGET_PT_R23 = 23,
4011     TARGET_PT_R24 = 24,
4012     TARGET_PT_R25 = 25,
4013     TARGET_PT_R26 = 26,
4014     TARGET_PT_R27 = 27,
4015     TARGET_PT_R28 = 28,
4016     TARGET_PT_R29 = 29,
4017     TARGET_PT_R30 = 30,
4018     TARGET_PT_R31 = 31,
4019     TARGET_PT_NIP = 32,
4020     TARGET_PT_MSR = 33,
4021     TARGET_PT_ORIG_R3 = 34,
4022     TARGET_PT_CTR = 35,
4023     TARGET_PT_LNK = 36,
4024     TARGET_PT_XER = 37,
4025     TARGET_PT_CCR = 38,
4026     /* Yes, there are two registers with #39.  One is 64-bit only.  */
4027     TARGET_PT_MQ = 39,
4028     TARGET_PT_SOFTE = 39,
4029     TARGET_PT_TRAP = 40,
4030     TARGET_PT_DAR = 41,
4031     TARGET_PT_DSISR = 42,
4032     TARGET_PT_RESULT = 43,
4033     TARGET_PT_REGS_COUNT = 44
4034 };
4035 
4036 /* See arch/powerpc/include/asm/ucontext.h.  Only used for 32-bit PPC;
4037    on 64-bit PPC, sigcontext and mcontext are one and the same.  */
4038 struct target_mcontext {
4039     target_ulong mc_gregs[48];
4040     /* Includes fpscr.  */
4041     uint64_t mc_fregs[33];
4042     target_ulong mc_pad[2];
4043     /* We need to handle Altivec and SPE at the same time, which no
4044        kernel needs to do.  Fortunately, the kernel defines this bit to
4045        be Altivec-register-large all the time, rather than trying to
4046        twiddle it based on the specific platform.  */
4047     union {
4048         /* SPE vector registers.  One extra for SPEFSCR.  */
4049         uint32_t spe[33];
4050         /* Altivec vector registers.  The packing of VSCR and VRSAVE
4051            varies depending on whether we're PPC64 or not: PPC64 splits
4052            them apart; PPC32 stuffs them together.  */
4053 #if defined(TARGET_PPC64)
4054 #define QEMU_NVRREG 34
4055 #else
4056 #define QEMU_NVRREG 33
4057 #endif
4058         ppc_avr_t altivec[QEMU_NVRREG];
4059 #undef QEMU_NVRREG
4060     } mc_vregs __attribute__((__aligned__(16)));
4061 };
4062 
4063 struct target_ucontext {
4064     target_ulong tuc_flags;
4065     target_ulong tuc_link;    /* struct ucontext __user * */
4066     struct target_sigaltstack tuc_stack;
4067 #if !defined(TARGET_PPC64)
4068     int32_t tuc_pad[7];
4069     target_ulong tuc_regs;    /* struct mcontext __user *
4070                                 points to uc_mcontext field */
4071 #endif
4072     target_sigset_t tuc_sigmask;
4073 #if defined(TARGET_PPC64)
4074     target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
4075     struct target_sigcontext tuc_mcontext;
4076 #else
4077     int32_t tuc_maskext[30];
4078     int32_t tuc_pad2[3];
4079     struct target_mcontext tuc_mcontext;
4080 #endif
4081 };
4082 
4083 /* See arch/powerpc/kernel/signal_32.c.  */
4084 struct target_sigframe {
4085     struct target_sigcontext sctx;
4086     struct target_mcontext mctx;
4087     int32_t abigap[56];
4088 };
4089 
4090 struct target_rt_sigframe {
4091     struct target_siginfo info;
4092     struct target_ucontext uc;
4093     int32_t abigap[56];
4094 };
4095 
4096 /* We use the mc_pad field for the signal return trampoline.  */
4097 #define tramp mc_pad
4098 
4099 /* See arch/powerpc/kernel/signal.c.  */
4100 static target_ulong get_sigframe(struct target_sigaction *ka,
4101                                  CPUState *env,
4102                                  int frame_size)
4103 {
4104     target_ulong oldsp, newsp;
4105 
4106     oldsp = env->gpr[1];
4107 
4108     if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
4109         (sas_ss_flags(oldsp))) {
4110         oldsp = (target_sigaltstack_used.ss_sp
4111                  + target_sigaltstack_used.ss_size);
4112     }
4113 
4114     newsp = (oldsp - frame_size) & ~0xFUL;
4115 
4116     return newsp;
4117 }
4118 
4119 static int save_user_regs(CPUState *env, struct target_mcontext *frame,
4120                           int sigret)
4121 {
4122     target_ulong msr = env->msr;
4123     int i;
4124     target_ulong ccr = 0;
4125 
4126     /* In general, the kernel attempts to be intelligent about what it
4127        needs to save for Altivec/FP/SPE registers.  We don't care that
4128        much, so we just go ahead and save everything.  */
4129 
4130     /* Save general registers.  */
4131     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4132         if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
4133             return 1;
4134         }
4135     }
4136     if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4137         || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4138         || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4139         || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4140         return 1;
4141 
4142     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4143         ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4144     }
4145     if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4146         return 1;
4147 
4148     /* Save Altivec registers if necessary.  */
4149     if (env->insns_flags & PPC_ALTIVEC) {
4150         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4151             ppc_avr_t *avr = &env->avr[i];
4152             ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4153 
4154             if (__put_user(avr->u64[0], &vreg->u64[0]) ||
4155                 __put_user(avr->u64[1], &vreg->u64[1])) {
4156                 return 1;
4157             }
4158         }
4159         /* Set MSR_VR in the saved MSR value to indicate that
4160            frame->mc_vregs contains valid data.  */
4161         msr |= MSR_VR;
4162         if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
4163                        &frame->mc_vregs.altivec[32].u32[3]))
4164             return 1;
4165     }
4166 
4167     /* Save floating point registers.  */
4168     if (env->insns_flags & PPC_FLOAT) {
4169         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4170             if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
4171                 return 1;
4172             }
4173         }
4174         if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
4175             return 1;
4176     }
4177 
4178     /* Save SPE registers.  The kernel only saves the high half.  */
4179     if (env->insns_flags & PPC_SPE) {
4180 #if defined(TARGET_PPC64)
4181         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4182             if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
4183                 return 1;
4184             }
4185         }
4186 #else
4187         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4188             if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4189                 return 1;
4190             }
4191         }
4192 #endif
4193         /* Set MSR_SPE in the saved MSR value to indicate that
4194            frame->mc_vregs contains valid data.  */
4195         msr |= MSR_SPE;
4196         if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4197             return 1;
4198     }
4199 
4200     /* Store MSR.  */
4201     if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4202         return 1;
4203 
4204     /* Set up the sigreturn trampoline: li r0,sigret; sc.  */
4205     if (sigret) {
4206         if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
4207             __put_user(0x44000002UL, &frame->tramp[1])) {
4208             return 1;
4209         }
4210     }
4211 
4212     return 0;
4213 }
4214 
4215 static int restore_user_regs(CPUState *env,
4216                              struct target_mcontext *frame, int sig)
4217 {
4218     target_ulong save_r2 = 0;
4219     target_ulong msr;
4220     target_ulong ccr;
4221 
4222     int i;
4223 
4224     if (!sig) {
4225         save_r2 = env->gpr[2];
4226     }
4227 
4228     /* Restore general registers.  */
4229     for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4230         if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
4231             return 1;
4232         }
4233     }
4234     if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
4235         || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
4236         || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
4237         || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
4238         return 1;
4239     if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
4240         return 1;
4241 
4242     for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4243         env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4244     }
4245 
4246     if (!sig) {
4247         env->gpr[2] = save_r2;
4248     }
4249     /* Restore MSR.  */
4250     if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
4251         return 1;
4252 
4253     /* If doing signal return, restore the previous little-endian mode.  */
4254     if (sig)
4255         env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4256 
4257     /* Restore Altivec registers if necessary.  */
4258     if (env->insns_flags & PPC_ALTIVEC) {
4259         for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4260             ppc_avr_t *avr = &env->avr[i];
4261             ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4262 
4263             if (__get_user(avr->u64[0], &vreg->u64[0]) ||
4264                 __get_user(avr->u64[1], &vreg->u64[1])) {
4265                 return 1;
4266             }
4267         }
4268         /* Set MSR_VEC in the saved MSR value to indicate that
4269            frame->mc_vregs contains valid data.  */
4270         if (__get_user(env->spr[SPR_VRSAVE],
4271                        (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
4272             return 1;
4273     }
4274 
4275     /* Restore floating point registers.  */
4276     if (env->insns_flags & PPC_FLOAT) {
4277         uint64_t fpscr;
4278         for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4279             if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
4280                 return 1;
4281             }
4282         }
4283         if (__get_user(fpscr, &frame->mc_fregs[32]))
4284             return 1;
4285         env->fpscr = (uint32_t) fpscr;
4286     }
4287 
4288     /* Save SPE registers.  The kernel only saves the high half.  */
4289     if (env->insns_flags & PPC_SPE) {
4290 #if defined(TARGET_PPC64)
4291         for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4292             uint32_t hi;
4293 
4294             if (__get_user(hi, &frame->mc_vregs.spe[i])) {
4295                 return 1;
4296             }
4297             env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4298         }
4299 #else
4300         for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4301             if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
4302                 return 1;
4303             }
4304         }
4305 #endif
4306         if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
4307             return 1;
4308     }
4309 
4310     return 0;
4311 }
4312 
4313 static void setup_frame(int sig, struct target_sigaction *ka,
4314                         target_sigset_t *set, CPUState *env)
4315 {
4316     struct target_sigframe *frame;
4317     struct target_sigcontext *sc;
4318     target_ulong frame_addr, newsp;
4319     int err = 0;
4320     int signal;
4321 
4322     frame_addr = get_sigframe(ka, env, sizeof(*frame));
4323     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4324         goto sigsegv;
4325     sc = &frame->sctx;
4326 
4327     signal = current_exec_domain_sig(sig);
4328 
4329     err |= __put_user(h2g(ka->_sa_handler), &sc->handler);
4330     err |= __put_user(set->sig[0], &sc->oldmask);
4331 #if defined(TARGET_PPC64)
4332     err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]);
4333 #else
4334     err |= __put_user(set->sig[1], &sc->_unused[3]);
4335 #endif
4336     err |= __put_user(h2g(&frame->mctx), &sc->regs);
4337     err |= __put_user(sig, &sc->signal);
4338 
4339     /* Save user regs.  */
4340     err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
4341 
4342     /* The kernel checks for the presence of a VDSO here.  We don't
4343        emulate a vdso, so use a sigreturn system call.  */
4344     env->lr = (target_ulong) h2g(frame->mctx.tramp);
4345 
4346     /* Turn off all fp exceptions.  */
4347     env->fpscr = 0;
4348 
4349     /* Create a stack frame for the caller of the handler.  */
4350     newsp = frame_addr - SIGNAL_FRAMESIZE;
4351     err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
4352 
4353     if (err)
4354         goto sigsegv;
4355 
4356     /* Set up registers for signal handler.  */
4357     env->gpr[1] = newsp;
4358     env->gpr[3] = signal;
4359     env->gpr[4] = (target_ulong) h2g(sc);
4360     env->nip = (target_ulong) ka->_sa_handler;
4361     /* Signal handlers are entered in big-endian mode.  */
4362     env->msr &= ~MSR_LE;
4363 
4364     unlock_user_struct(frame, frame_addr, 1);
4365     return;
4366 
4367 sigsegv:
4368     unlock_user_struct(frame, frame_addr, 1);
4369     if (logfile)
4370         fprintf (logfile, "segfaulting from setup_frame\n");
4371     force_sig(TARGET_SIGSEGV);
4372 }
4373 
4374 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4375                            target_siginfo_t *info,
4376                            target_sigset_t *set, CPUState *env)
4377 {
4378     struct target_rt_sigframe *rt_sf;
4379     struct target_mcontext *frame;
4380     target_ulong rt_sf_addr, newsp = 0;
4381     int i, err = 0;
4382     int signal;
4383 
4384     rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4385     if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4386         goto sigsegv;
4387 
4388     signal = current_exec_domain_sig(sig);
4389 
4390     err |= copy_siginfo_to_user(&rt_sf->info, info);
4391 
4392     err |= __put_user(0, &rt_sf->uc.tuc_flags);
4393     err |= __put_user(0, &rt_sf->uc.tuc_link);
4394     err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp,
4395                       &rt_sf->uc.tuc_stack.ss_sp);
4396     err |= __put_user(sas_ss_flags(env->gpr[1]),
4397                       &rt_sf->uc.tuc_stack.ss_flags);
4398     err |= __put_user(target_sigaltstack_used.ss_size,
4399                       &rt_sf->uc.tuc_stack.ss_size);
4400     err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4401                       &rt_sf->uc.tuc_regs);
4402     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4403         err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
4404     }
4405 
4406     frame = &rt_sf->uc.tuc_mcontext;
4407     err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
4408 
4409     /* The kernel checks for the presence of a VDSO here.  We don't
4410        emulate a vdso, so use a sigreturn system call.  */
4411     env->lr = (target_ulong) h2g(frame->tramp);
4412 
4413     /* Turn off all fp exceptions.  */
4414     env->fpscr = 0;
4415 
4416     /* Create a stack frame for the caller of the handler.  */
4417     newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
4418     err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
4419 
4420     if (err)
4421         goto sigsegv;
4422 
4423     /* Set up registers for signal handler.  */
4424     env->gpr[1] = newsp;
4425     env->gpr[3] = (target_ulong) signal;
4426     env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4427     env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4428     env->gpr[6] = (target_ulong) h2g(rt_sf);
4429     env->nip = (target_ulong) ka->_sa_handler;
4430     /* Signal handlers are entered in big-endian mode.  */
4431     env->msr &= ~MSR_LE;
4432 
4433     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4434     return;
4435 
4436 sigsegv:
4437     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4438     if (logfile)
4439         fprintf (logfile, "segfaulting from setup_rt_frame\n");
4440     force_sig(TARGET_SIGSEGV);
4441 
4442 }
4443 
4444 long do_sigreturn(CPUState *env)
4445 {
4446     struct target_sigcontext *sc = NULL;
4447     struct target_mcontext *sr = NULL;
4448     target_ulong sr_addr, sc_addr;
4449     sigset_t blocked;
4450     target_sigset_t set;
4451 
4452     sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4453     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4454         goto sigsegv;
4455 
4456 #if defined(TARGET_PPC64)
4457     set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
4458 #else
4459     if(__get_user(set.sig[0], &sc->oldmask) ||
4460        __get_user(set.sig[1], &sc->_unused[3]))
4461        goto sigsegv;
4462 #endif
4463     target_to_host_sigset_internal(&blocked, &set);
4464     sigprocmask(SIG_SETMASK, &blocked, NULL);
4465 
4466     if (__get_user(sr_addr, &sc->regs))
4467         goto sigsegv;
4468     if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4469         goto sigsegv;
4470     if (restore_user_regs(env, sr, 1))
4471         goto sigsegv;
4472 
4473     unlock_user_struct(sr, sr_addr, 1);
4474     unlock_user_struct(sc, sc_addr, 1);
4475     return -TARGET_QEMU_ESIGRETURN;
4476 
4477 sigsegv:
4478     unlock_user_struct(sr, sr_addr, 1);
4479     unlock_user_struct(sc, sc_addr, 1);
4480     if (logfile)
4481         fprintf (logfile, "segfaulting from do_sigreturn\n");
4482     force_sig(TARGET_SIGSEGV);
4483     return 0;
4484 }
4485 
4486 /* See arch/powerpc/kernel/signal_32.c.  */
4487 static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig)
4488 {
4489     struct target_mcontext *mcp;
4490     target_ulong mcp_addr;
4491     sigset_t blocked;
4492     target_sigset_t set;
4493 
4494     if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
4495                        sizeof (set)))
4496         return 1;
4497 
4498 #if defined(TARGET_PPC64)
4499     fprintf (stderr, "do_setcontext: not implemented\n");
4500     return 0;
4501 #else
4502     if (__get_user(mcp_addr, &ucp->tuc_regs))
4503         return 1;
4504 
4505     if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4506         return 1;
4507 
4508     target_to_host_sigset_internal(&blocked, &set);
4509     sigprocmask(SIG_SETMASK, &blocked, NULL);
4510     if (restore_user_regs(env, mcp, sig))
4511         goto sigsegv;
4512 
4513     unlock_user_struct(mcp, mcp_addr, 1);
4514     return 0;
4515 
4516 sigsegv:
4517     unlock_user_struct(mcp, mcp_addr, 1);
4518     return 1;
4519 #endif
4520 }
4521 
4522 long do_rt_sigreturn(CPUState *env)
4523 {
4524     struct target_rt_sigframe *rt_sf = NULL;
4525     target_ulong rt_sf_addr;
4526 
4527     rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4528     if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4529         goto sigsegv;
4530 
4531     if (do_setcontext(&rt_sf->uc, env, 1))
4532         goto sigsegv;
4533 
4534     do_sigaltstack(rt_sf_addr
4535                    + offsetof(struct target_rt_sigframe, uc.tuc_stack),
4536                    0, env->gpr[1]);
4537 
4538     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4539     return -TARGET_QEMU_ESIGRETURN;
4540 
4541 sigsegv:
4542     unlock_user_struct(rt_sf, rt_sf_addr, 1);
4543     if (logfile)
4544         fprintf (logfile, "segfaulting from do_rt_sigreturn\n");
4545     force_sig(TARGET_SIGSEGV);
4546     return 0;
4547 }
4548 
4549 #elif defined(TARGET_M68K)
4550 
4551 struct target_sigcontext {
4552     abi_ulong  sc_mask;
4553     abi_ulong  sc_usp;
4554     abi_ulong  sc_d0;
4555     abi_ulong  sc_d1;
4556     abi_ulong  sc_a0;
4557     abi_ulong  sc_a1;
4558     unsigned short sc_sr;
4559     abi_ulong  sc_pc;
4560 };
4561 
4562 struct target_sigframe
4563 {
4564     abi_ulong pretcode;
4565     int sig;
4566     int code;
4567     abi_ulong psc;
4568     char retcode[8];
4569     abi_ulong extramask[TARGET_NSIG_WORDS-1];
4570     struct target_sigcontext sc;
4571 };
4572 
4573 typedef int target_greg_t;
4574 #define TARGET_NGREG 18
4575 typedef target_greg_t target_gregset_t[TARGET_NGREG];
4576 
4577 typedef struct target_fpregset {
4578     int f_fpcntl[3];
4579     int f_fpregs[8*3];
4580 } target_fpregset_t;
4581 
4582 struct target_mcontext {
4583     int version;
4584     target_gregset_t gregs;
4585     target_fpregset_t fpregs;
4586 };
4587 
4588 #define TARGET_MCONTEXT_VERSION 2
4589 
4590 struct target_ucontext {
4591     abi_ulong tuc_flags;
4592     abi_ulong tuc_link;
4593     target_stack_t tuc_stack;
4594     struct target_mcontext tuc_mcontext;
4595     abi_long tuc_filler[80];
4596     target_sigset_t tuc_sigmask;
4597 };
4598 
4599 struct target_rt_sigframe
4600 {
4601     abi_ulong pretcode;
4602     int sig;
4603     abi_ulong pinfo;
4604     abi_ulong puc;
4605     char retcode[8];
4606     struct target_siginfo info;
4607     struct target_ucontext uc;
4608 };
4609 
4610 static int
4611 setup_sigcontext(struct target_sigcontext *sc, CPUState *env, abi_ulong mask)
4612 {
4613     int err = 0;
4614 
4615     err |= __put_user(mask, &sc->sc_mask);
4616     err |= __put_user(env->aregs[7], &sc->sc_usp);
4617     err |= __put_user(env->dregs[0], &sc->sc_d0);
4618     err |= __put_user(env->dregs[1], &sc->sc_d1);
4619     err |= __put_user(env->aregs[0], &sc->sc_a0);
4620     err |= __put_user(env->aregs[1], &sc->sc_a1);
4621     err |= __put_user(env->sr, &sc->sc_sr);
4622     err |= __put_user(env->pc, &sc->sc_pc);
4623 
4624     return err;
4625 }
4626 
4627 static int
4628 restore_sigcontext(CPUState *env, struct target_sigcontext *sc, int *pd0)
4629 {
4630     int err = 0;
4631     int temp;
4632 
4633     err |= __get_user(env->aregs[7], &sc->sc_usp);
4634     err |= __get_user(env->dregs[1], &sc->sc_d1);
4635     err |= __get_user(env->aregs[0], &sc->sc_a0);
4636     err |= __get_user(env->aregs[1], &sc->sc_a1);
4637     err |= __get_user(env->pc, &sc->sc_pc);
4638     err |= __get_user(temp, &sc->sc_sr);
4639     env->sr = (env->sr & 0xff00) | (temp & 0xff);
4640 
4641     *pd0 = tswapl(sc->sc_d0);
4642 
4643     return err;
4644 }
4645 
4646 /*
4647  * Determine which stack to use..
4648  */
4649 static inline abi_ulong
4650 get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
4651 {
4652     unsigned long sp;
4653 
4654     sp = regs->aregs[7];
4655 
4656     /* This is the X/Open sanctioned signal stack switching.  */
4657     if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
4658         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4659     }
4660 
4661     return ((sp - frame_size) & -8UL);
4662 }
4663 
4664 static void setup_frame(int sig, struct target_sigaction *ka,
4665 			target_sigset_t *set, CPUState *env)
4666 {
4667     struct target_sigframe *frame;
4668     abi_ulong frame_addr;
4669     abi_ulong retcode_addr;
4670     abi_ulong sc_addr;
4671     int err = 0;
4672     int i;
4673 
4674     frame_addr = get_sigframe(ka, env, sizeof *frame);
4675     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4676 	goto give_sigsegv;
4677 
4678     err |= __put_user(sig, &frame->sig);
4679 
4680     sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
4681     err |= __put_user(sc_addr, &frame->psc);
4682 
4683     err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
4684     if (err)
4685 	goto give_sigsegv;
4686 
4687     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4688         if (__put_user(set->sig[i], &frame->extramask[i - 1]))
4689             goto give_sigsegv;
4690     }
4691 
4692     /* Set up to return from userspace.  */
4693 
4694     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4695     err |= __put_user(retcode_addr, &frame->pretcode);
4696 
4697     /* moveq #,d0; trap #0 */
4698 
4699     err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
4700                       (long *)(frame->retcode));
4701 
4702     if (err)
4703         goto give_sigsegv;
4704 
4705     /* Set up to return from userspace */
4706 
4707     env->aregs[7] = frame_addr;
4708     env->pc = ka->_sa_handler;
4709 
4710     unlock_user_struct(frame, frame_addr, 1);
4711     return;
4712 
4713 give_sigsegv:
4714     unlock_user_struct(frame, frame_addr, 1);
4715     force_sig(TARGET_SIGSEGV);
4716 }
4717 
4718 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
4719                                            CPUState *env)
4720 {
4721     target_greg_t *gregs = uc->tuc_mcontext.gregs;
4722     int err;
4723 
4724     err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4725     err |= __put_user(env->dregs[0], &gregs[0]);
4726     err |= __put_user(env->dregs[1], &gregs[1]);
4727     err |= __put_user(env->dregs[2], &gregs[2]);
4728     err |= __put_user(env->dregs[3], &gregs[3]);
4729     err |= __put_user(env->dregs[4], &gregs[4]);
4730     err |= __put_user(env->dregs[5], &gregs[5]);
4731     err |= __put_user(env->dregs[6], &gregs[6]);
4732     err |= __put_user(env->dregs[7], &gregs[7]);
4733     err |= __put_user(env->aregs[0], &gregs[8]);
4734     err |= __put_user(env->aregs[1], &gregs[9]);
4735     err |= __put_user(env->aregs[2], &gregs[10]);
4736     err |= __put_user(env->aregs[3], &gregs[11]);
4737     err |= __put_user(env->aregs[4], &gregs[12]);
4738     err |= __put_user(env->aregs[5], &gregs[13]);
4739     err |= __put_user(env->aregs[6], &gregs[14]);
4740     err |= __put_user(env->aregs[7], &gregs[15]);
4741     err |= __put_user(env->pc, &gregs[16]);
4742     err |= __put_user(env->sr, &gregs[17]);
4743 
4744     return err;
4745 }
4746 
4747 static inline int target_rt_restore_ucontext(CPUState *env,
4748                                              struct target_ucontext *uc,
4749                                              int *pd0)
4750 {
4751     int temp;
4752     int err;
4753     target_greg_t *gregs = uc->tuc_mcontext.gregs;
4754 
4755     err = __get_user(temp, &uc->tuc_mcontext.version);
4756     if (temp != TARGET_MCONTEXT_VERSION)
4757         goto badframe;
4758 
4759     /* restore passed registers */
4760     err |= __get_user(env->dregs[0], &gregs[0]);
4761     err |= __get_user(env->dregs[1], &gregs[1]);
4762     err |= __get_user(env->dregs[2], &gregs[2]);
4763     err |= __get_user(env->dregs[3], &gregs[3]);
4764     err |= __get_user(env->dregs[4], &gregs[4]);
4765     err |= __get_user(env->dregs[5], &gregs[5]);
4766     err |= __get_user(env->dregs[6], &gregs[6]);
4767     err |= __get_user(env->dregs[7], &gregs[7]);
4768     err |= __get_user(env->aregs[0], &gregs[8]);
4769     err |= __get_user(env->aregs[1], &gregs[9]);
4770     err |= __get_user(env->aregs[2], &gregs[10]);
4771     err |= __get_user(env->aregs[3], &gregs[11]);
4772     err |= __get_user(env->aregs[4], &gregs[12]);
4773     err |= __get_user(env->aregs[5], &gregs[13]);
4774     err |= __get_user(env->aregs[6], &gregs[14]);
4775     err |= __get_user(env->aregs[7], &gregs[15]);
4776     err |= __get_user(env->pc, &gregs[16]);
4777     err |= __get_user(temp, &gregs[17]);
4778     env->sr = (env->sr & 0xff00) | (temp & 0xff);
4779 
4780     *pd0 = env->dregs[0];
4781     return err;
4782 
4783 badframe:
4784     return 1;
4785 }
4786 
4787 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4788                            target_siginfo_t *info,
4789 			   target_sigset_t *set, CPUState *env)
4790 {
4791     struct target_rt_sigframe *frame;
4792     abi_ulong frame_addr;
4793     abi_ulong retcode_addr;
4794     abi_ulong info_addr;
4795     abi_ulong uc_addr;
4796     int err = 0;
4797     int i;
4798 
4799     frame_addr = get_sigframe(ka, env, sizeof *frame);
4800     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4801 	goto give_sigsegv;
4802 
4803     err |= __put_user(sig, &frame->sig);
4804 
4805     info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
4806     err |= __put_user(info_addr, &frame->pinfo);
4807 
4808     uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
4809     err |= __put_user(uc_addr, &frame->puc);
4810 
4811     err |= copy_siginfo_to_user(&frame->info, info);
4812 
4813     /* Create the ucontext */
4814 
4815     err |= __put_user(0, &frame->uc.tuc_flags);
4816     err |= __put_user(0, &frame->uc.tuc_link);
4817     err |= __put_user(target_sigaltstack_used.ss_sp,
4818                       &frame->uc.tuc_stack.ss_sp);
4819     err |= __put_user(sas_ss_flags(env->aregs[7]),
4820                       &frame->uc.tuc_stack.ss_flags);
4821     err |= __put_user(target_sigaltstack_used.ss_size,
4822                       &frame->uc.tuc_stack.ss_size);
4823     err |= target_rt_setup_ucontext(&frame->uc, env);
4824 
4825     if (err)
4826             goto give_sigsegv;
4827 
4828     for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4829         if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
4830             goto give_sigsegv;
4831     }
4832 
4833     /* Set up to return from userspace.  */
4834 
4835     retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4836     err |= __put_user(retcode_addr, &frame->pretcode);
4837 
4838     /* moveq #,d0; notb d0; trap #0 */
4839 
4840     err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
4841                       (long *)(frame->retcode + 0));
4842     err |= __put_user(0x4e40, (short *)(frame->retcode + 4));
4843 
4844     if (err)
4845         goto give_sigsegv;
4846 
4847     /* Set up to return from userspace */
4848 
4849     env->aregs[7] = frame_addr;
4850     env->pc = ka->_sa_handler;
4851 
4852     unlock_user_struct(frame, frame_addr, 1);
4853     return;
4854 
4855 give_sigsegv:
4856     unlock_user_struct(frame, frame_addr, 1);
4857     force_sig(TARGET_SIGSEGV);
4858 }
4859 
4860 long do_sigreturn(CPUState *env)
4861 {
4862     struct target_sigframe *frame;
4863     abi_ulong frame_addr = env->aregs[7] - 4;
4864     target_sigset_t target_set;
4865     sigset_t set;
4866     int d0, i;
4867 
4868     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4869         goto badframe;
4870 
4871     /* set blocked signals */
4872 
4873     if (__get_user(target_set.sig[0], &frame->sc.sc_mask))
4874         goto badframe;
4875 
4876     for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4877         if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
4878             goto badframe;
4879     }
4880 
4881     target_to_host_sigset_internal(&set, &target_set);
4882     sigprocmask(SIG_SETMASK, &set, NULL);
4883 
4884     /* restore registers */
4885 
4886     if (restore_sigcontext(env, &frame->sc, &d0))
4887         goto badframe;
4888 
4889     unlock_user_struct(frame, frame_addr, 0);
4890     return d0;
4891 
4892 badframe:
4893     unlock_user_struct(frame, frame_addr, 0);
4894     force_sig(TARGET_SIGSEGV);
4895     return 0;
4896 }
4897 
4898 long do_rt_sigreturn(CPUState *env)
4899 {
4900     struct target_rt_sigframe *frame;
4901     abi_ulong frame_addr = env->aregs[7] - 4;
4902     target_sigset_t target_set;
4903     sigset_t set;
4904     int d0;
4905 
4906     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4907         goto badframe;
4908 
4909     target_to_host_sigset_internal(&set, &target_set);
4910     sigprocmask(SIG_SETMASK, &set, NULL);
4911 
4912     /* restore registers */
4913 
4914     if (target_rt_restore_ucontext(env, &frame->uc, &d0))
4915         goto badframe;
4916 
4917     if (do_sigaltstack(frame_addr +
4918                        offsetof(struct target_rt_sigframe, uc.tuc_stack),
4919                        0, get_sp_from_cpustate(env)) == -EFAULT)
4920         goto badframe;
4921 
4922     unlock_user_struct(frame, frame_addr, 0);
4923     return d0;
4924 
4925 badframe:
4926     unlock_user_struct(frame, frame_addr, 0);
4927     force_sig(TARGET_SIGSEGV);
4928     return 0;
4929 }
4930 
4931 #elif defined(TARGET_ALPHA)
4932 
4933 struct target_sigcontext {
4934     abi_long sc_onstack;
4935     abi_long sc_mask;
4936     abi_long sc_pc;
4937     abi_long sc_ps;
4938     abi_long sc_regs[32];
4939     abi_long sc_ownedfp;
4940     abi_long sc_fpregs[32];
4941     abi_ulong sc_fpcr;
4942     abi_ulong sc_fp_control;
4943     abi_ulong sc_reserved1;
4944     abi_ulong sc_reserved2;
4945     abi_ulong sc_ssize;
4946     abi_ulong sc_sbase;
4947     abi_ulong sc_traparg_a0;
4948     abi_ulong sc_traparg_a1;
4949     abi_ulong sc_traparg_a2;
4950     abi_ulong sc_fp_trap_pc;
4951     abi_ulong sc_fp_trigger_sum;
4952     abi_ulong sc_fp_trigger_inst;
4953 };
4954 
4955 struct target_ucontext {
4956     abi_ulong tuc_flags;
4957     abi_ulong tuc_link;
4958     abi_ulong tuc_osf_sigmask;
4959     target_stack_t tuc_stack;
4960     struct target_sigcontext tuc_mcontext;
4961     target_sigset_t tuc_sigmask;
4962 };
4963 
4964 struct target_sigframe {
4965     struct target_sigcontext sc;
4966     unsigned int retcode[3];
4967 };
4968 
4969 struct target_rt_sigframe {
4970     target_siginfo_t info;
4971     struct target_ucontext uc;
4972     unsigned int retcode[3];
4973 };
4974 
4975 #define INSN_MOV_R30_R16        0x47fe0410
4976 #define INSN_LDI_R0             0x201f0000
4977 #define INSN_CALLSYS            0x00000083
4978 
4979 static int setup_sigcontext(struct target_sigcontext *sc, CPUState *env,
4980                             abi_ulong frame_addr, target_sigset_t *set)
4981 {
4982     int i, err = 0;
4983 
4984     err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
4985     err |= __put_user(set->sig[0], &sc->sc_mask);
4986     err |= __put_user(env->pc, &sc->sc_pc);
4987     err |= __put_user(8, &sc->sc_ps);
4988 
4989     for (i = 0; i < 31; ++i) {
4990         err |= __put_user(env->ir[i], &sc->sc_regs[i]);
4991     }
4992     err |= __put_user(0, &sc->sc_regs[31]);
4993 
4994     for (i = 0; i < 31; ++i) {
4995         err |= __put_user(env->fir[i], &sc->sc_fpregs[i]);
4996     }
4997     err |= __put_user(0, &sc->sc_fpregs[31]);
4998     err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
4999 
5000     err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */
5001     err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */
5002     err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */
5003 
5004     return err;
5005 }
5006 
5007 static int restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
5008 {
5009     uint64_t fpcr;
5010     int i, err = 0;
5011 
5012     err |= __get_user(env->pc, &sc->sc_pc);
5013 
5014     for (i = 0; i < 31; ++i) {
5015         err |= __get_user(env->ir[i], &sc->sc_regs[i]);
5016     }
5017     for (i = 0; i < 31; ++i) {
5018         err |= __get_user(env->fir[i], &sc->sc_fpregs[i]);
5019     }
5020 
5021     err |= __get_user(fpcr, &sc->sc_fpcr);
5022     cpu_alpha_store_fpcr(env, fpcr);
5023 
5024     return err;
5025 }
5026 
5027 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
5028                                      CPUState *env, unsigned long framesize)
5029 {
5030     abi_ulong sp = env->ir[IR_SP];
5031 
5032     /* This is the X/Open sanctioned signal stack switching.  */
5033     if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5034         sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5035     }
5036     return (sp - framesize) & -32;
5037 }
5038 
5039 static void setup_frame(int sig, struct target_sigaction *ka,
5040                         target_sigset_t *set, CPUState *env)
5041 {
5042     abi_ulong frame_addr, r26;
5043     struct target_sigframe *frame;
5044     int err = 0;
5045 
5046     frame_addr = get_sigframe(ka, env, sizeof(*frame));
5047     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5048         goto give_sigsegv;
5049     }
5050 
5051     err |= setup_sigcontext(&frame->sc, env, frame_addr, set);
5052 
5053     if (ka->sa_restorer) {
5054         r26 = ka->sa_restorer;
5055     } else {
5056         err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5057         err |= __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5058                           &frame->retcode[1]);
5059         err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5060         /* imb() */
5061         r26 = frame_addr;
5062     }
5063 
5064     unlock_user_struct(frame, frame_addr, 1);
5065 
5066     if (err) {
5067     give_sigsegv:
5068         if (sig == TARGET_SIGSEGV) {
5069             ka->_sa_handler = TARGET_SIG_DFL;
5070         }
5071         force_sig(TARGET_SIGSEGV);
5072     }
5073 
5074     env->ir[IR_RA] = r26;
5075     env->ir[IR_PV] = env->pc = ka->_sa_handler;
5076     env->ir[IR_A0] = sig;
5077     env->ir[IR_A1] = 0;
5078     env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5079     env->ir[IR_SP] = frame_addr;
5080 }
5081 
5082 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5083                            target_siginfo_t *info,
5084 			   target_sigset_t *set, CPUState *env)
5085 {
5086     abi_ulong frame_addr, r26;
5087     struct target_rt_sigframe *frame;
5088     int i, err = 0;
5089 
5090     frame_addr = get_sigframe(ka, env, sizeof(*frame));
5091     if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5092         goto give_sigsegv;
5093     }
5094 
5095     err |= copy_siginfo_to_user(&frame->info, info);
5096 
5097     err |= __put_user(0, &frame->uc.tuc_flags);
5098     err |= __put_user(0, &frame->uc.tuc_link);
5099     err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
5100     err |= __put_user(target_sigaltstack_used.ss_sp,
5101                       &frame->uc.tuc_stack.ss_sp);
5102     err |= __put_user(sas_ss_flags(env->ir[IR_SP]),
5103                       &frame->uc.tuc_stack.ss_flags);
5104     err |= __put_user(target_sigaltstack_used.ss_size,
5105                       &frame->uc.tuc_stack.ss_size);
5106     err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
5107     for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
5108         err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5109     }
5110 
5111     if (ka->sa_restorer) {
5112         r26 = ka->sa_restorer;
5113     } else {
5114         err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5115         err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5116                           &frame->retcode[1]);
5117         err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
5118         /* imb(); */
5119         r26 = frame_addr;
5120     }
5121 
5122     if (err) {
5123     give_sigsegv:
5124        if (sig == TARGET_SIGSEGV) {
5125             ka->_sa_handler = TARGET_SIG_DFL;
5126         }
5127         force_sig(TARGET_SIGSEGV);
5128     }
5129 
5130     env->ir[IR_RA] = r26;
5131     env->ir[IR_PV] = env->pc = ka->_sa_handler;
5132     env->ir[IR_A0] = sig;
5133     env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5134     env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5135     env->ir[IR_SP] = frame_addr;
5136 }
5137 
5138 long do_sigreturn(CPUState *env)
5139 {
5140     struct target_sigcontext *sc;
5141     abi_ulong sc_addr = env->ir[IR_A0];
5142     target_sigset_t target_set;
5143     sigset_t set;
5144 
5145     if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5146         goto badframe;
5147     }
5148 
5149     target_sigemptyset(&target_set);
5150     if (__get_user(target_set.sig[0], &sc->sc_mask)) {
5151         goto badframe;
5152     }
5153 
5154     target_to_host_sigset_internal(&set, &target_set);
5155     sigprocmask(SIG_SETMASK, &set, NULL);
5156 
5157     if (restore_sigcontext(env, sc)) {
5158         goto badframe;
5159     }
5160     unlock_user_struct(sc, sc_addr, 0);
5161     return env->ir[IR_V0];
5162 
5163  badframe:
5164     unlock_user_struct(sc, sc_addr, 0);
5165     force_sig(TARGET_SIGSEGV);
5166 }
5167 
5168 long do_rt_sigreturn(CPUState *env)
5169 {
5170     abi_ulong frame_addr = env->ir[IR_A0];
5171     struct target_rt_sigframe *frame;
5172     sigset_t set;
5173 
5174     if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5175         goto badframe;
5176     }
5177     target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5178     sigprocmask(SIG_SETMASK, &set, NULL);
5179 
5180     if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
5181         goto badframe;
5182     }
5183     if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
5184                                              uc.tuc_stack),
5185                        0, env->ir[IR_SP]) == -EFAULT) {
5186         goto badframe;
5187     }
5188 
5189     unlock_user_struct(frame, frame_addr, 0);
5190     return env->ir[IR_V0];
5191 
5192 
5193  badframe:
5194     unlock_user_struct(frame, frame_addr, 0);
5195     force_sig(TARGET_SIGSEGV);
5196 }
5197 
5198 #else
5199 
5200 static void setup_frame(int sig, struct target_sigaction *ka,
5201 			target_sigset_t *set, CPUState *env)
5202 {
5203     fprintf(stderr, "setup_frame: not implemented\n");
5204 }
5205 
5206 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5207                            target_siginfo_t *info,
5208 			   target_sigset_t *set, CPUState *env)
5209 {
5210     fprintf(stderr, "setup_rt_frame: not implemented\n");
5211 }
5212 
5213 long do_sigreturn(CPUState *env)
5214 {
5215     fprintf(stderr, "do_sigreturn: not implemented\n");
5216     return -TARGET_ENOSYS;
5217 }
5218 
5219 long do_rt_sigreturn(CPUState *env)
5220 {
5221     fprintf(stderr, "do_rt_sigreturn: not implemented\n");
5222     return -TARGET_ENOSYS;
5223 }
5224 
5225 #endif
5226 
5227 void process_pending_signals(CPUState *cpu_env)
5228 {
5229     int sig;
5230     abi_ulong handler;
5231     sigset_t set, old_set;
5232     target_sigset_t target_old_set;
5233     struct emulated_sigtable *k;
5234     struct target_sigaction *sa;
5235     struct sigqueue *q;
5236     TaskState *ts = cpu_env->opaque;
5237 
5238     if (!ts->signal_pending)
5239         return;
5240 
5241     /* FIXME: This is not threadsafe.  */
5242     k = ts->sigtab;
5243     for(sig = 1; sig <= TARGET_NSIG; sig++) {
5244         if (k->pending)
5245             goto handle_signal;
5246         k++;
5247     }
5248     /* if no signal is pending, just return */
5249     ts->signal_pending = 0;
5250     return;
5251 
5252  handle_signal:
5253 #ifdef DEBUG_SIGNAL
5254     fprintf(stderr, "qemu: process signal %d\n", sig);
5255 #endif
5256     /* dequeue signal */
5257     q = k->first;
5258     k->first = q->next;
5259     if (!k->first)
5260         k->pending = 0;
5261 
5262     sig = gdb_handlesig (cpu_env, sig);
5263     if (!sig) {
5264         sa = NULL;
5265         handler = TARGET_SIG_IGN;
5266     } else {
5267         sa = &sigact_table[sig - 1];
5268         handler = sa->_sa_handler;
5269     }
5270 
5271     if (handler == TARGET_SIG_DFL) {
5272         /* default handler : ignore some signal. The other are job control or fatal */
5273         if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5274             kill(getpid(),SIGSTOP);
5275         } else if (sig != TARGET_SIGCHLD &&
5276                    sig != TARGET_SIGURG &&
5277                    sig != TARGET_SIGWINCH &&
5278                    sig != TARGET_SIGCONT) {
5279             force_sig(sig);
5280         }
5281     } else if (handler == TARGET_SIG_IGN) {
5282         /* ignore sig */
5283     } else if (handler == TARGET_SIG_ERR) {
5284         force_sig(sig);
5285     } else {
5286         /* compute the blocked signals during the handler execution */
5287         target_to_host_sigset(&set, &sa->sa_mask);
5288         /* SA_NODEFER indicates that the current signal should not be
5289            blocked during the handler */
5290         if (!(sa->sa_flags & TARGET_SA_NODEFER))
5291             sigaddset(&set, target_to_host_signal(sig));
5292 
5293         /* block signals in the handler using Linux */
5294         sigprocmask(SIG_BLOCK, &set, &old_set);
5295         /* save the previous blocked signal state to restore it at the
5296            end of the signal execution (see do_sigreturn) */
5297         host_to_target_sigset_internal(&target_old_set, &old_set);
5298 
5299         /* if the CPU is in VM86 mode, we restore the 32 bit values */
5300 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
5301         {
5302             CPUX86State *env = cpu_env;
5303             if (env->eflags & VM_MASK)
5304                 save_v86_state(env);
5305         }
5306 #endif
5307         /* prepare the stack frame of the virtual CPU */
5308         if (sa->sa_flags & TARGET_SA_SIGINFO)
5309             setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5310         else
5311             setup_frame(sig, sa, &target_old_set, cpu_env);
5312 	if (sa->sa_flags & TARGET_SA_RESETHAND)
5313             sa->_sa_handler = TARGET_SIG_DFL;
5314     }
5315     if (q != &k->info)
5316         free_sigqueue(cpu_env, q);
5317 }
5318