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 DWORD page_fault_code = EXCEPTION_ACCESS_VIOLATION;
325
326 rec.ExceptionRecord = NULL;
327 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
328 rec.ExceptionAddress = addr;
329 rec.NumberParameters = 0;
330
331 switch (trap) {
332 case SIGSEGV:
333 switch ( code & 0xffff ) {
334 case SEGV_MAPERR:
335 case SEGV_ACCERR:
336 rec.NumberParameters = 2;
337 rec.ExceptionInformation[0] = 0; /* FIXME ? */
338 rec.ExceptionInformation[1] = (ULONG_PTR)addr;
339 if (!(page_fault_code=VIRTUAL_HandleFault(addr)))
340 return;
341 rec.ExceptionCode = page_fault_code;
342 break;
343 default:FIXME("Unhandled SIGSEGV/%x\n",code);
344 break;
345 }
346 break;
347 case SIGBUS:
348 switch ( code & 0xffff ) {
349 case BUS_ADRALN:
350 rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
351 break;
352 #ifdef BUS_ADRERR
353 case BUS_ADRERR:
354 #endif
355 #ifdef BUS_OBJERR
356 case BUS_OBJERR:
357 /* FIXME: correct for all cases ? */
358 rec.NumberParameters = 2;
359 rec.ExceptionInformation[0] = 0; /* FIXME ? */
360 rec.ExceptionInformation[1] = (ULONG_PTR)addr;
361 if (!(page_fault_code=VIRTUAL_HandleFault(addr)))
362 return;
363 rec.ExceptionCode = page_fault_code;
364 break;
365 #endif
366 default:FIXME("Unhandled SIGBUS/%x\n",code);
367 break;
368 }
369 break;
370 case SIGILL:
371 switch ( code & 0xffff ) {
372 case ILL_ILLOPC: /* illegal opcode */
373 #ifdef ILL_ILLOPN
374 case ILL_ILLOPN: /* illegal operand */
375 #endif
376 #ifdef ILL_ILLADR
377 case ILL_ILLADR: /* illegal addressing mode */
378 #endif
379 #ifdef ILL_ILLTRP
380 case ILL_ILLTRP: /* illegal trap */
381 #endif
382 #ifdef ILL_COPROC
383 case ILL_COPROC: /* coprocessor error */
384 #endif
385 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
386 break;
387 case ILL_PRVOPC: /* privileged opcode */
388 #ifdef ILL_PRVREG
389 case ILL_PRVREG: /* privileged register */
390 #endif
391 rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
392 break;
393 #ifdef ILL_BADSTK
394 case ILL_BADSTK: /* internal stack error */
395 rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
396 break;
397 #endif
398 default:FIXME("Unhandled SIGILL/%x\n", code);
399 break;
400 }
401 break;
402 }
403 __regs_RtlRaiseException( &rec, context );
404 }
405
406 /**********************************************************************
407 * do_trap
408 *
409 * Implementation of SIGTRAP handler.
410 */
411 static void do_trap( CONTEXT *context, int code, void * addr )
412 {
413 EXCEPTION_RECORD rec;
414
415 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
416 rec.ExceptionRecord = NULL;
417 rec.ExceptionAddress = addr;
418 rec.NumberParameters = 0;
419
420 /* FIXME: check if we might need to modify PC */
421 switch (code & 0xffff) {
422 #ifdef TRAP_BRKPT
423 case TRAP_BRKPT:
424 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
425 break;
426 #endif
427 #ifdef TRAP_TRACE
428 case TRAP_TRACE:
429 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
430 break;
431 #endif
432 default:FIXME("Unhandled SIGTRAP/%x\n", code);
433 break;
434 }
435 __regs_RtlRaiseException( &rec, context );
436 }
437
438 /**********************************************************************
439 * do_trap
440 *
441 * Implementation of SIGFPE handler.
442 */
443 static void do_fpe( CONTEXT *context, int code, void * addr )
444 {
445 EXCEPTION_RECORD rec;
446
447 switch ( code & 0xffff ) {
448 #ifdef FPE_FLTSUB
449 case FPE_FLTSUB:
450 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
451 break;
452 #endif
453 #ifdef FPE_INTDIV
454 case FPE_INTDIV:
455 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
456 break;
457 #endif
458 #ifdef FPE_INTOVF
459 case FPE_INTOVF:
460 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
461 break;
462 #endif
463 #ifdef FPE_FLTDIV
464 case FPE_FLTDIV:
465 rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
466 break;
467 #endif
468 #ifdef FPE_FLTOVF
469 case FPE_FLTOVF:
470 rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
471 break;
472 #endif
473 #ifdef FPE_FLTUND
474 case FPE_FLTUND:
475 rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
476 break;
477 #endif
478 #ifdef FPE_FLTRES
479 case FPE_FLTRES:
480 rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
481 break;
482 #endif
483 #ifdef FPE_FLTINV
484 case FPE_FLTINV:
485 #endif
486 default:
487 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
488 break;
489 }
490 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
491 rec.ExceptionRecord = NULL;
492 rec.ExceptionAddress = addr;
493 rec.NumberParameters = 0;
494 __regs_RtlRaiseException( &rec, context );
495 }
496
497 /**********************************************************************
498 * segv_handler
499 *
500 * Handler for SIGSEGV and related errors.
501 */
502 static HANDLER_DEF(segv_handler)
503 {
504 CONTEXT context;
505 save_context( &context, HANDLER_CONTEXT );
506 do_segv( &context, __siginfo->si_signo, __siginfo->si_errno, __siginfo->si_code, __siginfo->si_addr );
507 restore_context( &context, HANDLER_CONTEXT );
508 }
509
510 /**********************************************************************
511 * trap_handler
512 *
513 * Handler for SIGTRAP.
514 */
515 static HANDLER_DEF(trap_handler)
516 {
517 CONTEXT context;
518 save_context( &context, HANDLER_CONTEXT );
519 do_trap( &context, __siginfo->si_code, __siginfo->si_addr );
520 restore_context( &context, HANDLER_CONTEXT );
521 }
522
523 /**********************************************************************
524 * fpe_handler
525 *
526 * Handler for SIGFPE.
527 */
528 static HANDLER_DEF(fpe_handler)
529 {
530 CONTEXT context;
531 save_fpu( &context, HANDLER_CONTEXT );
532 save_context( &context, HANDLER_CONTEXT );
533 do_fpe( &context, __siginfo->si_code, __siginfo->si_addr );
534 restore_context( &context, HANDLER_CONTEXT );
535 restore_fpu( &context, HANDLER_CONTEXT );
536 }
537
538 /**********************************************************************
539 * int_handler
540 *
541 * Handler for SIGINT.
542 */
543 static HANDLER_DEF(int_handler)
544 {
545 if (!dispatch_signal(SIGINT))
546 {
547 EXCEPTION_RECORD rec;
548 CONTEXT context;
549
550 save_context( &context, HANDLER_CONTEXT );
551 rec.ExceptionCode = CONTROL_C_EXIT;
552 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
553 rec.ExceptionRecord = NULL;
554 rec.ExceptionAddress = (LPVOID)context.Iar;
555 rec.NumberParameters = 0;
556 __regs_RtlRaiseException( &rec, &context );
557 restore_context( &context, HANDLER_CONTEXT );
558 }
559 }
560
561
562 /**********************************************************************
563 * abrt_handler
564 *
565 * Handler for SIGABRT.
566 */
567 static HANDLER_DEF(abrt_handler)
568 {
569 EXCEPTION_RECORD rec;
570 CONTEXT context;
571
572 save_context( &context, HANDLER_CONTEXT );
573 rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
574 rec.ExceptionFlags = EH_NONCONTINUABLE;
575 rec.ExceptionRecord = NULL;
576 rec.ExceptionAddress = (LPVOID)context.Iar;
577 rec.NumberParameters = 0;
578 __regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
579 restore_context( &context, HANDLER_CONTEXT );
580 }
581
582
583 /**********************************************************************
584 * quit_handler
585 *
586 * Handler for SIGQUIT.
587 */
588 static HANDLER_DEF(quit_handler)
589 {
590 server_abort_thread(0);
591 }
592
593
594 /**********************************************************************
595 * usr1_handler
596 *
597 * Handler for SIGUSR1, used to signal a thread that it got suspended.
598 */
599 static HANDLER_DEF(usr1_handler)
600 {
601 CONTEXT context;
602
603 save_context( &context, HANDLER_CONTEXT );
604 wait_suspend( &context );
605 restore_context( &context, HANDLER_CONTEXT );
606 }
607
608
609 /**********************************************************************
610 * get_signal_stack_total_size
611 *
612 * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
613 * Must be a power of two.
614 */
615 size_t get_signal_stack_total_size(void)
616 {
617 assert( sizeof(TEB) <= getpagesize() );
618 return getpagesize(); /* this is just for the TEB, we don't need a signal stack */
619 }
620
621
622 /***********************************************************************
623 * set_handler
624 *
625 * Set a signal handler
626 */
627 static int set_handler( int sig, void (*func)() )
628 {
629 struct sigaction sig_act;
630
631 sig_act.sa_sigaction = func;
632 sig_act.sa_mask = server_block_set;
633 sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
634 return sigaction( sig, &sig_act, NULL );
635 }
636
637
638 /***********************************************************************
639 * __wine_set_signal_handler (NTDLL.@)
640 */
641 int __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
642 {
643 if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
644 if (handlers[sig] != NULL) return -2;
645 handlers[sig] = wsh;
646 return 0;
647 }
648
649
650 /**********************************************************************
651 * signal_init_thread
652 */
653 void signal_init_thread(void)
654 {
655 }
656
657 /**********************************************************************
658 * signal_init_process
659 */
660 void signal_init_process(void)
661 {
662 if (set_handler( SIGINT, (void (*)())int_handler ) == -1) goto error;
663 if (set_handler( SIGFPE, (void (*)())fpe_handler ) == -1) goto error;
664 if (set_handler( SIGSEGV, (void (*)())segv_handler ) == -1) goto error;
665 if (set_handler( SIGILL, (void (*)())segv_handler ) == -1) goto error;
666 if (set_handler( SIGABRT, (void (*)())abrt_handler ) == -1) goto error;
667 if (set_handler( SIGQUIT, (void (*)())quit_handler ) == -1) goto error;
668 if (set_handler( SIGUSR1, (void (*)())usr1_handler ) == -1) goto error;
669 #ifdef SIGBUS
670 if (set_handler( SIGBUS, (void (*)())segv_handler ) == -1) goto error;
671 #endif
672 #ifdef SIGTRAP
673 if (set_handler( SIGTRAP, (void (*)())trap_handler ) == -1) goto error;
674 #endif
675 signal_init_thread();
676 return;
677
678 error:
679 perror("sigaction");
680 exit(1);
681 }
682
683
684 /**********************************************************************
685 * __wine_enter_vm86 (NTDLL.@)
686 */
687 void __wine_enter_vm86( CONTEXT *context )
688 {
689 MESSAGE("vm86 mode not supported on this platform\n");
690 }
691
692 /**********************************************************************
693 * DbgBreakPoint (NTDLL.@)
694 */
695 void WINAPI DbgBreakPoint(void)
696 {
697 kill(getpid(), SIGTRAP);
698 }
699
700 /**********************************************************************
701 * DbgUserBreakPoint (NTDLL.@)
702 */
703 void WINAPI DbgUserBreakPoint(void)
704 {
705 kill(getpid(), SIGTRAP);
706 }
707
708 #endif /* __powerpc__ */
709
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.