mshtml: Clean up get_all and tags (also fixes a typo).
[wine] / dlls / ntdll / signal_powerpc.c
1 /*
2  * PowerPC signal handling routines
3  *
4  * Copyright 2002 Marcus Meissner, SuSE Linux AG
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 __powerpc__
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34
35 #ifdef HAVE_SYS_PARAM_H
36 # include <sys/param.h>
37 #endif
38 #ifdef HAVE_SYSCALL_H
39 # include <syscall.h>
40 #else
41 # ifdef HAVE_SYS_SYSCALL_H
42 #  include <sys/syscall.h>
43 # endif
44 #endif
45
46 #ifdef HAVE_SYS_VM86_H
47 # include <sys/vm86.h>
48 #endif
49
50 #ifdef HAVE_SYS_SIGNAL_H
51 # include <sys/signal.h>
52 #endif
53
54 #include "windef.h"
55 #include "winternl.h"
56 #include "wine/library.h"
57 #include "wine/exception.h"
58 #include "ntdll_misc.h"
59 #include "wine/debug.h"
60
61 WINE_DEFAULT_DEBUG_CHANNEL(seh);
62
63
64 /***********************************************************************
65  * signal context platform-specific definitions
66  */
67 #ifdef linux
68
69 typedef struct ucontext SIGCONTEXT;
70
71 # define HANDLER_DEF(name) void name( int __signal, struct siginfo *__siginfo, SIGCONTEXT *__context )
72 # define HANDLER_CONTEXT (__context)
73
74 /* All Registers access - only for local access */
75 # define REG_sig(reg_name, context)             ((context)->uc_mcontext.regs->reg_name)
76
77
78 /* Gpr Registers access  */
79 # define GPR_sig(reg_num, context)              REG_sig(gpr[reg_num], context)
80
81 # define IAR_sig(context)                       REG_sig(nip, context)   /* Program counter */
82 # define MSR_sig(context)                       REG_sig(msr, context)   /* Machine State Register (Supervisor) */
83 # define CTR_sig(context)                       REG_sig(ctr, context)   /* Count register */
84
85 # define XER_sig(context)                       REG_sig(xer, context) /* User's integer exception register */
86 # define LR_sig(context)                        REG_sig(link, context) /* Link register */
87 # define CR_sig(context)                        REG_sig(ccr, context) /* Condition register */
88
89 /* Float Registers access  */
90 # define FLOAT_sig(reg_num, context)            (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
91
92 # define FPSCR_sig(context)                     (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
93
94 /* Exception Registers access */
95 # define DAR_sig(context)                       REG_sig(dar, context)
96 # define DSISR_sig(context)                     REG_sig(dsisr, context)
97 # define TRAP_sig(context)                      REG_sig(trap, context)
98
99 #endif /* linux */
100
101 #ifdef __APPLE__
102
103 # include <sys/ucontext.h>
104
105 # include <sys/types.h>
106 # include <signal.h>
107 typedef siginfo_t siginfo;
108
109 typedef struct ucontext SIGCONTEXT;
110
111
112 # define HANDLER_DEF(name) void name( int __signal, siginfo *__siginfo, SIGCONTEXT *__context )
113 # define HANDLER_CONTEXT (__context)
114
115 /* All Registers access - only for local access */
116 # define REG_sig(reg_name, context)             ((context)->uc_mcontext->ss.reg_name)
117 # define FLOATREG_sig(reg_name, context)        ((context)->uc_mcontext->fs.reg_name)
118 # define EXCEPREG_sig(reg_name, context)        ((context)->uc_mcontext->es.reg_name)
119 # define VECREG_sig(reg_name, context)          ((context)->uc_mcontext->vs.reg_name)
120
121 /* Gpr Registers access */
122 # define GPR_sig(reg_num, context)              REG_sig(r##reg_num, context)
123
124 # define IAR_sig(context)                       REG_sig(srr0, context)  /* Program counter */
125 # define MSR_sig(context)                       REG_sig(srr1, context)  /* Machine State Register (Supervisor) */
126 # define CTR_sig(context)                       REG_sig(ctr, context)
127
128 # define XER_sig(context)                       REG_sig(xer, context) /* Link register */
129 # define LR_sig(context)                        REG_sig(lr, context)  /* User's integer exception register */
130 # define CR_sig(context)                        REG_sig(cr, context)  /* Condition register */
131
132 /* Float Registers access */
133 # define FLOAT_sig(reg_num, context)            FLOATREG_sig(fpregs[reg_num], context)
134
135 # define FPSCR_sig(context)                     FLOATREG_sig(fpscr, context)
136
137 /* Exception Registers access */
138 # define DAR_sig(context)                       EXCEPREG_sig(dar, context)     /* Fault registers for coredump */
139 # define DSISR_sig(context)                     EXCEPREG_sig(dsisr, context)
140 # define TRAP_sig(context)                      EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
141
142 /* Signal defs : Those are undefined on darwin
143 SIGBUS
144 #undef BUS_ADRERR
145 #undef BUS_OBJERR
146 SIGILL
147 #undef ILL_ILLOPN
148 #undef ILL_ILLTRP
149 #undef ILL_ILLADR
150 #undef ILL_COPROC
151 #undef ILL_PRVREG
152 #undef ILL_BADSTK
153 SIGTRAP
154 #undef TRAP_BRKPT
155 #undef TRAP_TRACE
156 SIGFPE
157 */
158
159 #endif /* __APPLE__ */
160
161
162
163 typedef int (*wine_signal_handler)(unsigned int sig);
164
165 static wine_signal_handler handlers[256];
166
167 /***********************************************************************
168  *           dispatch_signal
169  */
170 inline static int dispatch_signal(unsigned int sig)
171 {
172     if (handlers[sig] == NULL) return 0;
173     return handlers[sig](sig);
174 }
175
176 /***********************************************************************
177  *           save_context
178  *
179  * Set the register values from a sigcontext.
180  */
181 static void save_context( CONTEXT *context, const SIGCONTEXT *sigcontext )
182 {
183
184 #define C(x) context->Gpr##x = GPR_sig(x,sigcontext)
185         /* Save Gpr registers */
186         C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
187         C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
188         C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
189         C(31);
190 #undef C
191
192         context->Iar = IAR_sig(sigcontext);  /* Program Counter */
193         context->Msr = MSR_sig(sigcontext);  /* Machine State Register (Supervisor) */
194         context->Ctr = CTR_sig(sigcontext);
195         
196         context->Xer = XER_sig(sigcontext);
197         context->Lr  = LR_sig(sigcontext);
198         context->Cr  = CR_sig(sigcontext);
199         
200         /* Saving Exception regs */
201         context->Dar   = DAR_sig(sigcontext);
202         context->Dsisr = DSISR_sig(sigcontext);
203         context->Trap  = TRAP_sig(sigcontext);
204 }
205
206
207 /***********************************************************************
208  *           restore_context
209  *
210  * Build a sigcontext from the register values.
211  */
212 static void restore_context( const CONTEXT *context, SIGCONTEXT *sigcontext )
213 {
214
215 #define C(x)  GPR_sig(x,sigcontext) = context->Gpr##x
216         C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
217         C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
218         C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
219         C(31);
220 #undef C
221
222         IAR_sig(sigcontext) = context->Iar;  /* Program Counter */
223         MSR_sig(sigcontext) = context->Msr;  /* Machine State Register (Supervisor) */
224         CTR_sig(sigcontext) = context->Ctr;
225         
226         XER_sig(sigcontext) = context->Xer;
227         LR_sig(sigcontext) = context->Lr;
228         CR_sig(sigcontext) = context->Cr;
229         
230         /* Setting Exception regs */
231         DAR_sig(sigcontext) = context->Dar;
232         DSISR_sig(sigcontext) = context->Dsisr;
233         TRAP_sig(sigcontext) = context->Trap;
234 }
235
236
237 /***********************************************************************
238  *           save_fpu
239  *
240  * Set the FPU context from a sigcontext.
241  */
242 inline static void save_fpu( CONTEXT *context, const SIGCONTEXT *sigcontext )
243 {
244 #define C(x)   context->Fpr##x = FLOAT_sig(x,sigcontext)
245         C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
246         C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
247         C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
248         C(31);
249 #undef C
250         context->Fpscr = FPSCR_sig(sigcontext);
251 }
252
253
254 /***********************************************************************
255  *           restore_fpu
256  *
257  * Restore the FPU context to a sigcontext.
258  */
259 inline static void restore_fpu( CONTEXT *context, const SIGCONTEXT *sigcontext )
260 {
261 #define C(x)  FLOAT_sig(x,sigcontext) = context->Fpr##x
262         C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
263         C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
264         C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
265         C(31);
266 #undef C
267         FPSCR_sig(sigcontext) = context->Fpscr;
268 }
269
270
271 /***********************************************************************
272  *           set_cpu_context
273  *
274  * Set the new CPU context.
275  */
276 void set_cpu_context( const CONTEXT *context )
277 {
278     FIXME("not implemented\n");
279 }
280
281
282 /**********************************************************************
283  *              get_fpu_code
284  *
285  * Get the FPU exception code from the FPU status.
286  */
287 static inline DWORD get_fpu_code( const CONTEXT *context )
288 {
289     DWORD status  = context->Fpscr;
290
291     if (status & 0x01)  /* IE */
292     {
293         if (status & 0x40)  /* SF */
294             return EXCEPTION_FLT_STACK_CHECK;
295         else
296             return EXCEPTION_FLT_INVALID_OPERATION;
297     }
298     if (status & 0x02) return EXCEPTION_FLT_DENORMAL_OPERAND;  /* DE flag */
299     if (status & 0x04) return EXCEPTION_FLT_DIVIDE_BY_ZERO;    /* ZE flag */
300     if (status & 0x08) return EXCEPTION_FLT_OVERFLOW;          /* OE flag */
301     if (status & 0x10) return EXCEPTION_FLT_UNDERFLOW;         /* UE flag */
302     if (status & 0x20) return EXCEPTION_FLT_INEXACT_RESULT;    /* PE flag */
303     return EXCEPTION_FLT_INVALID_OPERATION;  /* generic error */
304 }
305
306 /**********************************************************************
307  *              do_segv
308  *
309  * Implementation of SIGSEGV handler.
310  */
311 static void do_segv( CONTEXT *context, int trap, int err, int code, void * addr )
312 {
313     EXCEPTION_RECORD rec;
314     DWORD page_fault_code = EXCEPTION_ACCESS_VIOLATION;
315
316     rec.ExceptionRecord  = NULL;
317     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
318     rec.ExceptionAddress = addr;
319     rec.NumberParameters = 0;
320     
321     switch (trap) {
322     case SIGSEGV:
323         switch ( code & 0xffff ) {
324         case SEGV_MAPERR:
325         case SEGV_ACCERR:
326                 rec.NumberParameters = 2;
327                 rec.ExceptionInformation[0] = 0; /* FIXME ? */
328                 rec.ExceptionInformation[1] = (ULONG_PTR)addr;
329                 if (!(page_fault_code=VIRTUAL_HandleFault(addr)))
330                         return;
331                 rec.ExceptionCode = page_fault_code;
332                 break;
333         default:FIXME("Unhandled SIGSEGV/%x\n",code);
334                 break;
335         }
336         break;
337     case SIGBUS:
338         switch ( code & 0xffff ) {
339         case BUS_ADRALN:
340                 rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
341                 break;
342 #ifdef BUS_ADRERR
343         case BUS_ADRERR:
344 #endif
345 #ifdef BUS_OBJERR
346         case BUS_OBJERR:
347                 /* FIXME: correct for all cases ? */
348                 rec.NumberParameters = 2;
349                 rec.ExceptionInformation[0] = 0; /* FIXME ? */
350                 rec.ExceptionInformation[1] = (ULONG_PTR)addr;
351                 if (!(page_fault_code=VIRTUAL_HandleFault(addr)))
352                         return;
353                 rec.ExceptionCode = page_fault_code;
354                 break;
355 #endif
356         default:FIXME("Unhandled SIGBUS/%x\n",code);
357                 break;
358         }
359         break;
360     case SIGILL:
361         switch ( code & 0xffff ) {
362         case ILL_ILLOPC: /* illegal opcode */
363 #ifdef ILL_ILLOPN
364         case ILL_ILLOPN: /* illegal operand */
365 #endif
366 #ifdef ILL_ILLADR
367         case ILL_ILLADR: /* illegal addressing mode */
368 #endif
369 #ifdef ILL_ILLTRP
370         case ILL_ILLTRP: /* illegal trap */
371 #endif
372 #ifdef ILL_COPROC
373         case ILL_COPROC: /* coprocessor error */
374 #endif
375                 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
376                 break;
377         case ILL_PRVOPC: /* privileged opcode */
378 #ifdef ILL_PRVREG
379         case ILL_PRVREG: /* privileged register */
380 #endif
381                 rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
382                 break;
383 #ifdef ILL_BADSTK
384         case ILL_BADSTK: /* internal stack error */
385                 rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
386                 break;
387 #endif
388         default:FIXME("Unhandled SIGILL/%x\n", code);
389                 break;
390         }
391         break;
392     }
393     __regs_RtlRaiseException( &rec, context );
394 }
395
396 /**********************************************************************
397  *              do_trap
398  *
399  * Implementation of SIGTRAP handler.
400  */
401 static void do_trap( CONTEXT *context, int code, void * addr )
402 {
403     EXCEPTION_RECORD rec;
404
405     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
406     rec.ExceptionRecord  = NULL;
407     rec.ExceptionAddress = addr;
408     rec.NumberParameters = 0;
409
410     /* FIXME: check if we might need to modify PC */
411     switch (code & 0xffff) {
412 #ifdef TRAP_BRKPT
413     case TRAP_BRKPT:
414         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
415         break;
416 #endif
417 #ifdef TRAP_TRACE
418     case TRAP_TRACE:
419         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
420         break;
421 #endif
422     default:FIXME("Unhandled SIGTRAP/%x\n", code);
423                 break;
424     }
425     __regs_RtlRaiseException( &rec, context );
426 }
427
428 /**********************************************************************
429  *              do_trap
430  *
431  * Implementation of SIGFPE handler.
432  */
433 static void do_fpe( CONTEXT *context, int code, void * addr )
434 {
435     EXCEPTION_RECORD rec;
436
437     switch ( code  & 0xffff ) {
438 #ifdef FPE_FLTSUB
439     case FPE_FLTSUB:
440         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
441         break;
442 #endif
443 #ifdef FPE_INTDIV
444     case FPE_INTDIV:
445         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
446         break;
447 #endif
448 #ifdef FPE_INTOVF
449     case FPE_INTOVF:
450         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
451         break;
452 #endif
453 #ifdef FPE_FLTDIV
454     case FPE_FLTDIV:
455         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
456         break;
457 #endif
458 #ifdef FPE_FLTOVF
459     case FPE_FLTOVF:
460         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
461         break;
462 #endif
463 #ifdef FPE_FLTUND
464     case FPE_FLTUND:
465         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
466         break;
467 #endif
468 #ifdef FPE_FLTRES
469     case FPE_FLTRES:
470         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
471         break;
472 #endif
473 #ifdef FPE_FLTINV
474     case FPE_FLTINV:
475 #endif
476     default:
477         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
478         break;
479     }
480     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
481     rec.ExceptionRecord  = NULL;
482     rec.ExceptionAddress = addr;
483     rec.NumberParameters = 0;
484     __regs_RtlRaiseException( &rec, context );
485 }
486
487 /**********************************************************************
488  *              segv_handler
489  *
490  * Handler for SIGSEGV and related errors.
491  */
492 static HANDLER_DEF(segv_handler)
493 {
494     CONTEXT context;
495     save_context( &context, HANDLER_CONTEXT );
496     do_segv( &context, __siginfo->si_signo, __siginfo->si_errno, __siginfo->si_code, __siginfo->si_addr );
497     restore_context( &context, HANDLER_CONTEXT );
498 }
499
500 /**********************************************************************
501  *              trap_handler
502  *
503  * Handler for SIGTRAP.
504  */
505 static HANDLER_DEF(trap_handler)
506 {
507     CONTEXT context;
508     save_context( &context, HANDLER_CONTEXT );
509     do_trap( &context, __siginfo->si_code, __siginfo->si_addr );
510     restore_context( &context, HANDLER_CONTEXT );
511 }
512
513 /**********************************************************************
514  *              fpe_handler
515  *
516  * Handler for SIGFPE.
517  */
518 static HANDLER_DEF(fpe_handler)
519 {
520     CONTEXT context;
521     save_fpu( &context, HANDLER_CONTEXT );
522     save_context( &context, HANDLER_CONTEXT );
523     do_fpe( &context,  __siginfo->si_code, __siginfo->si_addr );
524     restore_context( &context, HANDLER_CONTEXT );
525     restore_fpu( &context, HANDLER_CONTEXT );
526 }
527
528 /**********************************************************************
529  *              int_handler
530  *
531  * Handler for SIGINT.
532  */
533 static HANDLER_DEF(int_handler)
534 {
535     if (!dispatch_signal(SIGINT))
536     {
537         EXCEPTION_RECORD rec;
538         CONTEXT context;
539
540         save_context( &context, HANDLER_CONTEXT );
541         rec.ExceptionCode    = CONTROL_C_EXIT;
542         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
543         rec.ExceptionRecord  = NULL;
544         rec.ExceptionAddress = (LPVOID)context.Iar;
545         rec.NumberParameters = 0;
546         __regs_RtlRaiseException( &rec, &context );
547         restore_context( &context, HANDLER_CONTEXT );
548     }
549 }
550
551
552 /**********************************************************************
553  *              abrt_handler
554  *
555  * Handler for SIGABRT.
556  */
557 static HANDLER_DEF(abrt_handler)
558 {
559     EXCEPTION_RECORD rec;
560     CONTEXT context;
561
562     save_context( &context, HANDLER_CONTEXT );
563     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
564     rec.ExceptionFlags   = EH_NONCONTINUABLE;
565     rec.ExceptionRecord  = NULL;
566     rec.ExceptionAddress = (LPVOID)context.Iar;
567     rec.NumberParameters = 0;
568     __regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
569     restore_context( &context, HANDLER_CONTEXT );
570 }
571
572
573 /**********************************************************************
574  *              term_handler
575  *
576  * Handler for SIGTERM.
577  */
578 static HANDLER_DEF(term_handler)
579 {
580     server_abort_thread(0);
581 }
582
583
584 /**********************************************************************
585  *              usr1_handler
586  *
587  * Handler for SIGUSR1, used to signal a thread that it got suspended.
588  */
589 static HANDLER_DEF(usr1_handler)
590 {
591     CONTEXT context;
592
593     save_context( &context, HANDLER_CONTEXT );
594     wait_suspend( &context );
595     restore_context( &context, HANDLER_CONTEXT );
596 }
597
598
599 /**********************************************************************
600  *              get_signal_stack_total_size
601  *
602  * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
603  * Must be a power of two.
604  */
605 size_t get_signal_stack_total_size(void)
606 {
607     assert( sizeof(TEB) <= getpagesize() );
608     return getpagesize();  /* this is just for the TEB, we don't need a signal stack */
609 }
610
611
612 /***********************************************************************
613  *           set_handler
614  *
615  * Set a signal handler
616  */
617 static int set_handler( int sig, void (*func)() )
618 {
619     struct sigaction sig_act;
620
621     sig_act.sa_sigaction = func;
622     sigemptyset( &sig_act.sa_mask );
623     sigaddset( &sig_act.sa_mask, SIGINT );
624     sigaddset( &sig_act.sa_mask, SIGALRM );
625
626     sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
627     return sigaction( sig, &sig_act, NULL );
628 }
629
630
631 /***********************************************************************
632  *           __wine_set_signal_handler   (NTDLL.@)
633  */
634 int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
635 {
636     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
637     if (handlers[sig] != NULL) return -2;
638     handlers[sig] = wsh;
639     return 0;
640 }
641
642
643 /**********************************************************************
644  *              SIGNAL_Init
645  */
646 BOOL SIGNAL_Init(void)
647 {
648     if (set_handler( SIGINT,  (void (*)())int_handler ) == -1) goto error;
649     if (set_handler( SIGFPE,  (void (*)())fpe_handler ) == -1) goto error;
650     if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
651     if (set_handler( SIGILL,  (void (*)())segv_handler ) == -1) goto error;
652     if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
653     if (set_handler( SIGTERM, (void (*)())term_handler ) == -1) goto error;
654     if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
655 #ifdef SIGBUS
656     if (set_handler( SIGBUS,  (void (*)())segv_handler ) == -1) goto error;
657 #endif
658 #ifdef SIGTRAP
659     if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
660 #endif
661
662     return TRUE;
663
664  error:
665     perror("sigaction");
666     return FALSE;
667 }
668
669
670 /**********************************************************************
671  *              __wine_enter_vm86   (NTDLL.@)
672  */
673 void __wine_enter_vm86( CONTEXT *context )
674 {
675     MESSAGE("vm86 mode not supported on this platform\n");
676 }
677
678 /**********************************************************************
679  *              DbgBreakPoint   (NTDLL.@)
680  */
681 void WINAPI DbgBreakPoint(void)
682 {
683      kill(getpid(), SIGTRAP);
684 }
685
686 /**********************************************************************
687  *              DbgUserBreakPoint   (NTDLL.@)
688  */
689 void WINAPI DbgUserBreakPoint(void)
690 {
691      kill(getpid(), SIGTRAP);
692 }
693
694 #endif  /* __powerpc__ */