git.oblomov.eu Git - wine/blob - dlls/ntdll/signal_arm.c

   1 /*
   2  * ARM signal handling routines
   3  *
   4  * Copyright 2002 Marcus Meissner, SuSE Linux AG
   5  * Copyright 2010, 2011 André Hentschel
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #ifdef __arm__
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <assert.h>
  28 #include <signal.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #ifdef HAVE_UNISTD_H
  33 # include <unistd.h>
  34 #endif
  35
  36 #ifdef HAVE_SYS_PARAM_H
  37 # include <sys/param.h>
  38 #endif
  39 #ifdef HAVE_SYSCALL_H
  40 # include <syscall.h>
  41 #else
  42 # ifdef HAVE_SYS_SYSCALL_H
  43 #  include <sys/syscall.h>
  44 # endif
  45 #endif
  46 #ifdef HAVE_SYS_SIGNAL_H
  47 # include <sys/signal.h>
  48 #endif
  49
  50 #include "ntstatus.h"
  51 #define WIN32_NO_STATUS
  52 #include "windef.h"
  53 #include "winternl.h"
  54 #include "wine/library.h"
  55 #include "wine/exception.h"
  56 #include "ntdll_misc.h"
  57 #include "wine/debug.h"
  58 #include "winnt.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  61
  62 static pthread_key_t teb_key;
  63
  64 /***********************************************************************
  65  * signal context platform-specific definitions
  66  */
  67 #ifdef linux
  68
  69 typedef ucontext_t SIGCONTEXT;
  70
  71 /* All Registers access - only for local access */
  72 # define REG_sig(reg_name, context) ((context)->uc_mcontext.reg_name)
  73 # define REGn_sig(reg_num, context) ((context)->uc_mcontext.arm_r##reg_num)
  74
  75 /* Special Registers access  */
  76 # define SP_sig(context)            REG_sig(arm_sp, context)    /* Stack pointer */
  77 # define LR_sig(context)            REG_sig(arm_lr, context)    /* Link register */
  78 # define PC_sig(context)            REG_sig(arm_pc, context)    /* Program counter */
  79 # define CPSR_sig(context)          REG_sig(arm_cpsr, context)  /* Current State Register */
  80 # define IP_sig(context)            REG_sig(arm_ip, context)    /* Intra-Procedure-call scratch register */
  81 # define FP_sig(context)            REG_sig(arm_fp, context)    /* Frame pointer */
  82
  83 /* Exceptions */
  84 # define ERROR_sig(context)         REG_sig(error_code, context)
  85 # define FAULT_sig(context)         REG_sig(fault_address, context)
  86 # define TRAP_sig(context)          REG_sig(trap_no, context)
  87
  88 #endif /* linux */
  89
  90 enum arm_trap_code
  91 {
  92     TRAP_ARM_UNKNOWN    = -1,  /* Unknown fault (TRAP_sig not defined) */
  93     TRAP_ARM_PRIVINFLT  =  6,  /* Invalid opcode exception */
  94     TRAP_ARM_PAGEFLT    = 14,  /* Page fault */
  95     TRAP_ARM_ALIGNFLT   = 17,  /* Alignment check exception */
  96 };
  97
  98 typedef void (WINAPI *raise_func)( EXCEPTION_RECORD *rec, CONTEXT *context );
  99 typedef int (*wine_signal_handler)(unsigned int sig);
 100
 101 static wine_signal_handler handlers[256];
 102
 103 /***********************************************************************
 104  *           dispatch_signal
 105  */
 106 static inline int dispatch_signal(unsigned int sig)
 107 {
 108     if (handlers[sig] == NULL) return 0;
 109     return handlers[sig](sig);
 110 }
 111
 112 /*******************************************************************
 113  *         is_valid_frame
 114  */
 115 static inline BOOL is_valid_frame( void *frame )
 116 {
 117     if ((ULONG_PTR)frame & 3) return FALSE;
 118     return (frame >= NtCurrentTeb()->Tib.StackLimit &&
 119             (void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
 120 }
 121
 122 /***********************************************************************
 123  *           save_context
 124  *
 125  * Set the register values from a sigcontext.
 126  */
 127 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
 128 {
 129 #define C(x) context->R##x = REGn_sig(x,sigcontext)
 130     /* Save normal registers */
 131     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
 132 #undef C
 133
 134     context->ContextFlags = CONTEXT_FULL;
 135     context->Sp   = SP_sig(sigcontext);   /* Stack pointer */
 136     context->Lr   = LR_sig(sigcontext);   /* Link register */
 137     context->Pc   = PC_sig(sigcontext);   /* Program Counter */
 138     context->Cpsr = CPSR_sig(sigcontext); /* Current State Register */
 139     context->Ip   = IP_sig(sigcontext);   /* Intra-Procedure-call scratch register */
 140     context->Fp   = FP_sig(sigcontext);   /* Frame pointer */
 141 }
 142
 143
 144 /***********************************************************************
 145  *           restore_context
 146  *
 147  * Build a sigcontext from the register values.
 148  */
 149 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
 150 {
 151 #define C(x)  REGn_sig(x,sigcontext) = context->R##x
 152     /* Restore normal registers */
 153     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
 154 #undef C
 155
 156     SP_sig(sigcontext)   = context->Sp;   /* Stack pointer */
 157     LR_sig(sigcontext)   = context->Lr ;  /* Link register */
 158     PC_sig(sigcontext)   = context->Pc;   /* Program Counter */
 159     CPSR_sig(sigcontext) = context->Cpsr; /* Current State Register */
 160     IP_sig(sigcontext)   = context->Ip;   /* Intra-Procedure-call scratch register */
 161     FP_sig(sigcontext)   = context->Fp;   /* Frame pointer */
 162 }
 163
 164
 165 /***********************************************************************
 166  *           save_fpu
 167  *
 168  * Set the FPU context from a sigcontext.
 169  */
 170 static inline void save_fpu( CONTEXT *context, const ucontext_t *sigcontext )
 171 {
 172     FIXME("not implemented\n");
 173 }
 174
 175
 176 /***********************************************************************
 177  *           restore_fpu
 178  *
 179  * Restore the FPU context to a sigcontext.
 180  */
 181 static inline void restore_fpu( CONTEXT *context, const ucontext_t *sigcontext )
 182 {
 183     FIXME("not implemented\n");
 184 }
 185
 186
 187 /***********************************************************************
 188  *              RtlCaptureContext (NTDLL.@)
 189  */
 190 /* FIXME: Use the Stack instead of the actual register values */
 191 __ASM_STDCALL_FUNC( RtlCaptureContext, 4,
 192                     ".arm\n\t"
 193                     "stmfd SP!, {r1}\n\t"
 194                     "mov r1, #0x40\n\t"     /* CONTEXT_ARM */
 195                     "add r1, r1, #0x3\n\t"  /* CONTEXT_FULL */
 196                     "str r1, [r0]\n\t"      /* context->ContextFlags */
 197                     "ldmfd SP!, {r1}\n\t"
 198                     "str r0, [r0, #0x4]\n\t"   /* context->R0 */
 199                     "str r1, [r0, #0x8]\n\t"   /* context->R1 */
 200                     "str r2, [r0, #0xc]\n\t"   /* context->R2 */
 201                     "str r3, [r0, #0x10]\n\t"  /* context->R3 */
 202                     "str r4, [r0, #0x14]\n\t"  /* context->R4 */
 203                     "str r5, [r0, #0x18]\n\t"  /* context->R5 */
 204                     "str r6, [r0, #0x1c]\n\t"  /* context->R6 */
 205                     "str r7, [r0, #0x20]\n\t"  /* context->R7 */
 206                     "str r8, [r0, #0x24]\n\t"  /* context->R8 */
 207                     "str r9, [r0, #0x28]\n\t"  /* context->R9 */
 208                     "str r10, [r0, #0x2c]\n\t" /* context->R10 */
 209                     "str r11, [r0, #0x30]\n\t" /* context->Fp */
 210                     "str IP, [r0, #0x34]\n\t"  /* context->Ip */
 211                     "str SP, [r0, #0x38]\n\t"  /* context->Sp */
 212                     "str LR, [r0, #0x3c]\n\t"  /* context->Lr */
 213                     "str LR, [r0, #0x40]\n\t"  /* context->Pc */
 214                     "mrs r1, CPSR\n\t"
 215                     "str r1, [r0, #0x44]\n\t"  /* context->Cpsr */
 216                     "mov PC, LR\n"
 217                     )
 218
 219
 220 /***********************************************************************
 221  *           set_cpu_context
 222  *
 223  * Set the new CPU context.
 224  */
 225 /* FIXME: What about the CPSR? */
 226 __ASM_GLOBAL_FUNC( set_cpu_context,
 227                    "mov IP, r0\n\t"
 228                    "ldr r0,  [IP, #0x4]\n\t"  /* context->R0 */
 229                    "ldr r1,  [IP, #0x8]\n\t"  /* context->R1 */
 230                    "ldr r2,  [IP, #0xc]\n\t"  /* context->R2 */
 231                    "ldr r3,  [IP, #0x10]\n\t" /* context->R3 */
 232                    "ldr r4,  [IP, #0x14]\n\t" /* context->R4 */
 233                    "ldr r5,  [IP, #0x18]\n\t" /* context->R5 */
 234                    "ldr r6,  [IP, #0x1c]\n\t" /* context->R6 */
 235                    "ldr r7,  [IP, #0x20]\n\t" /* context->R7 */
 236                    "ldr r8,  [IP, #0x24]\n\t" /* context->R8 */
 237                    "ldr r9,  [IP, #0x28]\n\t" /* context->R9 */
 238                    "ldr r10, [IP, #0x2c]\n\t" /* context->R10 */
 239                    "ldr r11, [IP, #0x30]\n\t" /* context->Fp */
 240                    "ldr SP,  [IP, #0x38]\n\t" /* context->Sp */
 241                    "ldr LR,  [IP, #0x3c]\n\t" /* context->Lr */
 242                    "ldr PC,  [IP, #0x40]\n\t" /* context->Pc */
 243                    )
 244
 245
 246 /***********************************************************************
 247  *           copy_context
 248  *
 249  * Copy a register context according to the flags.
 250  */
 251 void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
 252 {
 253     flags &= ~CONTEXT_ARM;  /* get rid of CPU id */
 254     if (flags & CONTEXT_CONTROL)
 255     {
 256         to->Sp      = from->Sp;
 257         to->Lr      = from->Lr;
 258         to->Pc      = from->Pc;
 259         to->Cpsr    = from->Cpsr;
 260     }
 261     if (flags & CONTEXT_INTEGER)
 262     {
 263         to->R0  = from->R0;
 264         to->R1  = from->R1;
 265         to->R2  = from->R2;
 266         to->R3  = from->R3;
 267         to->R4  = from->R4;
 268         to->R5  = from->R5;
 269         to->R6  = from->R6;
 270         to->R7  = from->R7;
 271         to->R8  = from->R8;
 272         to->R9  = from->R9;
 273         to->R10 = from->R10;
 274         to->Ip  = from->Ip;
 275         to->Fp  = from->Fp;
 276     }
 277 }
 278
 279
 280 /***********************************************************************
 281  *           context_to_server
 282  *
 283  * Convert a register context to the server format.
 284  */
 285 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
 286 {
 287     DWORD flags = from->ContextFlags & ~CONTEXT_ARM;  /* get rid of CPU id */
 288
 289     memset( to, 0, sizeof(*to) );
 290     to->cpu = CPU_ARM;
 291
 292     if (flags & CONTEXT_CONTROL)
 293     {
 294         to->flags |= SERVER_CTX_CONTROL;
 295         to->ctl.arm_regs.sp   = from->Sp;
 296         to->ctl.arm_regs.lr   = from->Lr;
 297         to->ctl.arm_regs.pc   = from->Pc;
 298         to->ctl.arm_regs.cpsr = from->Cpsr;
 299     }
 300     if (flags & CONTEXT_INTEGER)
 301     {
 302         to->flags |= SERVER_CTX_INTEGER;
 303         to->integer.arm_regs.r[0]  = from->R0;
 304         to->integer.arm_regs.r[1]  = from->R1;
 305         to->integer.arm_regs.r[2]  = from->R2;
 306         to->integer.arm_regs.r[3]  = from->R3;
 307         to->integer.arm_regs.r[4]  = from->R4;
 308         to->integer.arm_regs.r[5]  = from->R5;
 309         to->integer.arm_regs.r[6]  = from->R6;
 310         to->integer.arm_regs.r[7]  = from->R7;
 311         to->integer.arm_regs.r[8]  = from->R8;
 312         to->integer.arm_regs.r[9]  = from->R9;
 313         to->integer.arm_regs.r[10] = from->R10;
 314         to->integer.arm_regs.r[11] = from->Fp;
 315         to->integer.arm_regs.r[12] = from->Ip;
 316     }
 317     return STATUS_SUCCESS;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           context_from_server
 323  *
 324  * Convert a register context from the server format.
 325  */
 326 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
 327 {
 328     if (from->cpu != CPU_ARM) return STATUS_INVALID_PARAMETER;
 329
 330     to->ContextFlags = CONTEXT_ARM;
 331     if (from->flags & SERVER_CTX_CONTROL)
 332     {
 333         to->ContextFlags |= CONTEXT_CONTROL;
 334         to->Sp   = from->ctl.arm_regs.sp;
 335         to->Lr   = from->ctl.arm_regs.lr;
 336         to->Pc   = from->ctl.arm_regs.pc;
 337         to->Cpsr = from->ctl.arm_regs.cpsr;
 338     }
 339     if (from->flags & SERVER_CTX_INTEGER)
 340     {
 341         to->ContextFlags |= CONTEXT_INTEGER;
 342         to->R0  = from->integer.arm_regs.r[0];
 343         to->R1  = from->integer.arm_regs.r[1];
 344         to->R2  = from->integer.arm_regs.r[2];
 345         to->R3  = from->integer.arm_regs.r[3];
 346         to->R4  = from->integer.arm_regs.r[4];
 347         to->R5  = from->integer.arm_regs.r[5];
 348         to->R6  = from->integer.arm_regs.r[6];
 349         to->R7  = from->integer.arm_regs.r[7];
 350         to->R8  = from->integer.arm_regs.r[8];
 351         to->R9  = from->integer.arm_regs.r[9];
 352         to->R10 = from->integer.arm_regs.r[10];
 353         to->Fp  = from->integer.arm_regs.r[11];
 354         to->Ip  = from->integer.arm_regs.r[12];
 355      }
 356     return STATUS_SUCCESS;
 357 }
 358
 359 extern void raise_func_trampoline_thumb( EXCEPTION_RECORD *rec, CONTEXT *context, raise_func func );
 360 __ASM_GLOBAL_FUNC( raise_func_trampoline_thumb,
 361                    ".thumb\n\t"
 362                    "blx r2\n\t"
 363                    "bkpt")
 364
 365 extern void raise_func_trampoline_arm( EXCEPTION_RECORD *rec, CONTEXT *context, raise_func func );
 366 __ASM_GLOBAL_FUNC( raise_func_trampoline_arm,
 367                    ".arm\n\t"
 368                    "blx r2\n\t"
 369                    "bkpt")
 370
 371 /***********************************************************************
 372  *           setup_exception_record
 373  *
 374  * Setup the exception record and context on the thread stack.
 375  */
 376 static EXCEPTION_RECORD *setup_exception( SIGCONTEXT *sigcontext, raise_func func )
 377 {
 378     struct stack_layout
 379     {
 380         CONTEXT           context;
 381         EXCEPTION_RECORD  rec;
 382     } *stack;
 383     DWORD exception_code = 0;
 384
 385     stack = (struct stack_layout *)(SP_sig(sigcontext) & ~3);
 386     stack--;  /* push the stack_layout structure */
 387
 388     stack->rec.ExceptionRecord  = NULL;
 389     stack->rec.ExceptionCode    = exception_code;
 390     stack->rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 391     stack->rec.ExceptionAddress = (LPVOID)PC_sig(sigcontext);
 392     stack->rec.NumberParameters = 0;
 393
 394     save_context( &stack->context, sigcontext );
 395
 396     /* now modify the sigcontext to return to the raise function */
 397     SP_sig(sigcontext) = (DWORD)stack;
 398     if (CPSR_sig(sigcontext) & 0x20)
 399         PC_sig(sigcontext) = (DWORD)raise_func_trampoline_thumb;
 400     else
 401         PC_sig(sigcontext) = (DWORD)raise_func_trampoline_arm;
 402     REGn_sig(0, sigcontext) = (DWORD)&stack->rec;  /* first arg for raise_func */
 403     REGn_sig(1, sigcontext) = (DWORD)&stack->context; /* second arg for raise_func */
 404     REGn_sig(2, sigcontext) = (DWORD)func; /* the raise_func as third arg for the trampoline */
 405
 406
 407     return &stack->rec;
 408 }
 409
 410 /**********************************************************************
 411  *              raise_segv_exception
 412  */
 413 static void WINAPI raise_segv_exception( EXCEPTION_RECORD *rec, CONTEXT *context )
 414 {
 415     NTSTATUS status;
 416
 417     switch(rec->ExceptionCode)
 418     {
 419     case EXCEPTION_ACCESS_VIOLATION:
 420         if (rec->NumberParameters == 2)
 421         {
 422             if (!(rec->ExceptionCode = virtual_handle_fault( (void *)rec->ExceptionInformation[1],
 423                                                              rec->ExceptionInformation[0] )))
 424                 goto done;
 425         }
 426         break;
 427     }
 428     status = NtRaiseException( rec, context, TRUE );
 429     if (status) raise_status( status, rec );
 430 done:
 431     set_cpu_context( context );
 432 }
 433
 434 /**********************************************************************
 435  *           call_stack_handlers
 436  *
 437  * Call the stack handlers chain.
 438  */
 439 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 440 {
 441     EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
 442     DWORD res;
 443
 444     frame = NtCurrentTeb()->Tib.ExceptionList;
 445     nested_frame = NULL;
 446     while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
 447     {
 448         /* Check frame address */
 449         if (!is_valid_frame( frame ))
 450         {
 451             rec->ExceptionFlags |= EH_STACK_INVALID;
 452             break;
 453         }
 454
 455         /* Call handler */
 456         TRACE( "calling handler at %p code=%x flags=%x\n",
 457                frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
 458         res = frame->Handler( rec, frame, context, &dispatch );
 459         TRACE( "handler at %p returned %x\n", frame->Handler, res );
 460
 461         if (frame == nested_frame)
 462         {
 463             /* no longer nested */
 464             nested_frame = NULL;
 465             rec->ExceptionFlags &= ~EH_NESTED_CALL;
 466         }
 467
 468         switch(res)
 469         {
 470         case ExceptionContinueExecution:
 471             if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
 472             return STATUS_NONCONTINUABLE_EXCEPTION;
 473         case ExceptionContinueSearch:
 474             break;
 475         case ExceptionNestedException:
 476             if (nested_frame < dispatch) nested_frame = dispatch;
 477             rec->ExceptionFlags |= EH_NESTED_CALL;
 478             break;
 479         default:
 480             return STATUS_INVALID_DISPOSITION;
 481         }
 482         frame = frame->Prev;
 483     }
 484     return STATUS_UNHANDLED_EXCEPTION;
 485 }
 486
 487
 488 /*******************************************************************
 489  *              raise_exception
 490  *
 491  * Implementation of NtRaiseException.
 492  */
 493 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
 494 {
 495     NTSTATUS status;
 496
 497     if (first_chance)
 498     {
 499         DWORD c;
 500
 501         for (c = 0; c < rec->NumberParameters; c++)
 502             TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
 503         if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
 504         {
 505             if (rec->ExceptionInformation[1] >> 16)
 506                 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
 507                          rec->ExceptionAddress,
 508                          (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
 509             else
 510                 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
 511                          rec->ExceptionAddress,
 512                          (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
 513         }
 514         else
 515         {
 516             TRACE(" Pc:%04x Sp:%04x Lr:%04x Cpsr:%04x r0:%04x r1:%04x r2:%04x r3:%04x\n",
 517                   context->Pc, context->Sp, context->Lr, context->Cpsr,
 518                   context->R0, context->R1, context->R2, context->R3);
 519             TRACE(" r4:%04x r5:%04x  r6:%04x  r7:%04x r8:%04x r9:%04x r10:%04x Fp:%04x Ip:%04x\n",
 520                   context->R4, context->R5, context->R6, context->R7, context->R8,
 521                   context->R9, context->R10, context->Fp, context->Ip );
 522         }
 523
 524         status = send_debug_event( rec, TRUE, context );
 525         if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
 526             return STATUS_SUCCESS;
 527
 528         if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
 529             return STATUS_SUCCESS;
 530
 531         if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
 532             return status;
 533     }
 534
 535     /* last chance exception */
 536
 537     status = send_debug_event( rec, FALSE, context );
 538     if (status != DBG_CONTINUE)
 539     {
 540         if (rec->ExceptionFlags & EH_STACK_INVALID)
 541             ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
 542         else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
 543             ERR("Process attempted to continue execution after noncontinuable exception.\n");
 544         else
 545             ERR("Unhandled exception code %x flags %x addr %p\n",
 546                 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
 547         NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
 548     }
 549     return STATUS_SUCCESS;
 550 }
 551
 552
 553 /**********************************************************************
 554  *              segv_handler
 555  *
 556  * Handler for SIGSEGV and related errors.
 557  */
 558 static void segv_handler( int signal, siginfo_t *info, void *ucontext )
 559 {
 560     EXCEPTION_RECORD *rec;
 561     SIGCONTEXT *context = ucontext;
 562
 563     /* check for page fault inside the thread stack */
 564     if (TRAP_sig(context) == TRAP_ARM_PAGEFLT &&
 565         (char *)info->si_addr >= (char *)NtCurrentTeb()->DeallocationStack &&
 566         (char *)info->si_addr < (char *)NtCurrentTeb()->Tib.StackBase &&
 567         virtual_handle_stack_fault( info->si_addr ))
 568     {
 569         /* check if this was the last guard page */
 570         if ((char *)info->si_addr < (char *)NtCurrentTeb()->DeallocationStack + 2*4096)
 571         {
 572             rec = setup_exception( context, raise_segv_exception );
 573             rec->ExceptionCode = EXCEPTION_STACK_OVERFLOW;
 574         }
 575         return;
 576     }
 577
 578     rec = setup_exception( context, raise_segv_exception );
 579     if (rec->ExceptionCode == EXCEPTION_STACK_OVERFLOW) return;
 580
 581     switch(TRAP_sig(context))
 582     {
 583     case TRAP_ARM_PRIVINFLT:   /* Invalid opcode exception */
 584         rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 585         break;
 586     case TRAP_ARM_PAGEFLT:  /* Page fault */
 587         rec->ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
 588         rec->NumberParameters = 2;
 589         rec->ExceptionInformation[0] = (ERROR_sig(context) & 0x800) != 0;
 590         rec->ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
 591         break;
 592     case TRAP_ARM_ALIGNFLT:  /* Alignment check exception */
 593         rec->ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
 594         break;
 595     default:
 596         ERR("Got unexpected trap %ld\n", TRAP_sig(context));
 597         rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 598         break;
 599     }
 600 }
 601
 602 /**********************************************************************
 603  *              trap_handler
 604  *
 605  * Handler for SIGTRAP.
 606  */
 607 static void trap_handler( int signal, siginfo_t *info, void *ucontext )
 608 {
 609     EXCEPTION_RECORD rec;
 610     CONTEXT context;
 611     NTSTATUS status;
 612
 613     switch ( info->si_code )
 614     {
 615     case TRAP_TRACE:
 616         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
 617         break;
 618     case TRAP_BRKPT:
 619     default:
 620         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
 621         break;
 622     }
 623
 624     save_context( &context, ucontext );
 625     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 626     rec.ExceptionRecord  = NULL;
 627     rec.ExceptionAddress = (LPVOID)context.Pc;
 628     rec.NumberParameters = 0;
 629     status = raise_exception( &rec, &context, TRUE );
 630     if (status) raise_status( status, &rec );
 631     restore_context( &context, ucontext );
 632 }
 633
 634 /**********************************************************************
 635  *              fpe_handler
 636  *
 637  * Handler for SIGFPE.
 638  */
 639 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 640 {
 641     EXCEPTION_RECORD rec;
 642     CONTEXT context;
 643     NTSTATUS status;
 644
 645     save_fpu( &context, sigcontext );
 646     save_context( &context, sigcontext );
 647
 648     switch (siginfo->si_code & 0xffff )
 649     {
 650 #ifdef FPE_FLTSUB
 651     case FPE_FLTSUB:
 652         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
 653         break;
 654 #endif
 655 #ifdef FPE_INTDIV
 656     case FPE_INTDIV:
 657         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
 658         break;
 659 #endif
 660 #ifdef FPE_INTOVF
 661     case FPE_INTOVF:
 662         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
 663         break;
 664 #endif
 665 #ifdef FPE_FLTDIV
 666     case FPE_FLTDIV:
 667         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
 668         break;
 669 #endif
 670 #ifdef FPE_FLTOVF
 671     case FPE_FLTOVF:
 672         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
 673         break;
 674 #endif
 675 #ifdef FPE_FLTUND
 676     case FPE_FLTUND:
 677         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
 678         break;
 679 #endif
 680 #ifdef FPE_FLTRES
 681     case FPE_FLTRES:
 682         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
 683         break;
 684 #endif
 685 #ifdef FPE_FLTINV
 686     case FPE_FLTINV:
 687 #endif
 688     default:
 689         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
 690         break;
 691     }
 692     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 693     rec.ExceptionRecord  = NULL;
 694     rec.ExceptionAddress = (LPVOID)context.Pc;
 695     rec.NumberParameters = 0;
 696     status = raise_exception( &rec, &context, TRUE );
 697     if (status) raise_status( status, &rec );
 698
 699     restore_context( &context, sigcontext );
 700     restore_fpu( &context, sigcontext );
 701 }
 702
 703 /**********************************************************************
 704  *              int_handler
 705  *
 706  * Handler for SIGINT.
 707  */
 708 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 709 {
 710     if (!dispatch_signal(SIGINT))
 711     {
 712         EXCEPTION_RECORD rec;
 713         CONTEXT context;
 714         NTSTATUS status;
 715
 716         save_context( &context, sigcontext );
 717         rec.ExceptionCode    = CONTROL_C_EXIT;
 718         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 719         rec.ExceptionRecord  = NULL;
 720         rec.ExceptionAddress = (LPVOID)context.Pc;
 721         rec.NumberParameters = 0;
 722         status = raise_exception( &rec, &context, TRUE );
 723         if (status) raise_status( status, &rec );
 724         restore_context( &context, sigcontext );
 725     }
 726 }
 727
 728
 729 /**********************************************************************
 730  *              abrt_handler
 731  *
 732  * Handler for SIGABRT.
 733  */
 734 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 735 {
 736     EXCEPTION_RECORD rec;
 737     CONTEXT context;
 738     NTSTATUS status;
 739
 740     save_context( &context, sigcontext );
 741     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
 742     rec.ExceptionFlags   = EH_NONCONTINUABLE;
 743     rec.ExceptionRecord  = NULL;
 744     rec.ExceptionAddress = (LPVOID)context.Pc;
 745     rec.NumberParameters = 0;
 746     status = raise_exception( &rec, &context, TRUE );
 747     if (status) raise_status( status, &rec );
 748     restore_context( &context, sigcontext );
 749 }
 750
 751
 752 /**********************************************************************
 753  *              quit_handler
 754  *
 755  * Handler for SIGQUIT.
 756  */
 757 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 758 {
 759     abort_thread(0);
 760 }
 761
 762
 763 /**********************************************************************
 764  *              usr1_handler
 765  *
 766  * Handler for SIGUSR1, used to signal a thread that it got suspended.
 767  */
 768 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 769 {
 770     CONTEXT context;
 771
 772     save_context( &context, sigcontext );
 773     wait_suspend( &context );
 774     restore_context( &context, sigcontext );
 775 }
 776
 777
 778 /***********************************************************************
 779  *           __wine_set_signal_handler   (NTDLL.@)
 780  */
 781 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
 782 {
 783     if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
 784     if (handlers[sig] != NULL) return -2;
 785     handlers[sig] = wsh;
 786     return 0;
 787 }
 788
 789
 790 /**********************************************************************
 791  *             signal_alloc_thread
 792  */
 793 NTSTATUS signal_alloc_thread( TEB **teb )
 794 {
 795     static size_t sigstack_zero_bits;
 796     SIZE_T size;
 797     NTSTATUS status;
 798
 799     if (!sigstack_zero_bits)
 800     {
 801         size_t min_size = page_size;
 802         /* find the first power of two not smaller than min_size */
 803         while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
 804         assert( sizeof(TEB) <= min_size );
 805     }
 806
 807     size = 1 << sigstack_zero_bits;
 808     *teb = NULL;
 809     if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
 810                                             &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
 811     {
 812         (*teb)->Tib.Self = &(*teb)->Tib;
 813         (*teb)->Tib.ExceptionList = (void *)~0UL;
 814     }
 815     return status;
 816 }
 817
 818
 819 /**********************************************************************
 820  *             signal_free_thread
 821  */
 822 void signal_free_thread( TEB *teb )
 823 {
 824     SIZE_T size;
 825
 826     if (teb->DeallocationStack)
 827     {
 828         size = 0;
 829         NtFreeVirtualMemory( GetCurrentProcess(), &teb->DeallocationStack, &size, MEM_RELEASE );
 830     }
 831     size = 0;
 832     NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
 833 }
 834
 835
 836 /**********************************************************************
 837  *              signal_init_thread
 838  */
 839 void signal_init_thread( TEB *teb )
 840 {
 841     static int init_done;
 842
 843     if (!init_done)
 844     {
 845         pthread_key_create( &teb_key, NULL );
 846         init_done = 1;
 847     }
 848     pthread_setspecific( teb_key, teb );
 849 }
 850
 851
 852 /**********************************************************************
 853  *              signal_init_process
 854  */
 855 void signal_init_process(void)
 856 {
 857     struct sigaction sig_act;
 858
 859     sig_act.sa_mask = server_block_set;
 860     sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
 861
 862     sig_act.sa_sigaction = int_handler;
 863     if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
 864     sig_act.sa_sigaction = fpe_handler;
 865     if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
 866     sig_act.sa_sigaction = abrt_handler;
 867     if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
 868     sig_act.sa_sigaction = quit_handler;
 869     if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
 870     sig_act.sa_sigaction = usr1_handler;
 871     if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
 872
 873     sig_act.sa_sigaction = segv_handler;
 874     if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
 875     if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
 876 #ifdef SIGBUS
 877     if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
 878 #endif
 879
 880 #ifdef SIGTRAP
 881     sig_act.sa_sigaction = trap_handler;
 882     if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
 883 #endif
 884     return;
 885
 886  error:
 887     perror("sigaction");
 888     exit(1);
 889 }
 890
 891
 892 /**********************************************************************
 893  *              __wine_enter_vm86   (NTDLL.@)
 894  */
 895 void __wine_enter_vm86( CONTEXT *context )
 896 {
 897     MESSAGE("vm86 mode not supported on this platform\n");
 898 }
 899
 900 /***********************************************************************
 901  *            RtlUnwind  (NTDLL.@)
 902  */
 903 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
 904 {
 905     FIXME( "Not implemented on ARM\n" );
 906 }
 907
 908 /*******************************************************************
 909  *              NtRaiseException (NTDLL.@)
 910  */
 911 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
 912 {
 913     NTSTATUS status = raise_exception( rec, context, first_chance );
 914     if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
 915     return status;
 916 }
 917
 918 /***********************************************************************
 919  *              RtlRaiseException (NTDLL.@)
 920  */
 921 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
 922 {
 923     CONTEXT context;
 924     NTSTATUS status;
 925
 926     RtlCaptureContext( &context );
 927     rec->ExceptionAddress = (LPVOID)context.Pc;
 928     status = raise_exception( rec, &context, TRUE );
 929     if (status) raise_status( status, rec );
 930 }
 931
 932 /*************************************************************************
 933  *             RtlCaptureStackBackTrace (NTDLL.@)
 934  */
 935 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
 936 {
 937     FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
 938     return 0;
 939 }
 940
 941 /***********************************************************************
 942  *           call_thread_entry_point
 943  */
 944 void call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
 945 {
 946     __TRY
 947     {
 948         exit_thread( entry( arg ));
 949     }
 950     __EXCEPT(unhandled_exception_filter)
 951     {
 952         NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
 953     }
 954     __ENDTRY
 955     abort();  /* should not be reached */
 956 }
 957
 958 /***********************************************************************
 959  *           RtlExitUserThread  (NTDLL.@)
 960  */
 961 void WINAPI RtlExitUserThread( ULONG status )
 962 {
 963     exit_thread( status );
 964 }
 965
 966 /***********************************************************************
 967  *           abort_thread
 968  */
 969 void abort_thread( int status )
 970 {
 971     terminate_thread( status );
 972 }
 973
 974 /**********************************************************************
 975  *              DbgBreakPoint   (NTDLL.@)
 976  */
 977 void WINAPI DbgBreakPoint(void)
 978 {
 979      kill(getpid(), SIGTRAP);
 980 }
 981
 982 /**********************************************************************
 983  *              DbgUserBreakPoint   (NTDLL.@)
 984  */
 985 void WINAPI DbgUserBreakPoint(void)
 986 {
 987      kill(getpid(), SIGTRAP);
 988 }
 989
 990 /**********************************************************************
 991  *           NtCurrentTeb   (NTDLL.@)
 992  */
 993 TEB * WINAPI NtCurrentTeb(void)
 994 {
 995     return pthread_getspecific( teb_key );
 996 }
 997
 998 #endif  /* __arm__ */