wineps: Don't display the MFCOMMENT escape.
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "windef.h"
37 #include "winternl.h"
38 #include "winnt.h"
39
40 #include "wine/exception.h"
41 #include "ntdll_misc.h"
42
43 #include "wine/debug.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(seh);
46
47 #define HANDLER_DEF(name) void name( int __signal, struct siginfo *__siginfo, ucontext_t *__context )
48 #define HANDLER_CONTEXT (__context)
49
50 typedef int (*wine_signal_handler)(unsigned int sig);
51
52 static wine_signal_handler handlers[256];
53
54 /***********************************************************************
55  *           dispatch_signal
56  */
57 inline static int dispatch_signal(unsigned int sig)
58 {
59     if (handlers[sig] == NULL) return 0;
60     return handlers[sig](sig);
61 }
62
63
64 /*
65  * FIXME:  All this works only on Solaris for now
66  */
67
68 /**********************************************************************
69  *              save_context
70  */
71 static void save_context( CONTEXT *context, ucontext_t *ucontext )
72 {
73     /* Special registers */
74     context->psr = ucontext->uc_mcontext.gregs[REG_PSR];
75     context->pc  = ucontext->uc_mcontext.gregs[REG_PC];
76     context->npc = ucontext->uc_mcontext.gregs[REG_nPC];
77     context->y   = ucontext->uc_mcontext.gregs[REG_Y];
78     context->wim = 0;  /* FIXME */
79     context->tbr = 0;  /* FIXME */
80
81     /* Global registers */
82     context->g0 = 0;  /* always */
83     context->g1 = ucontext->uc_mcontext.gregs[REG_G1];
84     context->g2 = ucontext->uc_mcontext.gregs[REG_G2];
85     context->g3 = ucontext->uc_mcontext.gregs[REG_G3];
86     context->g4 = ucontext->uc_mcontext.gregs[REG_G4];
87     context->g5 = ucontext->uc_mcontext.gregs[REG_G5];
88     context->g6 = ucontext->uc_mcontext.gregs[REG_G6];
89     context->g7 = ucontext->uc_mcontext.gregs[REG_G7];
90
91     /* Current 'out' registers */
92     context->o0 = ucontext->uc_mcontext.gregs[REG_O0];
93     context->o1 = ucontext->uc_mcontext.gregs[REG_O1];
94     context->o2 = ucontext->uc_mcontext.gregs[REG_O2];
95     context->o3 = ucontext->uc_mcontext.gregs[REG_O3];
96     context->o4 = ucontext->uc_mcontext.gregs[REG_O4];
97     context->o5 = ucontext->uc_mcontext.gregs[REG_O5];
98     context->o6 = ucontext->uc_mcontext.gregs[REG_O6];
99     context->o7 = ucontext->uc_mcontext.gregs[REG_O7];
100
101     /* FIXME: what if the current register window isn't saved? */
102     if ( ucontext->uc_mcontext.gwins && ucontext->uc_mcontext.gwins->wbcnt > 0 )
103     {
104         /* Current 'local' registers from first register window */
105         context->l0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[0];
106         context->l1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[1];
107         context->l2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[2];
108         context->l3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[3];
109         context->l4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[4];
110         context->l5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[5];
111         context->l6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[6];
112         context->l7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_local[7];
113
114         /* Current 'in' registers from first register window */
115         context->i0 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[0];
116         context->i1 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[1];
117         context->i2 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[2];
118         context->i3 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[3];
119         context->i4 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[4];
120         context->i5 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[5];
121         context->i6 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[6];
122         context->i7 = ucontext->uc_mcontext.gwins->wbuf[0].rw_in[7];
123     }
124 }
125
126 /**********************************************************************
127  *              restore_context
128  */
129 static void restore_context( CONTEXT *context, ucontext_t *ucontext )
130 {
131    /* FIXME */
132 }
133
134 /**********************************************************************
135  *              save_fpu
136  */
137 static void save_fpu( CONTEXT *context, ucontext_t *ucontext )
138 {
139    /* FIXME */
140 }
141
142 /**********************************************************************
143  *              restore_fpu
144  */
145 static void restore_fpu( CONTEXT *context, ucontext_t *ucontext )
146 {
147    /* FIXME */
148 }
149
150
151 /***********************************************************************
152  *           set_cpu_context
153  *
154  * Set the new CPU context.
155  */
156 void set_cpu_context( const CONTEXT *context )
157 {
158     FIXME("not implemented\n");
159 }
160
161
162 /**********************************************************************
163  *              segv_handler
164  *
165  * Handler for SIGSEGV.
166  */
167 static void segv_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
168 {
169     EXCEPTION_RECORD rec;
170     CONTEXT context;
171
172     /* we want the page-fault case to be fast */
173     if ( info->si_code == SEGV_ACCERR )
174         if (VIRTUAL_HandleFault( (LPVOID)info->si_addr )) return;
175
176     save_context( &context, ucontext );
177     rec.ExceptionCode    = EXCEPTION_ACCESS_VIOLATION;
178     rec.ExceptionRecord  = NULL;
179     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
180     rec.ExceptionAddress = (LPVOID)context.pc;
181     rec.NumberParameters = 2;
182     rec.ExceptionInformation[0] = 0;  /* FIXME: read/write access ? */
183     rec.ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
184
185     __regs_RtlRaiseException( &rec, &context );
186     restore_context( &context, ucontext );
187 }
188
189 /**********************************************************************
190  *              bus_handler
191  *
192  * Handler for SIGBUS.
193  */
194 static void bus_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
195 {
196     EXCEPTION_RECORD rec;
197     CONTEXT context;
198
199     save_context( &context, ucontext );
200     rec.ExceptionRecord  = NULL;
201     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
202     rec.ExceptionAddress = (LPVOID)context.pc;
203     rec.NumberParameters = 0;
204
205     if ( info->si_code == BUS_ADRALN )
206         rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
207     else
208         rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
209
210     __regs_RtlRaiseException( &rec, &context );
211     restore_context( &context, ucontext );
212 }
213
214 /**********************************************************************
215  *              ill_handler
216  *
217  * Handler for SIGILL.
218  */
219 static void ill_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
220 {
221     EXCEPTION_RECORD rec;
222     CONTEXT context;
223
224     switch ( info->si_code )
225     {
226     default:
227     case ILL_ILLOPC:
228     case ILL_ILLOPN:
229     case ILL_ILLADR:
230     case ILL_ILLTRP:
231         rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
232         break;
233
234     case ILL_PRVOPC:
235     case ILL_PRVREG:
236         rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
237         break;
238
239     case ILL_BADSTK:
240         rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
241         break;
242     }
243
244     save_context( &context, ucontext );
245     rec.ExceptionRecord  = NULL;
246     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
247     rec.ExceptionAddress = (LPVOID)context.pc;
248     rec.NumberParameters = 0;
249     __regs_RtlRaiseException( &rec, &context );
250     restore_context( &context, ucontext );
251 }
252
253
254 /**********************************************************************
255  *              trap_handler
256  *
257  * Handler for SIGTRAP.
258  */
259 static void trap_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
260 {
261     EXCEPTION_RECORD rec;
262     CONTEXT context;
263
264     switch ( info->si_code )
265     {
266     case TRAP_TRACE:
267         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
268         break;
269     case TRAP_BRKPT:
270     default:
271         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
272         break;
273     }
274
275     save_context( &context, ucontext );
276     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
277     rec.ExceptionRecord  = NULL;
278     rec.ExceptionAddress = (LPVOID)context.pc;
279     rec.NumberParameters = 0;
280     __regs_RtlRaiseException( &rec, &context );
281     restore_context( &context, ucontext );
282 }
283
284
285 /**********************************************************************
286  *              fpe_handler
287  *
288  * Handler for SIGFPE.
289  */
290 static void fpe_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
291 {
292     EXCEPTION_RECORD rec;
293     CONTEXT context;
294
295     switch ( info->si_code )
296     {
297     case FPE_FLTSUB:
298         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
299         break;
300     case FPE_INTDIV:
301         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
302         break;
303     case FPE_INTOVF:
304         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
305         break;
306     case FPE_FLTDIV:
307         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
308         break;
309     case FPE_FLTOVF:
310         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
311         break;
312     case FPE_FLTUND:
313         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
314         break;
315     case FPE_FLTRES:
316         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
317         break;
318     case FPE_FLTINV:
319     default:
320         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
321         break;
322     }
323
324     save_context( &context, ucontext );
325     save_fpu( &context, ucontext );
326     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
327     rec.ExceptionRecord  = NULL;
328     rec.ExceptionAddress = (LPVOID)context.pc;
329     rec.NumberParameters = 0;
330     __regs_RtlRaiseException( &rec, &context );
331     restore_context( &context, ucontext );
332     restore_fpu( &context, ucontext );
333 }
334
335
336 /**********************************************************************
337  *              int_handler
338  *
339  * Handler for SIGINT.
340  */
341 static void int_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
342 {
343     if (!dispatch_signal(SIGINT))
344     {
345         EXCEPTION_RECORD rec;
346         CONTEXT context;
347
348         save_context( &context, ucontext );
349         rec.ExceptionCode    = CONTROL_C_EXIT;
350         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
351         rec.ExceptionRecord  = NULL;
352         rec.ExceptionAddress = (LPVOID)context.pc;
353         rec.NumberParameters = 0;
354         __regs_RtlRaiseException( &rec, &context );
355         restore_context( &context, ucontext );
356     }
357 }
358
359 /**********************************************************************
360  *              abrt_handler
361  *
362  * Handler for SIGABRT.
363  */
364 static HANDLER_DEF(abrt_handler)
365 {
366     EXCEPTION_RECORD rec;
367     CONTEXT context;
368
369     save_context( &context, HANDLER_CONTEXT );
370     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
371     rec.ExceptionFlags   = EH_NONCONTINUABLE;
372     rec.ExceptionRecord  = NULL;
373     rec.ExceptionAddress = (LPVOID)context.pc;
374     rec.NumberParameters = 0;
375     __regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
376     restore_context( &context, HANDLER_CONTEXT );
377 }
378
379
380 /**********************************************************************
381  *              term_handler
382  *
383  * Handler for SIGTERM.
384  */
385 static HANDLER_DEF(term_handler)
386 {
387     server_abort_thread(0);
388 }
389
390
391 /**********************************************************************
392  *              usr1_handler
393  *
394  * Handler for SIGUSR1, used to signal a thread that it got suspended.
395  */
396 static HANDLER_DEF(usr1_handler)
397 {
398     CONTEXT context;
399
400     save_context( &context, HANDLER_CONTEXT );
401     wait_suspend( &context );
402     restore_context( &context, HANDLER_CONTEXT );
403 }
404
405
406 /**********************************************************************
407  *              get_signal_stack_total_size
408  *
409  * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
410  * Must be a power of two.
411  */
412 size_t get_signal_stack_total_size(void)
413 {
414     assert( sizeof(TEB) <= getpagesize() );
415     return getpagesize();  /* this is just for the TEB, we don't need a signal stack */
416 }
417
418
419 /***********************************************************************
420  *           set_handler
421  *
422  * Set a signal handler
423  */
424 static int set_handler( int sig, void (*func)() )
425 {
426     struct sigaction sig_act;
427
428     sig_act.sa_handler = NULL;
429     sig_act.sa_sigaction = func;
430     sigemptyset( &sig_act.sa_mask );
431     sig_act.sa_flags = SA_SIGINFO;
432
433     return sigaction( sig, &sig_act, NULL );
434 }
435
436
437 /***********************************************************************
438  *           __wine_set_signal_handler   (NTDLL.@)
439  */
440 int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
441 {
442     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
443     if (handlers[sig] != NULL) return -2;
444     handlers[sig] = wsh;
445     return 0;
446 }
447
448
449 /**********************************************************************
450  *              SIGNAL_Init
451  */
452 BOOL SIGNAL_Init(void)
453 {
454     if (set_handler( SIGINT,  (void (*)())int_handler  ) == -1) goto error;
455     if (set_handler( SIGFPE,  (void (*)())fpe_handler  ) == -1) goto error;
456     if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
457     if (set_handler( SIGILL,  (void (*)())ill_handler  ) == -1) goto error;
458     if (set_handler( SIGBUS,  (void (*)())bus_handler  ) == -1) goto error;
459     if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
460     if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
461     if (set_handler( SIGTERM, (void (*)())term_handler ) == -1) goto error;
462     if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
463     /* 'ta 6' tells the kernel to synthesize any unaligned accesses this 
464        process makes, instead of just signalling an error and terminating
465        the process.  wine-devel did not reach a conclusion on whether
466        this is correct, because that is what x86 does, or it is harmful 
467        because it could obscure problems in user code */
468     asm("ta 6"); /* 6 == ST_FIX_ALIGN defined in sys/trap.h */
469    return TRUE;
470
471  error:
472     perror("sigaction");
473     return FALSE;
474 }
475
476
477 /**********************************************************************
478  *              __wine_enter_vm86
479  */
480 void __wine_enter_vm86( CONTEXT *context )
481 {
482     MESSAGE("vm86 mode not supported on this platform\n");
483 }
484
485 /**********************************************************************
486  *              DbgBreakPoint   (NTDLL.@)
487  */
488 void WINAPI DbgBreakPoint(void)
489 {
490      kill(getpid(), SIGTRAP);
491 }
492
493 /**********************************************************************
494  *              DbgUserBreakPoint   (NTDLL.@)
495  */
496 void WINAPI DbgUserBreakPoint(void)
497 {
498      kill(getpid(), SIGTRAP);
499 }
500
501 #endif  /* __sparc__ */