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