dlls/ntdll/signal_arm64.c

   1 /*
   2  * ARM64 signal handling routines
   3  *
   4  * Copyright 2010-2013 André Hentschel
   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 __aarch64__
  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 #ifdef HAVE_SYS_PARAM_H
  35 # include <sys/param.h>
  36 #endif
  37 #ifdef HAVE_SYSCALL_H
  38 # include <syscall.h>
  39 #else
  40 # ifdef HAVE_SYS_SYSCALL_H
  41 #  include <sys/syscall.h>
  42 # endif
  43 #endif
  44 #ifdef HAVE_SYS_SIGNAL_H
  45 # include <sys/signal.h>
  46 #endif
  47 #ifdef HAVE_SYS_UCONTEXT_H
  48 # include <sys/ucontext.h>
  49 #endif
  50
  51 #include "ntstatus.h"
  52 #define WIN32_NO_STATUS
  53 #include "windef.h"
  54 #include "winternl.h"
  55 #include "wine/library.h"
  56 #include "wine/exception.h"
  57 #include "ntdll_misc.h"
  58 #include "wine/debug.h"
  59 #include "winnt.h"
  60
  61 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  62 WINE_DECLARE_DEBUG_CHANNEL(relay);
  63
  64 static pthread_key_t teb_key;
  65
  66 /***********************************************************************
  67  * signal context platform-specific definitions
  68  */
  69 #ifdef linux
  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.regs[reg_num])
  74
  75 /* Special Registers access  */
  76 # define SP_sig(context)            REG_sig(sp, context)    /* Stack pointer */
  77 # define PC_sig(context)            REG_sig(pc, context)    /* Program counter */
  78 # define PSTATE_sig(context)        REG_sig(pstate, context) /* Current State Register */
  79 # define FP_sig(context)            REGn_sig(29, context)    /* Frame pointer */
  80 # define LR_sig(context)            REGn_sig(30, context)    /* Link Register */
  81
  82 /* Exceptions */
  83 # define FAULT_sig(context)         REG_sig(fault_address, context)
  84
  85 #endif /* linux */
  86
  87 static const size_t teb_size = 0x2000;  /* we reserve two pages for the TEB */
  88 static size_t signal_stack_size;
  89
  90 typedef void (WINAPI *raise_func)( EXCEPTION_RECORD *rec, CONTEXT *context );
  91 typedef int (*wine_signal_handler)(unsigned int sig);
  92
  93 static wine_signal_handler handlers[256];
  94
  95 /***********************************************************************
  96  *           dispatch_signal
  97  */
  98 static inline int dispatch_signal(unsigned int sig)
  99 {
 100     if (handlers[sig] == NULL) return 0;
 101     return handlers[sig](sig);
 102 }
 103
 104 /*******************************************************************
 105  *         is_valid_frame
 106  */
 107 static inline BOOL is_valid_frame( void *frame )
 108 {
 109     if ((ULONG_PTR)frame & 3) return FALSE;
 110     return (frame >= NtCurrentTeb()->Tib.StackLimit &&
 111             (void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
 112 }
 113
 114 /***********************************************************************
 115  *           save_context
 116  *
 117  * Set the register values from a sigcontext.
 118  */
 119 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
 120 {
 121 #define C(n) context->X##n = REGn_sig(n,sigcontext)
 122     /* Save normal registers */
 123     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9);
 124     C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19);
 125     C(20); C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28);
 126 #undef C
 127
 128     context->ContextFlags = CONTEXT_FULL;
 129     context->Fp     = FP_sig(sigcontext);     /* Frame pointer */
 130     context->Lr     = LR_sig(sigcontext);     /* Link register */
 131     context->Sp     = SP_sig(sigcontext);     /* Stack pointer */
 132     context->Pc     = PC_sig(sigcontext);     /* Program Counter */
 133     context->Cpsr   = PSTATE_sig(sigcontext); /* Current State Register */
 134 }
 135
 136
 137 /***********************************************************************
 138  *           restore_context
 139  *
 140  * Build a sigcontext from the register values.
 141  */
 142 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
 143 {
 144 #define C(n)  REGn_sig(n,sigcontext) = context->X##n
 145     /* Restore normal registers */
 146     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9);
 147     C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19);
 148     C(20); C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28);
 149 #undef C
 150
 151     FP_sig(sigcontext)     = context->Fp;     /* Frame pointer */
 152     LR_sig(sigcontext)     = context->Lr;     /* Link register */
 153     SP_sig(sigcontext)     = context->Sp;     /* Stack pointer */
 154     PC_sig(sigcontext)     = context->Pc;     /* Program Counter */
 155     PSTATE_sig(sigcontext) = context->Cpsr;   /* Current State Register */
 156 }
 157
 158
 159 /***********************************************************************
 160  *           save_fpu
 161  *
 162  * Set the FPU context from a sigcontext.
 163  */
 164 static inline void save_fpu( CONTEXT *context, const ucontext_t *sigcontext )
 165 {
 166     FIXME( "Not implemented on ARM64\n" );
 167 }
 168
 169
 170 /***********************************************************************
 171  *           restore_fpu
 172  *
 173  * Restore the FPU context to a sigcontext.
 174  */
 175 static inline void restore_fpu( CONTEXT *context, const ucontext_t *sigcontext )
 176 {
 177     FIXME( "Not implemented on ARM64\n" );
 178 }
 179
 180 /***********************************************************************
 181  *              RtlCaptureContext (NTDLL.@)
 182  */
 183 /* FIXME: Use the Stack instead of the actual register values? */
 184 __ASM_STDCALL_FUNC( RtlCaptureContext, 8,
 185                     "stp x0, x1, [sp, #-32]!\n\t"
 186                     "mov w1, #0x400000\n\t"         /* CONTEXT_ARM64 */
 187                     "add w1, w1, #0x3\n\t"          /* CONTEXT_FULL */
 188                     "str w1, [x0]\n\t"              /* context->ContextFlags */ /* 32-bit, look at cpsr */
 189                     "mrs x1, NZCV\n\t"
 190                     "str w1, [x0, #0x4]\n\t"        /* context->Cpsr */
 191                     "ldp x0, x1, [sp], #32\n\t"
 192                     "str x0, [x0, #0x8]\n\t"        /* context->X0 */
 193                     "str x1, [x0, #0x10]\n\t"       /* context->X1 */
 194                     "str x2, [x0, #0x18]\n\t"       /* context->X2 */
 195                     "str x3, [x0, #0x20]\n\t"       /* context->X3 */
 196                     "str x4, [x0, #0x28]\n\t"       /* context->X4 */
 197                     "str x5, [x0, #0x30]\n\t"       /* context->X5 */
 198                     "str x6, [x0, #0x38]\n\t"       /* context->X6 */
 199                     "str x7, [x0, #0x40]\n\t"       /* context->X7 */
 200                     "str x8, [x0, #0x48]\n\t"       /* context->X8 */
 201                     "str x9, [x0, #0x50]\n\t"       /* context->X9 */
 202                     "str x10, [x0, #0x58]\n\t"      /* context->X10 */
 203                     "str x11, [x0, #0x60]\n\t"      /* context->X11 */
 204                     "str x12, [x0, #0x68]\n\t"      /* context->X12 */
 205                     "str x13, [x0, #0x70]\n\t"      /* context->X13 */
 206                     "str x14, [x0, #0x78]\n\t"      /* context->X14 */
 207                     "str x15, [x0, #0x80]\n\t"      /* context->X15 */
 208                     "str x16, [x0, #0x88]\n\t"      /* context->X16 */
 209                     "str x17, [x0, #0x90]\n\t"      /* context->X17 */
 210                     "str x18, [x0, #0x98]\n\t"      /* context->X18 */
 211                     "str x19, [x0, #0xa0]\n\t"      /* context->X19 */
 212                     "str x20, [x0, #0xa8]\n\t"      /* context->X20 */
 213                     "str x21, [x0, #0xb0]\n\t"      /* context->X21 */
 214                     "str x22, [x0, #0xb8]\n\t"      /* context->X22 */
 215                     "str x23, [x0, #0xc0]\n\t"      /* context->X23 */
 216                     "str x24, [x0, #0xc8]\n\t"      /* context->X24 */
 217                     "str x25, [x0, #0xd0]\n\t"      /* context->X25 */
 218                     "str x26, [x0, #0xd8]\n\t"      /* context->X26 */
 219                     "str x27, [x0, #0xe0]\n\t"      /* context->X27 */
 220                     "str x28, [x0, #0xe8]\n\t"      /* context->X28 */
 221                     "str x29, [x0, #0xf0]\n\t"      /* context->Fp */
 222                     "str x30, [x0, #0xf8]\n\t"      /* context->Lr */
 223                     "mov x1, sp\n\t"
 224                     "str x1, [x0, #0x100]\n\t"      /* context->Sp */
 225                     "adr x1, 1f\n\t"
 226                     "1: str x1, [x0, #0x108]\n\t"   /* context->Pc */
 227                     "ret"
 228                     )
 229
 230 /***********************************************************************
 231  *           set_cpu_context
 232  *
 233  * Set the new CPU context.
 234  */
 235 static void set_cpu_context( const CONTEXT *context )
 236 {
 237     FIXME( "Not implemented on ARM64\n" );
 238 }
 239
 240 /***********************************************************************
 241  *           copy_context
 242  *
 243  * Copy a register context according to the flags.
 244  */
 245 static void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
 246 {
 247     flags &= ~CONTEXT_ARM64;  /* get rid of CPU id */
 248     if (flags & CONTEXT_CONTROL)
 249     {
 250         to->Fp      = from->Fp;
 251         to->Lr      = from->Lr;
 252         to->Sp      = from->Sp;
 253         to->Pc      = from->Pc;
 254         to->Cpsr    = from->Cpsr;
 255     }
 256     if (flags & CONTEXT_INTEGER)
 257     {
 258 #define C(n)  to->X##n = from->X##n
 259     /* Restore normal registers */
 260     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9);
 261     C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19);
 262     C(20); C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28);
 263 #undef C
 264     }
 265 }
 266
 267 /***********************************************************************
 268  *           context_to_server
 269  *
 270  * Convert a register context to the server format.
 271  */
 272 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
 273 {
 274     DWORD flags = from->ContextFlags & ~CONTEXT_ARM64;  /* get rid of CPU id */
 275
 276     memset( to, 0, sizeof(*to) );
 277     to->cpu = CPU_ARM64;
 278
 279     if (flags & CONTEXT_CONTROL)
 280     {
 281         to->flags |= SERVER_CTX_CONTROL;
 282         to->integer.arm64_regs.x[29] = from->Fp;
 283         to->integer.arm64_regs.x[30] = from->Lr;
 284         to->ctl.arm64_regs.sp     = from->Sp;
 285         to->ctl.arm64_regs.pc     = from->Pc;
 286         to->ctl.arm64_regs.pstate = from->Cpsr;
 287     }
 288     if (flags & CONTEXT_INTEGER)
 289     {
 290         to->flags |= SERVER_CTX_INTEGER;
 291 #define C(n)  to->integer.arm64_regs.x[n] = from->X##n
 292     /* Restore normal registers */
 293     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9);
 294     C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19);
 295     C(20); C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28);
 296 #undef C
 297     }
 298     return STATUS_SUCCESS;
 299 }
 300
 301
 302 /***********************************************************************
 303  *           context_from_server
 304  *
 305  * Convert a register context from the server format.
 306  */
 307 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
 308 {
 309     if (from->cpu != CPU_ARM64) return STATUS_INVALID_PARAMETER;
 310
 311     to->ContextFlags = CONTEXT_ARM64;
 312     if (from->flags & SERVER_CTX_CONTROL)
 313     {
 314         to->ContextFlags |= CONTEXT_CONTROL;
 315         to->Fp     = from->integer.arm64_regs.x[29];
 316         to->Lr     = from->integer.arm64_regs.x[30];
 317         to->Sp     = from->ctl.arm64_regs.sp;
 318         to->Pc     = from->ctl.arm64_regs.pc;
 319         to->Cpsr   = from->ctl.arm64_regs.pstate;
 320     }
 321     if (from->flags & SERVER_CTX_INTEGER)
 322     {
 323         to->ContextFlags |= CONTEXT_INTEGER;
 324 #define C(n)  to->X##n = from->integer.arm64_regs.x[n]
 325     /* Restore normal registers */
 326     C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9);
 327     C(10); C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19);
 328     C(20); C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28);
 329 #undef C
 330      }
 331     return STATUS_SUCCESS;
 332 }
 333
 334 /***********************************************************************
 335  *              NtSetContextThread  (NTDLL.@)
 336  *              ZwSetContextThread  (NTDLL.@)
 337  */
 338 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
 339 {
 340     NTSTATUS ret;
 341     BOOL self;
 342
 343     ret = set_thread_context( handle, context, &self );
 344     if (self && ret == STATUS_SUCCESS) set_cpu_context( context );
 345     return ret;
 346 }
 347
 348
 349 /***********************************************************************
 350  *              NtGetContextThread  (NTDLL.@)
 351  *              ZwGetContextThread  (NTDLL.@)
 352  */
 353 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
 354 {
 355     NTSTATUS ret;
 356     DWORD needed_flags = context->ContextFlags;
 357     BOOL self = (handle == GetCurrentThread());
 358
 359     if (!self)
 360     {
 361         if ((ret = get_thread_context( handle, context, &self ))) return ret;
 362         needed_flags &= ~context->ContextFlags;
 363     }
 364
 365     if (self && needed_flags)
 366     {
 367         CONTEXT ctx;
 368         RtlCaptureContext( &ctx );
 369         copy_context( context, &ctx, ctx.ContextFlags & needed_flags );
 370         context->ContextFlags |= ctx.ContextFlags & needed_flags;
 371     }
 372     return STATUS_SUCCESS;
 373 }
 374
 375
 376 /***********************************************************************
 377  *           setup_exception_record
 378  *
 379  * Setup the exception record and context on the thread stack.
 380  */
 381 static EXCEPTION_RECORD *setup_exception( ucontext_t *sigcontext, raise_func func )
 382 {
 383     struct stack_layout
 384     {
 385         CONTEXT           context;
 386         EXCEPTION_RECORD  rec;
 387     } *stack;
 388     DWORD exception_code = 0;
 389
 390     /* push the stack_layout structure */
 391     stack = (struct stack_layout *)((SP_sig(sigcontext) - sizeof(*stack)) & ~15);
 392
 393     stack->rec.ExceptionRecord  = NULL;
 394     stack->rec.ExceptionCode    = exception_code;
 395     stack->rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 396     stack->rec.ExceptionAddress = (LPVOID)PC_sig(sigcontext);
 397     stack->rec.NumberParameters = 0;
 398
 399     save_context( &stack->context, sigcontext );
 400
 401     /* now modify the sigcontext to return to the raise function */
 402     SP_sig(sigcontext) = (ULONG_PTR)stack;
 403     PC_sig(sigcontext) = (ULONG_PTR)func;
 404     REGn_sig(0, sigcontext) = (ULONG_PTR)&stack->rec;  /* first arg for raise_func */
 405     REGn_sig(1, sigcontext) = (ULONG_PTR)&stack->context; /* second arg for raise_func */
 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], FALSE )))
 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]=%016lx\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             /* FIXME: dump context */
 517         }
 518
 519         status = send_debug_event( rec, TRUE, context );
 520         if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
 521             return STATUS_SUCCESS;
 522
 523         if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
 524             return STATUS_SUCCESS;
 525
 526         if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
 527             return status;
 528     }
 529
 530     /* last chance exception */
 531
 532     status = send_debug_event( rec, FALSE, context );
 533     if (status != DBG_CONTINUE)
 534     {
 535         if (rec->ExceptionFlags & EH_STACK_INVALID)
 536             ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
 537         else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
 538             ERR("Process attempted to continue execution after noncontinuable exception.\n");
 539         else
 540             ERR("Unhandled exception code %x flags %x addr %p\n",
 541                 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
 542         NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
 543     }
 544     return STATUS_SUCCESS;
 545 }
 546
 547 /**********************************************************************
 548  *              segv_handler
 549  *
 550  * Handler for SIGSEGV and related errors.
 551  */
 552 static void segv_handler( int signal, siginfo_t *info, void *ucontext )
 553 {
 554     EXCEPTION_RECORD *rec;
 555     ucontext_t *context = ucontext;
 556
 557     /* check for page fault inside the thread stack */
 558     if (signal == SIGSEGV &&
 559         (char *)info->si_addr >= (char *)NtCurrentTeb()->DeallocationStack &&
 560         (char *)info->si_addr < (char *)NtCurrentTeb()->Tib.StackBase &&
 561         virtual_handle_stack_fault( info->si_addr ))
 562     {
 563         /* check if this was the last guard page */
 564         if ((char *)info->si_addr < (char *)NtCurrentTeb()->DeallocationStack + 2*4096)
 565         {
 566             rec = setup_exception( context, raise_segv_exception );
 567             rec->ExceptionCode = EXCEPTION_STACK_OVERFLOW;
 568         }
 569         return;
 570     }
 571
 572     rec = setup_exception( context, raise_segv_exception );
 573     if (rec->ExceptionCode == EXCEPTION_STACK_OVERFLOW) return;
 574
 575     switch(signal)
 576     {
 577     case SIGILL:   /* Invalid opcode exception */
 578         rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 579         break;
 580     case SIGSEGV:  /* Segmentation fault */
 581         rec->ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
 582         rec->NumberParameters = 2;
 583         /* FIXME: Currently the kernel provides no way to determine if it's read or write */
 584         rec->ExceptionInformation[0] = 0;
 585         rec->ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
 586         break;
 587     case SIGBUS:  /* Alignment check exception */
 588         rec->ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
 589         break;
 590     default:
 591         ERR("Got unexpected signal %i\n", signal);
 592         rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
 593         break;
 594     }
 595 }
 596
 597 /**********************************************************************
 598  *              trap_handler
 599  *
 600  * Handler for SIGTRAP.
 601  */
 602 static void trap_handler( int signal, siginfo_t *info, void *ucontext )
 603 {
 604     EXCEPTION_RECORD rec;
 605     CONTEXT context;
 606     NTSTATUS status;
 607
 608     switch ( info->si_code )
 609     {
 610     case TRAP_TRACE:
 611         rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
 612         break;
 613     case TRAP_BRKPT:
 614     default:
 615         rec.ExceptionCode = EXCEPTION_BREAKPOINT;
 616         break;
 617     }
 618
 619     save_context( &context, ucontext );
 620     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 621     rec.ExceptionRecord  = NULL;
 622     rec.ExceptionAddress = (LPVOID)context.Pc;
 623     rec.NumberParameters = 0;
 624     status = raise_exception( &rec, &context, TRUE );
 625     if (status) raise_status( status, &rec );
 626     restore_context( &context, ucontext );
 627 }
 628
 629 /**********************************************************************
 630  *              fpe_handler
 631  *
 632  * Handler for SIGFPE.
 633  */
 634 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 635 {
 636     EXCEPTION_RECORD rec;
 637     CONTEXT context;
 638     NTSTATUS status;
 639
 640     save_fpu( &context, sigcontext );
 641     save_context( &context, sigcontext );
 642
 643     switch (siginfo->si_code & 0xffff )
 644     {
 645 #ifdef FPE_FLTSUB
 646     case FPE_FLTSUB:
 647         rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
 648         break;
 649 #endif
 650 #ifdef FPE_INTDIV
 651     case FPE_INTDIV:
 652         rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
 653         break;
 654 #endif
 655 #ifdef FPE_INTOVF
 656     case FPE_INTOVF:
 657         rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
 658         break;
 659 #endif
 660 #ifdef FPE_FLTDIV
 661     case FPE_FLTDIV:
 662         rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
 663         break;
 664 #endif
 665 #ifdef FPE_FLTOVF
 666     case FPE_FLTOVF:
 667         rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
 668         break;
 669 #endif
 670 #ifdef FPE_FLTUND
 671     case FPE_FLTUND:
 672         rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
 673         break;
 674 #endif
 675 #ifdef FPE_FLTRES
 676     case FPE_FLTRES:
 677         rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
 678         break;
 679 #endif
 680 #ifdef FPE_FLTINV
 681     case FPE_FLTINV:
 682 #endif
 683     default:
 684         rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
 685         break;
 686     }
 687     rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 688     rec.ExceptionRecord  = NULL;
 689     rec.ExceptionAddress = (LPVOID)context.Pc;
 690     rec.NumberParameters = 0;
 691     status = raise_exception( &rec, &context, TRUE );
 692     if (status) raise_status( status, &rec );
 693
 694     restore_context( &context, sigcontext );
 695     restore_fpu( &context, sigcontext );
 696 }
 697
 698 /**********************************************************************
 699  *              int_handler
 700  *
 701  * Handler for SIGINT.
 702  */
 703 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 704 {
 705     if (!dispatch_signal(SIGINT))
 706     {
 707         EXCEPTION_RECORD rec;
 708         CONTEXT context;
 709         NTSTATUS status;
 710
 711         save_context( &context, sigcontext );
 712         rec.ExceptionCode    = CONTROL_C_EXIT;
 713         rec.ExceptionFlags   = EXCEPTION_CONTINUABLE;
 714         rec.ExceptionRecord  = NULL;
 715         rec.ExceptionAddress = (LPVOID)context.Pc;
 716         rec.NumberParameters = 0;
 717         status = raise_exception( &rec, &context, TRUE );
 718         if (status) raise_status( status, &rec );
 719         restore_context( &context, sigcontext );
 720     }
 721 }
 722
 723
 724 /**********************************************************************
 725  *              abrt_handler
 726  *
 727  * Handler for SIGABRT.
 728  */
 729 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 730 {
 731     EXCEPTION_RECORD rec;
 732     CONTEXT context;
 733     NTSTATUS status;
 734
 735     save_context( &context, sigcontext );
 736     rec.ExceptionCode    = EXCEPTION_WINE_ASSERTION;
 737     rec.ExceptionFlags   = EH_NONCONTINUABLE;
 738     rec.ExceptionRecord  = NULL;
 739     rec.ExceptionAddress = (LPVOID)context.Pc;
 740     rec.NumberParameters = 0;
 741     status = raise_exception( &rec, &context, TRUE );
 742     if (status) raise_status( status, &rec );
 743     restore_context( &context, sigcontext );
 744 }
 745
 746
 747 /**********************************************************************
 748  *              quit_handler
 749  *
 750  * Handler for SIGQUIT.
 751  */
 752 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 753 {
 754     abort_thread(0);
 755 }
 756
 757
 758 /**********************************************************************
 759  *              usr1_handler
 760  *
 761  * Handler for SIGUSR1, used to signal a thread that it got suspended.
 762  */
 763 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
 764 {
 765     CONTEXT context;
 766
 767     save_context( &context, sigcontext );
 768     wait_suspend( &context );
 769     restore_context( &context, sigcontext );
 770 }
 771
 772
 773 /***********************************************************************
 774  *           __wine_set_signal_handler   (NTDLL.@)
 775  */
 776 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
 777 {
 778     if (sig >= sizeof(handlers) / sizeof(handlers[0])) return -1;
 779     if (handlers[sig] != NULL) return -2;
 780     handlers[sig] = wsh;
 781     return 0;
 782 }
 783
 784
 785 /**********************************************************************
 786  *             signal_alloc_thread
 787  */
 788 NTSTATUS signal_alloc_thread( TEB **teb )
 789 {
 790     static size_t sigstack_zero_bits;
 791     SIZE_T size;
 792     NTSTATUS status;
 793
 794     if (!sigstack_zero_bits)
 795     {
 796         size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 );
 797         /* find the first power of two not smaller than min_size */
 798         sigstack_zero_bits = 12;
 799         while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
 800         signal_stack_size = (1 << sigstack_zero_bits) - teb_size;
 801         assert( sizeof(TEB) <= teb_size );
 802     }
 803
 804     size = 1 << sigstack_zero_bits;
 805     *teb = NULL;
 806     if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
 807                                             &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
 808     {
 809         (*teb)->Tib.Self = &(*teb)->Tib;
 810         (*teb)->Tib.ExceptionList = (void *)~0UL;
 811     }
 812     return status;
 813 }
 814
 815
 816 /**********************************************************************
 817  *             signal_free_thread
 818  */
 819 void signal_free_thread( TEB *teb )
 820 {
 821     SIZE_T size = 0;
 822
 823     NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
 824 }
 825
 826
 827 /**********************************************************************
 828  *              signal_init_thread
 829  */
 830 void signal_init_thread( TEB *teb )
 831 {
 832     static BOOL init_done;
 833
 834     if (!init_done)
 835     {
 836         pthread_key_create( &teb_key, NULL );
 837         init_done = TRUE;
 838     }
 839
 840     /* Win64/ARM applications expect the TEB pointer to be in the x18 platform register. */
 841     __asm__ __volatile__( "mov x18, %0" : : "r" (teb) );
 842
 843     pthread_setspecific( teb_key, teb );
 844 }
 845
 846
 847 /**********************************************************************
 848  *              signal_init_process
 849  */
 850 void signal_init_process(void)
 851 {
 852     struct sigaction sig_act;
 853
 854     sig_act.sa_mask = server_block_set;
 855     sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
 856
 857     sig_act.sa_sigaction = int_handler;
 858     if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
 859     sig_act.sa_sigaction = fpe_handler;
 860     if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
 861     sig_act.sa_sigaction = abrt_handler;
 862     if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
 863     sig_act.sa_sigaction = quit_handler;
 864     if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
 865     sig_act.sa_sigaction = usr1_handler;
 866     if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
 867
 868     sig_act.sa_sigaction = segv_handler;
 869     if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
 870     if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
 871 #ifdef SIGBUS
 872     if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
 873 #endif
 874
 875 #ifdef SIGTRAP
 876     sig_act.sa_sigaction = trap_handler;
 877     if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
 878 #endif
 879     return;
 880
 881  error:
 882     perror("sigaction");
 883     exit(1);
 884 }
 885
 886
 887 /**********************************************************************
 888  *              __wine_enter_vm86   (NTDLL.@)
 889  */
 890 void __wine_enter_vm86( CONTEXT *context )
 891 {
 892     MESSAGE("vm86 mode not supported on this platform\n");
 893 }
 894
 895 /***********************************************************************
 896  *            RtlUnwind  (NTDLL.@)
 897  */
 898 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
 899 {
 900     FIXME( "Not implemented on ARM64\n" );
 901 }
 902
 903 /*******************************************************************
 904  *              NtRaiseException (NTDLL.@)
 905  */
 906 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
 907 {
 908     NTSTATUS status = raise_exception( rec, context, first_chance );
 909     if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
 910     return status;
 911 }
 912
 913 /***********************************************************************
 914  *              RtlRaiseException (NTDLL.@)
 915  */
 916 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
 917 {
 918     CONTEXT context;
 919     NTSTATUS status;
 920
 921     RtlCaptureContext( &context );
 922     rec->ExceptionAddress = (LPVOID)context.Pc;
 923     status = raise_exception( rec, &context, TRUE );
 924     if (status) raise_status( status, rec );
 925 }
 926
 927 /*************************************************************************
 928  *             RtlCaptureStackBackTrace (NTDLL.@)
 929  */
 930 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
 931 {
 932     FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
 933     return 0;
 934 }
 935
 936 /***********************************************************************
 937  *           call_thread_entry_point
 938  */
 939 static void call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
 940 {
 941     __TRY
 942     {
 943         TRACE_(relay)( "\1Starting thread proc %p (arg=%p)\n", entry, arg );
 944         exit_thread( entry( arg ));
 945     }
 946     __EXCEPT(unhandled_exception_filter)
 947     {
 948         NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
 949     }
 950     __ENDTRY
 951     abort();  /* should not be reached */
 952 }
 953
 954 struct startup_info
 955 {
 956     LPTHREAD_START_ROUTINE entry;
 957     void                  *arg;
 958     BOOL                   suspend;
 959 };
 960
 961 /***********************************************************************
 962  *           thread_startup
 963  */
 964 static void thread_startup( void *param )
 965 {
 966     CONTEXT context = { 0 };
 967     struct startup_info *info = param;
 968
 969     /* build the initial context */
 970     context.ContextFlags = CONTEXT_FULL;
 971     context.X0 = (DWORD_PTR)info->entry;
 972     context.X1 = (DWORD_PTR)info->arg;
 973     context.Sp = (DWORD_PTR)NtCurrentTeb()->Tib.StackBase;
 974     context.Pc = (DWORD_PTR)call_thread_entry_point;
 975
 976     if (info->suspend) wait_suspend( &context );
 977     attach_dlls( &context );
 978
 979     call_thread_entry_point( (LPTHREAD_START_ROUTINE)context.X0, (void *)context.X1 );
 980 }
 981
 982 /***********************************************************************
 983  *           signal_start_thread
 984  *
 985  * Thread startup sequence:
 986  * signal_start_thread()
 987  *   -> thread_startup()
 988  *     -> call_thread_entry_point()
 989  */
 990 void signal_start_thread( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend )
 991 {
 992     struct startup_info info = { entry, arg, suspend };
 993     wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
 994 }
 995
 996 /**********************************************************************
 997  *              signal_start_process
 998  *
 999  * Process startup sequence:
1000  * signal_start_process()
1001  *   -> thread_startup()
1002  *     -> call_thread_entry_point()
1003  *       -> kernel32_start_process()
1004  */
1005 void signal_start_process( LPTHREAD_START_ROUTINE entry, BOOL suspend )
1006 {
1007     struct startup_info info = { kernel32_start_process, entry, suspend };
1008     wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
1009 }
1010
1011 /***********************************************************************
1012  *           RtlExitUserThread  (NTDLL.@)
1013  */
1014 void WINAPI RtlExitUserThread( ULONG status )
1015 {
1016     exit_thread( status );
1017 }
1018
1019 /***********************************************************************
1020  *           abort_thread
1021  */
1022 void abort_thread( int status )
1023 {
1024     terminate_thread( status );
1025 }
1026
1027 /**********************************************************************
1028  *              DbgBreakPoint   (NTDLL.@)
1029  */
1030 void WINAPI DbgBreakPoint(void)
1031 {
1032      kill(getpid(), SIGTRAP);
1033 }
1034
1035 /**********************************************************************
1036  *              DbgUserBreakPoint   (NTDLL.@)
1037  */
1038 void WINAPI DbgUserBreakPoint(void)
1039 {
1040      kill(getpid(), SIGTRAP);
1041 }
1042
1043 /**********************************************************************
1044  *           NtCurrentTeb   (NTDLL.@)
1045  */
1046 TEB * WINAPI NtCurrentTeb(void)
1047 {
1048     return pthread_getspecific( teb_key );
1049 }
1050
1051 #endif  /* __aarch64__ */