kernel32: Some English (United States) spelling fixes.
[wine] / dlls / ntdll / signal_sparc.c
1 /*
2  * Sparc signal handling routines
3  *
4  * Copyright 1999 Ulrich Weigand
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library 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 GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #ifdef __sparc__
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <sys/ucontext.h>
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39 #include "winternl.h"
40 #include "winnt.h"
41
42 #include "wine/exception.h"
43 #include "ntdll_misc.h"
44
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(seh);
48
49 static pthread_key_t teb_key;
50
51 typedef int (*wine_signal_handler)(unsigned int sig);
52
53 static wine_signal_handler handlers[256];
54
55 /***********************************************************************
56  *           dispatch_signal
57  */
58 static inline int dispatch_signal(unsigned int sig)
59 {
60     if (handlers[sig] == NULL) return 0;
61     return handlers[sig](sig);
62 }
63
64
65 /*
66  * FIXME:  All this works only on Solaris for now
67  */
68
69 /**********************************************************************
70  *              save_context
71  */
72 static void save_context( CONTEXT *context, ucontext_t *ucontext )
73 {
74     context->ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
75
76     /* Special registers */
77     context->psr = ucontext->uc_mcontext.gregs[REG_PSR];
78     context->pc  = ucontext->uc_mcontext.gregs[REG_PC];
79     context->npc = ucontext->uc_mcontext.gregs[REG_nPC];
80     context->y   = ucontext->uc_mcontext.gregs[REG_Y];
81     context->wim = 0;  /* FIXME */
82     context->tbr = 0;  /* FIXME */
83
84     /* Global registers */
85     context->g0 = 0;  /* always */
86     context->g1 = ucontext->uc_mcontext.gregs[REG_G1];
87     context->g2 = ucontext->uc_mcontext.gregs[REG_G2];
88     context->g3 = ucontext->uc_mcontext.gregs[REG_G3];
89     context->g4 = ucontext->uc_mcontext.gregs[REG_G4];
90     context->g5 = ucontext->uc_mcontext.gregs[REG_G5];
91     context->g6 = ucontext->uc_mcontext.gregs[REG_G6];
92     context->g7 = ucontext->uc_mcontext.gregs[REG_G7];
93
94     /* Current 'out' registers */
95     context->o0 = ucontext->uc_mcontext.gregs[REG_O0];
96     context->o1 = ucontext->uc_mcontext.gregs[REG_O1];
97     context->o2 = ucontext->uc_mcontext.gregs[REG_O2];
98     context->o3 = ucontext->uc_mcontext.gregs[REG_O3];
99     context->o4 = ucontext->uc_mcontext.gregs[REG_O4];
100     context->o5 = ucontext->uc_mcontext.gregs[REG_O5];
101     context->o6 = ucontext->uc_mcontext.gregs[REG_O6];
102     context->o7 = ucontext->uc_mcontext.gregs[REG_O7];
103
104     /* FIXME: what if the current register window isn't saved? */
105     if ( ucontext->uc_mcontext.gwins && ucontext->uc_mcontext.gwins->wbcnt > 0 )
106     {
107         /* Current 'local' registers from first register window */
108         context->l0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[0];
109         context->l1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[1];
110         context->l2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[2];
111         context->l3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[3];
112         context->l4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[4];
113         context->l5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[5];
114         context->l6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[6];
115         context->l7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[7];
116
117         /* Current 'in' registers from first register window */
118         context->i0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[0];
119         context->i1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[1];
120         context->i2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[2];
121         context->i3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[3];
122         context->i4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[4];
123         context->i5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[5];
124         context->i6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[6];
125         context->i7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[7];
126     }
127 }
128
129 /**********************************************************************
130  *              restore_context
131  */
132 static void restore_context( CONTEXT *context, ucontext_t *ucontext )
133 {
134    /* FIXME */
135 }
136
137 /**********************************************************************
138  *              save_fpu
139  */
140 static void save_fpu( CONTEXT *context, ucontext_t *ucontext )
141 {
142    /* FIXME */
143 }
144
145 /**********************************************************************
146  *              restore_fpu
147  */
148 static void restore_fpu( CONTEXT *context, ucontext_t *ucontext )
149 {
150    /* FIXME */
151 }
152
153
154 /**********************************************************************
155  *           call_stack_handlers
156  *
157  * Call the stack handlers chain.
158  */
159 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
160 {
161     EXCEPTION_POINTERS ptrs;
162
163     FIXME( "not implemented on Sparc\n" );
164
165     /* hack: call unhandled exception filter directly */
166     ptrs.ExceptionRecord = rec;
167     ptrs.ContextRecord = context;
168     unhandled_exception_filter( &ptrs );
169     return STATUS_UNHANDLED_EXCEPTION;
170 }
171
172
173 /*******************************************************************
174  *              raise_exception
175  *
176  * Implementation of NtRaiseException.
177  */
178 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
179 {
180     NTSTATUS status;
181
182     if (first_chance)
183     {
184         DWORD c;
185
186         TRACE( "code=%x flags=%x addr=%p ip=%x tid=%04x\n",
187                rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
188                context->pc, GetCurrentThreadId() );
189         for (c = 0; c < rec->NumberParameters; c++)
190             TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
191         if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
192         {
193             if (rec->ExceptionInformation[1] >> 16)
194                 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
195                          rec->ExceptionAddress,
196                          (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
197             else
198                 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
199                          rec->ExceptionAddress,
200                          (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
201         }
202         else
203         {
204             /* FIXME: dump context */
205         }
206
207         status = send_debug_event( rec, TRUE, context );
208         if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
209             return STATUS_SUCCESS;
210
211         if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
212             return STATUS_SUCCESS;
213
214         if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
215             return status;
216     }
217
218     /* last chance exception */
219
220     status = send_debug_event( rec, FALSE, context );
221     if (status != DBG_CONTINUE)
222     {
223         if (rec->ExceptionFlags & EH_STACK_INVALID)
224             ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
225         else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
226             ERR("Process attempted to continue execution after noncontinuable exception.\n");
227         else
228             ERR("Unhandled exception code %x flags %x addr %p\n",
229                 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
230         NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
231     }
232     return STATUS_SUCCESS;
233 }
234
235
236 /***********************************************************************
237  *              RtlCaptureContext (NTDLL.@)
238  */
239 void WINAPI RtlCaptureContext( CONTEXT *context )
240 {
241     FIXME("not implemented\n");
242     memset( context, 0, sizeof(*context) );
243 }
244
245
246 /***********************************************************************
247  *           set_cpu_context
248  *
249  * Set the new CPU context.
250  */
251 void set_cpu_context( const CONTEXT *context )
252 {
253     FIXME("not implemented\n");
254 }
255
256
257 /***********************************************************************
258  *           copy_context
259  *
260  * Copy a register context according to the flags.
261  */
262 void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
263 {
264     flags &= ~CONTEXT_SPARC;  /* get rid of CPU id */
265     if (flags & CONTEXT_CONTROL)
266     {
267         to->psr = from->psr;
268         to->pc  = from->pc;
269         to->npc = from->npc;
270         to->y   = from->y;
271         to->wim = from->wim;
272         to->tbr = from->tbr;
273     }
274     if (flags & CONTEXT_INTEGER)
275     {
276         to->g0 = from->g0;
277         to->g1 = from->g1;
278         to->g2 = from->g2;
279         to->g3 = from->g3;
280         to->g4 = from->g4;
281         to->g5 = from->g5;
282         to->g6 = from->g6;
283         to->g7 = from->g7;
284         to->o0 = from->o0;
285         to->o1 = from->o1;
286         to->o2 = from->o2;
287         to->o3 = from->o3;
288         to->o4 = from->o4;
289         to->o5 = from->o5;
290         to->o6 = from->o6;
291         to->o7 = from->o7;
292         to->l0 = from->l0;
293         to->l1 = from->l1;
294         to->l2 = from->l2;
295         to->l3 = from->l3;
296         to->l4 = from->l4;
297         to->l5 = from->l5;
298         to->l6 = from->l6;
299         to->l7 = from->l7;
300         to->i0 = from->i0;
301         to->i1 = from->i1;
302         to->i2 = from->i2;
303         to->i3 = from->i3;
304         to->i4 = from->i4;
305         to->i5 = from->i5;
306         to->i6 = from->i6;
307         to->i7 = from->i7;
308     }
309     if (flags & CONTEXT_FLOATING_POINT)
310     {
311         /* FIXME */
312     }
313 }
314
315
316 /***********************************************************************
317  *           context_to_server
318  *
319  * Convert a register context to the server format.
320  */
321 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
322 {
323     DWORD flags = from->ContextFlags & ~CONTEXT_SPARC;  /* get rid of CPU id */
324
325     memset( to, 0, sizeof(*to) );
326     to->cpu = CPU_SPARC;
327
328     if (flags & CONTEXT_CONTROL)
329     {
330         to->flags |= SERVER_CTX_CONTROL;
331         to->ctl.sparc_regs.psr = from->psr;
332         to->ctl.sparc_regs.pc  = from->pc;
333         to->ctl.sparc_regs.npc = from->npc;
334         to->ctl.sparc_regs.y   = from->y;
335         to->ctl.sparc_regs.wim = from->wim;
336         to->ctl.sparc_regs.tbr = from->tbr;
337     }
338     if (flags & CONTEXT_INTEGER)
339     {
340         to->flags |= SERVER_CTX_INTEGER;
341         to->integer.sparc_regs.g[0] = from->g0;
342         to->integer.sparc_regs.g[1] = from->g1;
343         to->integer.sparc_regs.g[2] = from->g2;
344         to->integer.sparc_regs.g[3] = from->g3;
345         to->integer.sparc_regs.g[4] = from->g4;
346         to->integer.sparc_regs.g[5] = from->g5;
347         to->integer.sparc_regs.g[6] = from->g6;
348         to->integer.sparc_regs.g[7] = from->g7;
349         to->integer.sparc_regs.o[0] = from->o0;
350         to->integer.sparc_regs.o[1] = from->o1;
351         to->integer.sparc_regs.o[2] = from->o2;
352         to->integer.sparc_regs.o[3] = from->o3;
353         to->integer.sparc_regs.o[4] = from->o4;
354         to->integer.sparc_regs.o[5] = from->o5;
355         to->integer.sparc_regs.o[6] = from->o6;
356         to->integer.sparc_regs.o[7] = from->o7;
357         to->integer.sparc_regs.l[0] = from->l0;
358         to->integer.sparc_regs.l[1] = from->l1;
359         to->integer.sparc_regs.l[2] = from->l2;
360         to->integer.sparc_regs.l[3] = from->l3;
361         to->integer.sparc_regs.l[4] = from->l4;
362         to->integer.sparc_regs.l[5] = from->l5;
363         to->integer.sparc_regs.l[6] = from->l6;
364         to->integer.sparc_regs.l[7] = from->l7;
365         to->integer.sparc_regs.i[0] = from->i0;
366         to->integer.sparc_regs.i[1] = from->i1;
367         to->integer.sparc_regs.i[2] = from->i2;
368         to->integer.sparc_regs.i[3] = from->i3;
369         to->integer.sparc_regs.i[4] = from->i4;
370         to->integer.sparc_regs.i[5] = from->i5;
371         to->integer.sparc_regs.i[6] = from->i6;
372         to->integer.sparc_regs.i[7] = from->i7;
373     }
374     if (flags & CONTEXT_FLOATING_POINT)
375     {
376         /* FIXME */
377     }
378     return STATUS_SUCCESS;
379 }
380
381
382 /***********************************************************************
383  *           context_from_server
384  *
385  * Convert a register context from the server format.
386  */
387 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
388 {
389     if (from->cpu != CPU_SPARC) return STATUS_INVALID_PARAMETER;
390
391     to->ContextFlags = CONTEXT_SPARC;
392     if (from->flags & SERVER_CTX_CONTROL)
393     {
394         to->ContextFlags |= CONTEXT_CONTROL;
395         to->psr = from->ctl.sparc_regs.psr;
396         to->pc  = from->ctl.sparc_regs.pc;
397         to->npc = from->ctl.sparc_regs.npc;
398         to->y   = from->ctl.sparc_regs.y;
399         to->wim = from->ctl.sparc_regs.wim;
400         to->tbr = from->ctl.sparc_regs.tbr;
401     }
402     if (from->flags & SERVER_CTX_INTEGER)
403     {
404         to->ContextFlags |= CONTEXT_INTEGER;
405         to->g0 = from->integer.sparc_regs.g[0];
406         to->g1 = from->integer.sparc_regs.g[1];
407         to->g2 = from->integer.sparc_regs.g[2];
408         to->g3 = from->integer.sparc_regs.g[3];
409         to->g4 = from->integer.sparc_regs.g[4];
410         to->g5 = from->integer.sparc_regs.g[5];
411         to->g6 = from->integer.sparc_regs.g[6];
412         to->g7 = from->integer.sparc_regs.g[7];
413         to->o0 = from->integer.sparc_regs.o[0];
414         to->o1 = from->integer.sparc_regs.o[1];
415         to->o2 = from->integer.sparc_regs.o[2];
416         to->o3 = from->integer.sparc_regs.o[3];
417         to->o4 = from->integer.sparc_regs.o[4];
418         to->o5 = from->integer.sparc_regs.o[5];
419         to->o6 = from->integer.sparc_regs.o[6];
420         to->o7 = from->integer.sparc_regs.o[7];
421         to->l0 = from->integer.sparc_regs.l[0];
422         to->l1 = from->integer.sparc_regs.l[1];
423         to->l2 = from->integer.sparc_regs.l[2];
424         to->l3 = from->integer.sparc_regs.l[3];
425         to->l4 = from->integer.sparc_regs.l[4];
426         to->l5 = from->integer.sparc_regs.l[5];
427         to->l6 = from->integer.sparc_regs.l[6];
428         to->l7 = from->integer.sparc_regs.l[7];
429         to->i0 = from->integer.sparc_regs.i[0];
430         to->i1 = from->integer.sparc_regs.i[1];
431         to->i2 = from->integer.sparc_regs.i[2];
432         to->i3 = from->integer.sparc_regs.i[3];
433         to->i4 = from->integer.sparc_regs.i[4];
434         to->i5 = from->integer.sparc_regs.i[5];
435         to->i6 = from->integer.sparc_regs.i[6];
436         to->i7 = from->integer.sparc_regs.i[7];
437     }
438     if (from->flags & SERVER_CTX_FLOATING_POINT)
439     {
440         /* FIXME */
441     }
442     return STATUS_SUCCESS;
443 }
444
445
446 /**********************************************************************
447  *              segv_handler
448  *
449  * Handler for SIGSEGV.
450  */
451 static void segv_handler( int signal, siginfo_t *info, void *ucontext )
452 {
453     EXCEPTION_RECORD rec;
454     CONTEXT context;
455     NTSTATUS status;
456
457     rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
458
459     /* we want the page-fault case to be fast */
460     if ( info->si_code == SEGV_ACCERR )
461         if (!(rec.ExceptionCode = virtual_handle_fault( info->si_addr, 0 ))) return;
462
463     save_context( &context, ucontext );
464     rec.ExceptionRecord  = NULL;
465     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
466     rec.ExceptionAddress = (LPVOID)context.pc;
467     rec.NumberParameters = 2;
468     rec.ExceptionInformation[0] = 0;  /* FIXME: read/write access ? */
469     rec.ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
470
471     status = raise_exception( &rec, &context, TRUE );
472     if (status) raise_status( status, &rec );
473     restore_context( &context, ucontext );
474 }
475
476 /**********************************************************************
477  *              bus_handler
478  *
479  * Handler for SIGBUS.
480  */
481 static void bus_handler( int signal, siginfo_t *info, void *ucontext )
482 {
483     EXCEPTION_RECORD rec;
484     CONTEXT context;
485     NTSTATUS status;
486
487     save_context( &context, ucontext );
488     rec.ExceptionRecord  = NULL;
489     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
490     rec.ExceptionAddress = (LPVOID)context.pc;
491     rec.NumberParameters = 0;
492
493     if ( info->si_code == BUS_ADRALN )
494         rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
495     else
496         rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
497
498     status = raise_exception( &rec, &context, TRUE );
499     if (status) raise_status( status, &rec );
500     restore_context( &context, ucontext );
501 }
502
503 /**********************************************************************
504  *              ill_handler
505  *
506  * Handler for SIGILL.
507  */
508 static void ill_handler( int signal, siginfo_t *info, void *ucontext )
509 {
510     EXCEPTION_RECORD rec;
511     CONTEXT context;
512     NTSTATUS status;
513
514     switch ( info->si_code )
515     {
516     default:
517     case ILL_ILLOPC:
518     case ILL_ILLOPN:
519     case ILL_ILLADR:
520     case ILL_ILLTRP:
521         rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
522         break;
523
524     case ILL_PRVOPC:
525     case ILL_PRVREG:
526         rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
527         break;
528
529     case ILL_BADSTK:
530         rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
531         break;
532     }
533
534     save_context( &context, ucontext );
535     rec.ExceptionRecord  = NULL;
536     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
537     rec.ExceptionAddress = (LPVOID)context.pc;
538     rec.NumberParameters = 0;
539     status = raise_exception( &rec, &context, TRUE );
540     if (status) raise_status( status, &rec );
541     restore_context( &context, ucontext );
542 }
543
544
545 /**********************************************************************
546  *              trap_handler
547  *
548  * Handler for SIGTRAP.
549  */
550 static void trap_handler( int signal, siginfo_t *info, void *ucontext )
551 {
552     EXCEPTION_RECORD rec;
553     CONTEXT context;
554     NTSTATUS status;
555
556     switch ( info->si_code )
557     {
558     case TRAP_TRACE:
559         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
560         break;
561     case TRAP_BRKPT:
562     default:
563         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
564         break;
565     }
566
567     save_context( &context, ucontext );
568     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
569     rec.ExceptionRecord  = NULL;
570     rec.ExceptionAddress = (LPVOID)context.pc;
571     rec.NumberParameters = 0;
572     status = raise_exception( &rec, &context, TRUE );
573     if (status) raise_status( status, &rec );
574     restore_context( &context, ucontext );
575 }
576
577
578 /**********************************************************************
579  *              fpe_handler
580  *
581  * Handler for SIGFPE.
582  */
583 static void fpe_handler( int signal, siginfo_t *info, void *ucontext )
584 {
585     EXCEPTION_RECORD rec;
586     CONTEXT context;
587     NTSTATUS status;
588
589     switch ( info->si_code )
590     {
591     case FPE_FLTSUB:
592         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
593         break;
594     case FPE_INTDIV:
595         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
596         break;
597     case FPE_INTOVF:
598         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
599         break;
600     case FPE_FLTDIV:
601         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
602         break;
603     case FPE_FLTOVF:
604         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
605         break;
606     case FPE_FLTUND:
607         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
608         break;
609     case FPE_FLTRES:
610         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
611         break;
612     case FPE_FLTINV:
613     default:
614         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
615         break;
616     }
617
618     save_context( &context, ucontext );
619     save_fpu( &context, ucontext );
620     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
621     rec.ExceptionRecord  = NULL;
622     rec.ExceptionAddress = (LPVOID)context.pc;
623     rec.NumberParameters = 0;
624     status = raise_exception( &rec, &context, TRUE );
625     if (status) raise_status( status, &rec );
626     restore_context( &context, ucontext );
627     restore_fpu( &context, ucontext );
628 }
629
630
631 /**********************************************************************
632  *              int_handler
633  *
634  * Handler for SIGINT.
635  */
636 static void int_handler( int signal, siginfo_t *info, void *ucontext )
637 {
638     if (!dispatch_signal(SIGINT))
639     {
640         EXCEPTION_RECORD rec;
641         CONTEXT context;
642         NTSTATUS status;
643
644         save_context( &context, ucontext );
645         rec.ExceptionCode    = CONTROL_C_EXIT;
646         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
647         rec.ExceptionRecord  = NULL;
648         rec.ExceptionAddress = (LPVOID)context.pc;
649         rec.NumberParameters = 0;
650         status = raise_exception( &rec, &context, TRUE );
651         if (status) raise_status( status, &rec );
652         restore_context( &context, ucontext );
653     }
654 }
655
656 /**********************************************************************
657  *              abrt_handler
658  *
659  * Handler for SIGABRT.
660  */
661 static void abrt_handler( int signal, struct siginfo *info, void *ucontext )
662 {
663     EXCEPTION_RECORD rec;
664     CONTEXT context;
665     NTSTATUS status;
666
667     save_context( &context, ucontext );
668     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
669     rec.ExceptionFlags   = EH_NONCONTINUABLE;
670     rec.ExceptionRecord  = NULL;
671     rec.ExceptionAddress = (LPVOID)context.pc;
672     rec.NumberParameters = 0;
673     status = raise_exception( &rec, &context, TRUE );
674     if (status) raise_status( status, &rec );
675     restore_context( &context, ucontext );
676 }
677
678
679 /**********************************************************************
680  *              quit_handler
681  *
682  * Handler for SIGQUIT.
683  */
684 static void quit_handler( int signal, struct siginfo *info, void *ucontext )
685 {
686     abort_thread(0);
687 }
688
689
690 /**********************************************************************
691  *              usr1_handler
692  *
693  * Handler for SIGUSR1, used to signal a thread that it got suspended.
694  */
695 static void usr1_handler( int signal, struct siginfo *info, void *ucontext )
696 {
697     CONTEXT context;
698
699     save_context( &context, ucontext );
700     wait_suspend( &context );
701     restore_context( &context, ucontext );
702 }
703
704
705 /***********************************************************************
706  *           __wine_set_signal_handler   (NTDLL.@)
707  */
708 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
709 {
710     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
711     if (handlers[sig] != NULL) return -2;
712     handlers[sig] = wsh;
713     return 0;
714 }
715
716
717 /**********************************************************************
718  *              signal_alloc_thread
719  */
720 NTSTATUS signal_alloc_thread( TEB **teb )
721 {
722     static size_t sigstack_zero_bits;
723     SIZE_T size;
724     NTSTATUS status;
725
726     if (!sigstack_zero_bits)
727     {
728         size_t min_size = getpagesize();  /* this is just for the TEB, we don't use a signal stack yet */
729         /* find the first power of two not smaller than min_size */
730         while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
731         assert( sizeof(TEB) <= min_size );
732     }
733
734     size = 1 << sigstack_zero_bits;
735     *teb = NULL;
736     if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
737                                             &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
738     {
739         (*teb)->Tib.Self = &(*teb)->Tib;
740         (*teb)->Tib.ExceptionList = (void *)~0UL;
741     }
742     return status;
743 }
744
745
746 /**********************************************************************
747  *              signal_free_thread
748  */
749 void signal_free_thread( TEB *teb )
750 {
751     SIZE_T size;
752
753     if (teb->DeallocationStack)
754     {
755         size = 0;
756         NtFreeVirtualMemory( GetCurrentProcess(), &teb->DeallocationStack, &size, MEM_RELEASE );
757     }
758     size = 0;
759     NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
760 }
761
762
763 /**********************************************************************
764  *              signal_init_thread
765  */
766 void signal_init_thread( TEB *teb )
767 {
768     static int init_done;
769
770     if (!init_done)
771     {
772         pthread_key_create( &teb_key, NULL );
773         init_done = 1;
774     }
775     pthread_setspecific( teb_key, teb );
776 }
777
778
779 /**********************************************************************
780  *              signal_init_process
781  */
782 void signal_init_process(void)
783 {
784     struct sigaction sig_act;
785
786     sig_act.sa_mask = server_block_set;
787     sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
788
789     sig_act.sa_sigaction = int_handler;
790     if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
791     sig_act.sa_sigaction = fpe_handler;
792     if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
793     sig_act.sa_sigaction = abrt_handler;
794     if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
795     sig_act.sa_sigaction = quit_handler;
796     if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
797     sig_act.sa_sigaction = usr1_handler;
798     if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
799
800     sig_act.sa_sigaction = segv_handler;
801     if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
802     sig_act.sa_sigaction = ill_handler;
803     if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
804 #ifdef SIGBUS
805     sig_act.sa_sigaction = bus_handler;
806     if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
807 #endif
808
809 #ifdef SIGTRAP
810     sig_act.sa_sigaction = trap_handler;
811     if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
812 #endif
813
814 #ifdef __sun__
815     /* 'ta 6' tells the kernel to synthesize any unaligned accesses this 
816        process makes, instead of just signalling an error and terminating
817        the process.  wine-devel did not reach a conclusion on whether
818        this is correct, because that is what x86 does, or it is harmful 
819        because it could obscure problems in user code */
820     __asm__("ta 6"); /* 6 == ST_FIX_ALIGN defined in sys/trap.h */
821 #endif
822
823     return;
824  error:
825     perror("sigaction");
826     exit(1);
827 }
828
829
830 /**********************************************************************
831  *              __wine_enter_vm86
832  */
833 void __wine_enter_vm86( CONTEXT *context )
834 {
835     MESSAGE("vm86 mode not supported on this platform\n");
836 }
837
838 /***********************************************************************
839  *            RtlUnwind  (NTDLL.@)
840  */
841 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
842 {
843     FIXME( "Not implemented on Sparc\n" );
844 }
845
846 /*******************************************************************
847  *              NtRaiseException (NTDLL.@)
848  */
849 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
850 {
851     NTSTATUS status = raise_exception( rec, context, first_chance );
852     if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
853     return status;
854 }
855
856 /***********************************************************************
857  *              RtlRaiseException (NTDLL.@)
858  */
859 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
860 {
861     CONTEXT context;
862     NTSTATUS status;
863
864     RtlCaptureContext( &context );
865     rec->ExceptionAddress = (void *)context.pc;
866     status = raise_exception( rec, &context, TRUE );
867     if (status) raise_status( status, rec );
868 }
869
870 /*************************************************************************
871  *              RtlCaptureStackBackTrace (NTDLL.@)
872  */
873 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
874 {
875     FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
876     return 0;
877 }
878
879 /***********************************************************************
880  *           call_thread_entry_point
881  */
882 void call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
883 {
884     __TRY
885     {
886         exit_thread( entry( arg ));
887     }
888     __EXCEPT(unhandled_exception_filter)
889     {
890         NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
891     }
892     __ENDTRY
893     abort();  /* should not be reached */
894 }
895
896 /***********************************************************************
897  *           RtlExitUserThread  (NTDLL.@)
898  */
899 void WINAPI RtlExitUserThread( ULONG status )
900 {
901     exit_thread( status );
902 }
903
904 /***********************************************************************
905  *           abort_thread
906  */
907 void abort_thread( int status )
908 {
909     terminate_thread( status );
910 }
911
912 /**********************************************************************
913  *              DbgBreakPoint   (NTDLL.@)
914  */
915 void WINAPI DbgBreakPoint(void)
916 {
917      kill(getpid(), SIGTRAP);
918 }
919
920 /**********************************************************************
921  *              DbgUserBreakPoint   (NTDLL.@)
922  */
923 void WINAPI DbgUserBreakPoint(void)
924 {
925      kill(getpid(), SIGTRAP);
926 }
927
928 /**********************************************************************
929  *           NtCurrentTeb   (NTDLL.@)
930  */
931 TEB * WINAPI NtCurrentTeb(void)
932 {
933     return pthread_getspecific( teb_key );
934 }
935
936 #endif  /* __sparc__ */