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