1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "qemu/osdep.h"
20#include "qemu.h"
21#include "user-internals.h"
22#include "signal-common.h"
23#include "linux-user/trace.h"
24
25
26struct target_reg_window {
27 abi_ulong locals[8];
28 abi_ulong ins[8];
29};
30
31
32struct target_stackf {
33
34
35
36
37
38 struct target_reg_window win;
39
40
41
42
43
44 abi_ulong xargs[8];
45};
46
47struct target_siginfo_fpu {
48#ifdef TARGET_SPARC64
49 uint64_t si_double_regs[32];
50 uint64_t si_fsr;
51 uint64_t si_gsr;
52 uint64_t si_fprs;
53#else
54
55 uint64_t si_double_regs[16];
56 uint32_t si_fsr;
57 uint32_t si_fpqdepth;
58 struct {
59 uint32_t insn_addr;
60 uint32_t insn;
61 } si_fpqueue [16];
62#endif
63};
64
65#ifdef TARGET_ARCH_HAS_SETUP_FRAME
66struct target_signal_frame {
67 struct target_stackf ss;
68 struct target_pt_regs regs;
69 uint32_t si_mask;
70 abi_ulong fpu_save;
71 uint32_t insns[2] QEMU_ALIGNED(8);
72 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
73 abi_ulong extra_size;
74 abi_ulong rwin_save;
75};
76#endif
77
78struct target_rt_signal_frame {
79 struct target_stackf ss;
80 target_siginfo_t info;
81 struct target_pt_regs regs;
82#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
83 abi_ulong fpu_save;
84 target_stack_t stack;
85 target_sigset_t mask;
86#else
87 target_sigset_t mask;
88 abi_ulong fpu_save;
89 uint32_t insns[2];
90 target_stack_t stack;
91 abi_ulong extra_size;
92#endif
93 abi_ulong rwin_save;
94};
95
96static abi_ulong get_sigframe(struct target_sigaction *sa,
97 CPUSPARCState *env,
98 size_t framesize)
99{
100 abi_ulong sp = get_sp_from_cpustate(env);
101
102
103
104
105
106 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) {
107 return -1;
108 }
109
110
111 sp = target_sigsp(sp, sa) - framesize;
112
113
114
115
116
117
118
119
120 sp &= ~15UL;
121
122 return sp;
123}
124
125static void save_pt_regs(struct target_pt_regs *regs, CPUSPARCState *env)
126{
127 int i;
128
129#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
130 __put_user(sparc64_tstate(env), ®s->tstate);
131
132 __put_user(0, ®s->magic);
133#else
134 __put_user(cpu_get_psr(env), ®s->psr);
135#endif
136
137 __put_user(env->pc, ®s->pc);
138 __put_user(env->npc, ®s->npc);
139 __put_user(env->y, ®s->y);
140
141 for (i = 0; i < 8; i++) {
142 __put_user(env->gregs[i], ®s->u_regs[i]);
143 }
144 for (i = 0; i < 8; i++) {
145 __put_user(env->regwptr[WREG_O0 + i], ®s->u_regs[i + 8]);
146 }
147}
148
149static void restore_pt_regs(struct target_pt_regs *regs, CPUSPARCState *env)
150{
151 int i;
152
153#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
154
155 uint64_t tstate;
156 __get_user(tstate, ®s->tstate);
157 cpu_put_ccr(env, tstate >> 32);
158 env->asi = extract64(tstate, 24, 8);
159#else
160
161
162
163
164
165 uint32_t psr;
166 __get_user(psr, ®s->psr);
167 env->psr = (psr & PSR_ICC) | (env->psr & ~PSR_ICC);
168#endif
169
170
171
172 __get_user(env->y, ®s->y);
173
174 for (i = 0; i < 8; i++) {
175 __get_user(env->gregs[i], ®s->u_regs[i]);
176 }
177 for (i = 0; i < 8; i++) {
178 __get_user(env->regwptr[WREG_O0 + i], ®s->u_regs[i + 8]);
179 }
180}
181
182static void save_reg_win(struct target_reg_window *win, CPUSPARCState *env)
183{
184 int i;
185
186 for (i = 0; i < 8; i++) {
187 __put_user(env->regwptr[i + WREG_L0], &win->locals[i]);
188 }
189 for (i = 0; i < 8; i++) {
190 __put_user(env->regwptr[i + WREG_I0], &win->ins[i]);
191 }
192}
193
194static void save_fpu(struct target_siginfo_fpu *fpu, CPUSPARCState *env)
195{
196 int i;
197
198#ifdef TARGET_SPARC64
199 for (i = 0; i < 32; ++i) {
200 __put_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
201 }
202 __put_user(env->fsr, &fpu->si_fsr);
203 __put_user(env->gsr, &fpu->si_gsr);
204 __put_user(env->fprs, &fpu->si_fprs);
205#else
206 for (i = 0; i < 16; ++i) {
207 __put_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
208 }
209 __put_user(env->fsr, &fpu->si_fsr);
210 __put_user(0, &fpu->si_fpqdepth);
211#endif
212}
213
214static void restore_fpu(struct target_siginfo_fpu *fpu, CPUSPARCState *env)
215{
216 int i;
217
218#ifdef TARGET_SPARC64
219 uint64_t fprs;
220 __get_user(fprs, &fpu->si_fprs);
221
222
223 if (fprs & FPRS_DL) {
224 for (i = 0; i < 16; ++i) {
225 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
226 }
227 }
228 if (fprs & FPRS_DU) {
229 for (i = 16; i < 32; ++i) {
230 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
231 }
232 }
233 __get_user(env->fsr, &fpu->si_fsr);
234 __get_user(env->gsr, &fpu->si_gsr);
235 env->fprs |= fprs;
236#else
237 for (i = 0; i < 16; ++i) {
238 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
239 }
240 __get_user(env->fsr, &fpu->si_fsr);
241#endif
242}
243
244#ifdef TARGET_ARCH_HAS_SETUP_FRAME
245static void install_sigtramp(uint32_t *tramp, int syscall)
246{
247 __put_user(0x82102000u + syscall, &tramp[0]);
248 __put_user(0x91d02010u, &tramp[1]);
249}
250
251void setup_frame(int sig, struct target_sigaction *ka,
252 target_sigset_t *set, CPUSPARCState *env)
253{
254 abi_ulong sf_addr;
255 struct target_signal_frame *sf;
256 size_t sf_size = sizeof(*sf) + sizeof(struct target_siginfo_fpu);
257 int i;
258
259 sf_addr = get_sigframe(ka, env, sf_size);
260 trace_user_setup_frame(env, sf_addr);
261
262 sf = lock_user(VERIFY_WRITE, sf_addr, sf_size, 0);
263 if (!sf) {
264 force_sigsegv(sig);
265 return;
266 }
267
268
269 save_pt_regs(&sf->regs, env);
270 __put_user(0, &sf->extra_size);
271
272 save_fpu((struct target_siginfo_fpu *)(sf + 1), env);
273 __put_user(sf_addr + sizeof(*sf), &sf->fpu_save);
274
275 __put_user(0, &sf->rwin_save);
276
277 __put_user(set->sig[0], &sf->si_mask);
278 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
279 __put_user(set->sig[i + 1], &sf->extramask[i]);
280 }
281
282 save_reg_win(&sf->ss.win, env);
283
284
285 env->regwptr[WREG_SP] = sf_addr;
286 env->regwptr[WREG_O0] = sig;
287 env->regwptr[WREG_O1] = sf_addr +
288 offsetof(struct target_signal_frame, regs);
289 env->regwptr[WREG_O2] = sf_addr +
290 offsetof(struct target_signal_frame, regs);
291
292
293 env->pc = ka->_sa_handler;
294 env->npc = env->pc + 4;
295
296
297 if (ka->ka_restorer) {
298 env->regwptr[WREG_O7] = ka->ka_restorer;
299 } else {
300
301 install_sigtramp(sf->insns, TARGET_NR_sigreturn);
302 env->regwptr[WREG_O7] = default_sigreturn;
303 }
304 unlock_user(sf, sf_addr, sf_size);
305}
306#endif
307
308void setup_rt_frame(int sig, struct target_sigaction *ka,
309 target_siginfo_t *info,
310 target_sigset_t *set, CPUSPARCState *env)
311{
312 abi_ulong sf_addr;
313 struct target_rt_signal_frame *sf;
314 size_t sf_size = sizeof(*sf) + sizeof(struct target_siginfo_fpu);
315
316 sf_addr = get_sigframe(ka, env, sf_size);
317 trace_user_setup_rt_frame(env, sf_addr);
318
319 sf = lock_user(VERIFY_WRITE, sf_addr, sf_size, 0);
320 if (!sf) {
321 force_sigsegv(sig);
322 return;
323 }
324
325
326 save_reg_win(&sf->ss.win, env);
327 save_pt_regs(&sf->regs, env);
328
329 save_fpu((struct target_siginfo_fpu *)(sf + 1), env);
330 __put_user(sf_addr + sizeof(*sf), &sf->fpu_save);
331
332 __put_user(0, &sf->rwin_save);
333
334 tswap_siginfo(&sf->info, info);
335 tswap_sigset(&sf->mask, set);
336 target_save_altstack(&sf->stack, env);
337
338#ifdef TARGET_ABI32
339 __put_user(0, &sf->extra_size);
340#endif
341
342
343 env->regwptr[WREG_SP] = sf_addr - TARGET_STACK_BIAS;
344 env->regwptr[WREG_O0] = sig;
345 env->regwptr[WREG_O1] =
346 sf_addr + offsetof(struct target_rt_signal_frame, info);
347#ifdef TARGET_ABI32
348 env->regwptr[WREG_O2] =
349 sf_addr + offsetof(struct target_rt_signal_frame, regs);
350#else
351 env->regwptr[WREG_O2] = env->regwptr[WREG_O1];
352#endif
353
354
355 env->pc = ka->_sa_handler;
356 env->npc = env->pc + 4;
357
358
359#ifdef TARGET_ABI32
360 if (ka->ka_restorer) {
361 env->regwptr[WREG_O7] = ka->ka_restorer;
362 } else {
363
364 install_sigtramp(sf->insns, TARGET_NR_rt_sigreturn);
365 env->regwptr[WREG_O7] = default_rt_sigreturn;
366 }
367#else
368 env->regwptr[WREG_O7] = ka->ka_restorer;
369#endif
370
371 unlock_user(sf, sf_addr, sf_size);
372}
373
374long do_sigreturn(CPUSPARCState *env)
375{
376#ifdef TARGET_ARCH_HAS_SETUP_FRAME
377 abi_ulong sf_addr;
378 struct target_signal_frame *sf = NULL;
379 abi_ulong pc, npc, ptr;
380 target_sigset_t set;
381 sigset_t host_set;
382 int i;
383
384 sf_addr = env->regwptr[WREG_SP];
385 trace_user_do_sigreturn(env, sf_addr);
386
387
388 if ((sf_addr & 15) || !lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
389 goto segv_and_exit;
390 }
391
392
393 __get_user(ptr, &sf->regs.u_regs[14]);
394 if (ptr & 7) {
395 goto segv_and_exit;
396 }
397
398
399 __get_user(pc, &sf->regs.pc);
400 __get_user(npc, &sf->regs.npc);
401 if ((pc | npc) & 3) {
402 goto segv_and_exit;
403 }
404
405
406 restore_pt_regs(&sf->regs, env);
407 env->pc = pc;
408 env->npc = npc;
409
410 __get_user(ptr, &sf->fpu_save);
411 if (ptr) {
412 struct target_siginfo_fpu *fpu;
413 if ((ptr & 3) || !lock_user_struct(VERIFY_READ, fpu, ptr, 1)) {
414 goto segv_and_exit;
415 }
416 restore_fpu(fpu, env);
417 unlock_user_struct(fpu, ptr, 0);
418 }
419
420 __get_user(ptr, &sf->rwin_save);
421 if (ptr) {
422 goto segv_and_exit;
423 }
424
425 __get_user(set.sig[0], &sf->si_mask);
426 for (i = 1; i < TARGET_NSIG_WORDS; i++) {
427 __get_user(set.sig[i], &sf->extramask[i - 1]);
428 }
429
430 target_to_host_sigset_internal(&host_set, &set);
431 set_sigmask(&host_set);
432
433 unlock_user_struct(sf, sf_addr, 0);
434 return -TARGET_QEMU_ESIGRETURN;
435
436 segv_and_exit:
437 unlock_user_struct(sf, sf_addr, 0);
438 force_sig(TARGET_SIGSEGV);
439 return -TARGET_QEMU_ESIGRETURN;
440#else
441 return -TARGET_ENOSYS;
442#endif
443}
444
445long do_rt_sigreturn(CPUSPARCState *env)
446{
447 abi_ulong sf_addr, tpc, tnpc, ptr;
448 struct target_rt_signal_frame *sf = NULL;
449 sigset_t set;
450
451 sf_addr = get_sp_from_cpustate(env);
452 trace_user_do_rt_sigreturn(env, sf_addr);
453
454
455 if ((sf_addr & 15) || !lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
456 goto segv_and_exit;
457 }
458
459
460 __get_user(ptr, &sf->regs.u_regs[8 + WREG_SP]);
461 if ((ptr + TARGET_STACK_BIAS) & 7) {
462 goto segv_and_exit;
463 }
464
465
466 __get_user(tpc, &sf->regs.pc);
467 __get_user(tnpc, &sf->regs.npc);
468 if ((tpc | tnpc) & 3) {
469 goto segv_and_exit;
470 }
471
472
473 restore_pt_regs(&sf->regs, env);
474
475 __get_user(ptr, &sf->fpu_save);
476 if (ptr) {
477 struct target_siginfo_fpu *fpu;
478 if ((ptr & 7) || !lock_user_struct(VERIFY_READ, fpu, ptr, 1)) {
479 goto segv_and_exit;
480 }
481 restore_fpu(fpu, env);
482 unlock_user_struct(fpu, ptr, 0);
483 }
484
485 __get_user(ptr, &sf->rwin_save);
486 if (ptr) {
487 goto segv_and_exit;
488 }
489
490 target_restore_altstack(&sf->stack, env);
491 target_to_host_sigset(&set, &sf->mask);
492 set_sigmask(&set);
493
494 env->pc = tpc;
495 env->npc = tnpc;
496
497 unlock_user_struct(sf, sf_addr, 0);
498 return -TARGET_QEMU_ESIGRETURN;
499
500 segv_and_exit:
501 unlock_user_struct(sf, sf_addr, 0);
502 force_sig(TARGET_SIGSEGV);
503 return -TARGET_QEMU_ESIGRETURN;
504}
505
506#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
507#define SPARC_MC_TSTATE 0
508#define SPARC_MC_PC 1
509#define SPARC_MC_NPC 2
510#define SPARC_MC_Y 3
511#define SPARC_MC_G1 4
512#define SPARC_MC_G2 5
513#define SPARC_MC_G3 6
514#define SPARC_MC_G4 7
515#define SPARC_MC_G5 8
516#define SPARC_MC_G6 9
517#define SPARC_MC_G7 10
518#define SPARC_MC_O0 11
519#define SPARC_MC_O1 12
520#define SPARC_MC_O2 13
521#define SPARC_MC_O3 14
522#define SPARC_MC_O4 15
523#define SPARC_MC_O5 16
524#define SPARC_MC_O6 17
525#define SPARC_MC_O7 18
526#define SPARC_MC_NGREG 19
527
528typedef abi_ulong target_mc_greg_t;
529typedef target_mc_greg_t target_mc_gregset_t[SPARC_MC_NGREG];
530
531struct target_mc_fq {
532 abi_ulong mcfq_addr;
533 uint32_t mcfq_insn;
534};
535
536
537
538
539
540
541struct target_mc_fpu {
542 union {
543 uint32_t sregs[32];
544 uint64_t dregs[32];
545
546 } mcfpu_fregs;
547 abi_ulong mcfpu_fsr;
548 abi_ulong mcfpu_fprs;
549 abi_ulong mcfpu_gsr;
550 abi_ulong mcfpu_fq;
551 unsigned char mcfpu_qcnt;
552 unsigned char mcfpu_qentsz;
553 unsigned char mcfpu_enab;
554} __attribute__((aligned(16)));
555typedef struct target_mc_fpu target_mc_fpu_t;
556
557typedef struct {
558 target_mc_gregset_t mc_gregs;
559 target_mc_greg_t mc_fp;
560 target_mc_greg_t mc_i7;
561 target_mc_fpu_t mc_fpregs;
562} target_mcontext_t;
563
564struct target_ucontext {
565 abi_ulong tuc_link;
566 abi_ulong tuc_flags;
567 target_sigset_t tuc_sigmask;
568 target_mcontext_t tuc_mcontext;
569};
570
571
572void sparc64_set_context(CPUSPARCState *env)
573{
574 abi_ulong ucp_addr;
575 struct target_ucontext *ucp;
576 target_mc_gregset_t *grp;
577 target_mc_fpu_t *fpup;
578 abi_ulong pc, npc, tstate;
579 unsigned int i;
580 unsigned char fenab;
581
582 ucp_addr = env->regwptr[WREG_O0];
583 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
584 goto do_sigsegv;
585 }
586 grp = &ucp->tuc_mcontext.mc_gregs;
587 __get_user(pc, &((*grp)[SPARC_MC_PC]));
588 __get_user(npc, &((*grp)[SPARC_MC_NPC]));
589 if ((pc | npc) & 3) {
590 goto do_sigsegv;
591 }
592 if (env->regwptr[WREG_O1]) {
593 target_sigset_t target_set;
594 sigset_t set;
595
596 if (TARGET_NSIG_WORDS == 1) {
597 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
598 } else {
599 abi_ulong *src, *dst;
600 src = ucp->tuc_sigmask.sig;
601 dst = target_set.sig;
602 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
603 __get_user(*dst, src);
604 }
605 }
606 target_to_host_sigset_internal(&set, &target_set);
607 set_sigmask(&set);
608 }
609 env->pc = pc;
610 env->npc = npc;
611 __get_user(env->y, &((*grp)[SPARC_MC_Y]));
612 __get_user(tstate, &((*grp)[SPARC_MC_TSTATE]));
613
614 env->asi = (tstate >> 24) & 0xff;
615 cpu_put_ccr(env, (tstate >> 32) & 0xff);
616 __get_user(env->gregs[1], (&(*grp)[SPARC_MC_G1]));
617 __get_user(env->gregs[2], (&(*grp)[SPARC_MC_G2]));
618 __get_user(env->gregs[3], (&(*grp)[SPARC_MC_G3]));
619 __get_user(env->gregs[4], (&(*grp)[SPARC_MC_G4]));
620 __get_user(env->gregs[5], (&(*grp)[SPARC_MC_G5]));
621 __get_user(env->gregs[6], (&(*grp)[SPARC_MC_G6]));
622
623
624
625
626
627
628
629
630
631
632 __get_user(env->regwptr[WREG_O0], (&(*grp)[SPARC_MC_O0]));
633 __get_user(env->regwptr[WREG_O1], (&(*grp)[SPARC_MC_O1]));
634 __get_user(env->regwptr[WREG_O2], (&(*grp)[SPARC_MC_O2]));
635 __get_user(env->regwptr[WREG_O3], (&(*grp)[SPARC_MC_O3]));
636 __get_user(env->regwptr[WREG_O4], (&(*grp)[SPARC_MC_O4]));
637 __get_user(env->regwptr[WREG_O5], (&(*grp)[SPARC_MC_O5]));
638 __get_user(env->regwptr[WREG_O6], (&(*grp)[SPARC_MC_O6]));
639 __get_user(env->regwptr[WREG_O7], (&(*grp)[SPARC_MC_O7]));
640
641 __get_user(env->regwptr[WREG_FP], &(ucp->tuc_mcontext.mc_fp));
642 __get_user(env->regwptr[WREG_I7], &(ucp->tuc_mcontext.mc_i7));
643
644 fpup = &ucp->tuc_mcontext.mc_fpregs;
645
646 __get_user(fenab, &(fpup->mcfpu_enab));
647 if (fenab) {
648 abi_ulong fprs;
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666 __get_user(fprs, &(fpup->mcfpu_fprs));
667 if (fprs & FPRS_DL) {
668 for (i = 0; i < 16; i++) {
669 __get_user(env->fpr[i].ll, &(fpup->mcfpu_fregs.dregs[i]));
670 }
671 }
672 if (fprs & FPRS_DU) {
673 for (i = 16; i < 32; i++) {
674 __get_user(env->fpr[i].ll, &(fpup->mcfpu_fregs.dregs[i]));
675 }
676 }
677 __get_user(env->fsr, &(fpup->mcfpu_fsr));
678 __get_user(env->gsr, &(fpup->mcfpu_gsr));
679 }
680 unlock_user_struct(ucp, ucp_addr, 0);
681 return;
682do_sigsegv:
683 unlock_user_struct(ucp, ucp_addr, 0);
684 force_sig(TARGET_SIGSEGV);
685}
686
687void sparc64_get_context(CPUSPARCState *env)
688{
689 abi_ulong ucp_addr;
690 struct target_ucontext *ucp;
691 target_mc_gregset_t *grp;
692 target_mcontext_t *mcp;
693 int err;
694 unsigned int i;
695 target_sigset_t target_set;
696 sigset_t set;
697
698 ucp_addr = env->regwptr[WREG_O0];
699 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
700 goto do_sigsegv;
701 }
702
703 memset(ucp, 0, sizeof(*ucp));
704
705 mcp = &ucp->tuc_mcontext;
706 grp = &mcp->mc_gregs;
707
708
709 env->pc = env->npc;
710 env->npc += 4;
711
712
713
714
715
716
717 err = do_sigprocmask(0, NULL, &set);
718 assert(err == 0);
719 host_to_target_sigset_internal(&target_set, &set);
720 if (TARGET_NSIG_WORDS == 1) {
721 __put_user(target_set.sig[0],
722 (abi_ulong *)&ucp->tuc_sigmask);
723 } else {
724 abi_ulong *src, *dst;
725 src = target_set.sig;
726 dst = ucp->tuc_sigmask.sig;
727 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
728 __put_user(*src, dst);
729 }
730 }
731
732 __put_user(sparc64_tstate(env), &((*grp)[SPARC_MC_TSTATE]));
733 __put_user(env->pc, &((*grp)[SPARC_MC_PC]));
734 __put_user(env->npc, &((*grp)[SPARC_MC_NPC]));
735 __put_user(env->y, &((*grp)[SPARC_MC_Y]));
736 __put_user(env->gregs[1], &((*grp)[SPARC_MC_G1]));
737 __put_user(env->gregs[2], &((*grp)[SPARC_MC_G2]));
738 __put_user(env->gregs[3], &((*grp)[SPARC_MC_G3]));
739 __put_user(env->gregs[4], &((*grp)[SPARC_MC_G4]));
740 __put_user(env->gregs[5], &((*grp)[SPARC_MC_G5]));
741 __put_user(env->gregs[6], &((*grp)[SPARC_MC_G6]));
742 __put_user(env->gregs[7], &((*grp)[SPARC_MC_G7]));
743
744
745
746
747
748
749
750
751
752 __put_user(env->regwptr[WREG_O0], &((*grp)[SPARC_MC_O0]));
753 __put_user(env->regwptr[WREG_O1], &((*grp)[SPARC_MC_O1]));
754 __put_user(env->regwptr[WREG_O2], &((*grp)[SPARC_MC_O2]));
755 __put_user(env->regwptr[WREG_O3], &((*grp)[SPARC_MC_O3]));
756 __put_user(env->regwptr[WREG_O4], &((*grp)[SPARC_MC_O4]));
757 __put_user(env->regwptr[WREG_O5], &((*grp)[SPARC_MC_O5]));
758 __put_user(env->regwptr[WREG_O6], &((*grp)[SPARC_MC_O6]));
759 __put_user(env->regwptr[WREG_O7], &((*grp)[SPARC_MC_O7]));
760
761 __put_user(env->regwptr[WREG_FP], &(mcp->mc_fp));
762 __put_user(env->regwptr[WREG_I7], &(mcp->mc_i7));
763
764
765
766
767
768
769
770 unlock_user_struct(ucp, ucp_addr, 1);
771 return;
772do_sigsegv:
773 unlock_user_struct(ucp, ucp_addr, 1);
774 force_sig(TARGET_SIGSEGV);
775}
776#else
777void setup_sigtramp(abi_ulong sigtramp_page)
778{
779 uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 * 8, 0);
780 assert(tramp != NULL);
781
782 default_sigreturn = sigtramp_page;
783 install_sigtramp(tramp, TARGET_NR_sigreturn);
784
785 default_rt_sigreturn = sigtramp_page + 8;
786 install_sigtramp(tramp + 2, TARGET_NR_rt_sigreturn);
787
788 unlock_user(tramp, sigtramp_page, 2 * 8);
789}
790#endif
791