?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntoskrnl.exe: Add Ex[p]InterlockedFlushSList.
[wine.git] / dlls / ntdll / signal_arm64.c
blob94520c95ced698948c5475c7d56022ff7178e8dc
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 #define NONAMELESSUNION
52 #define NONAMELESSSTRUCT
53 #include "ntstatus.h"
54 #define WIN32_NO_STATUS
55 #include "windef.h"
56 #include "winternl.h"
57 #include "wine/library.h"
58 #include "wine/exception.h"
59 #include "ntdll_misc.h"
60 #include "wine/debug.h"
61 #include "winnt.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(seh);
64 WINE_DECLARE_DEBUG_CHANNEL(relay);
65
66 static pthread_key_t teb_key;
67
68 /***********************************************************************
69 * signal context platform-specific definitions
70 */
71 #ifdef linux
72
73 /* All Registers access - only for local access */
74 # define REG_sig(reg_name, context) ((context)->uc_mcontext.reg_name)
75 # define REGn_sig(reg_num, context) ((context)->uc_mcontext.regs[reg_num])
76
77 /* Special Registers access */
78 # define SP_sig(context) REG_sig(sp, context) /* Stack pointer */
79 # define PC_sig(context) REG_sig(pc, context) /* Program counter */
80 # define PSTATE_sig(context) REG_sig(pstate, context) /* Current State Register */
81 # define FP_sig(context) REGn_sig(29, context) /* Frame pointer */
82 # define LR_sig(context) REGn_sig(30, context) /* Link Register */
83
84 /* Exceptions */
85 # define FAULT_sig(context) REG_sig(fault_address, context)
86
87 #endif /* linux */
88
89 static const size_t teb_size = 0x2000; /* we reserve two pages for the TEB */
90 static size_t signal_stack_size;
91
92 typedef void (WINAPI *raise_func)( EXCEPTION_RECORD *rec, CONTEXT *context );
93 typedef int (*wine_signal_handler)(unsigned int sig);
94
95 static wine_signal_handler handlers[256];
96
97 /***********************************************************************
98 * dispatch_signal
99 */
100 static inline int dispatch_signal(unsigned int sig)
101 {
102 if (handlers[sig] == NULL) return 0;
103 return handlers[sig](sig);
104 }
105
106 /*******************************************************************
107 * is_valid_frame
108 */
109 static inline BOOL is_valid_frame( void *frame )
110 {
111 if ((ULONG_PTR)frame & 3) return FALSE;
112 return (frame >= NtCurrentTeb()->Tib.StackLimit &&
113 (void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
114 }
115
116 /***********************************************************************
117 * save_context
118 *
119 * Set the register values from a sigcontext.
120 */
121 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
122 {
123 DWORD i;
124
125 context->ContextFlags = CONTEXT_FULL;
126 context->u.s.Fp = FP_sig(sigcontext); /* Frame pointer */
127 context->u.s.Lr = LR_sig(sigcontext); /* Link register */
128 context->Sp = SP_sig(sigcontext); /* Stack pointer */
129 context->Pc = PC_sig(sigcontext); /* Program Counter */
130 context->Cpsr = PSTATE_sig(sigcontext); /* Current State Register */
131 for (i = 0; i <= 28; i++) context->u.X[i] = REGn_sig( i, sigcontext );
132 }
133
134
135 /***********************************************************************
136 * restore_context
137 *
138 * Build a sigcontext from the register values.
139 */
140 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
141 {
142 DWORD i;
143
144 FP_sig(sigcontext) = context->u.s.Fp; /* Frame pointer */
145 LR_sig(sigcontext) = context->u.s.Lr; /* Link register */
146 SP_sig(sigcontext) = context->Sp; /* Stack pointer */
147 PC_sig(sigcontext) = context->Pc; /* Program Counter */
148 PSTATE_sig(sigcontext) = context->Cpsr; /* Current State Register */
149 for (i = 0; i <= 28; i++) REGn_sig( i, sigcontext ) = context->u.X[i];
150 }
151
152
153 /***********************************************************************
154 * save_fpu
155 *
156 * Set the FPU context from a sigcontext.
157 */
158 static inline void save_fpu( CONTEXT *context, const ucontext_t *sigcontext )
159 {
160 FIXME( "Not implemented on ARM64\n" );
161 }
162
163
164 /***********************************************************************
165 * restore_fpu
166 *
167 * Restore the FPU context to a sigcontext.
168 */
169 static inline void restore_fpu( CONTEXT *context, const ucontext_t *sigcontext )
170 {
171 FIXME( "Not implemented on ARM64\n" );
172 }
173
174 /***********************************************************************
175 * RtlCaptureContext (NTDLL.@)
176 */
177 /* FIXME: Use the Stack instead of the actual register values? */
178 __ASM_STDCALL_FUNC( RtlCaptureContext, 8,
179 "stp x0, x1, [sp, #-32]!\n\t"
180 "mov w1, #0x400000\n\t" /* CONTEXT_ARM64 */
181 "add w1, w1, #0x3\n\t" /* CONTEXT_FULL */
182 "str w1, [x0]\n\t" /* context->ContextFlags */ /* 32-bit, look at cpsr */
183 "mrs x1, NZCV\n\t"
184 "str w1, [x0, #0x4]\n\t" /* context->Cpsr */
185 "ldp x0, x1, [sp], #32\n\t"
186 "str x0, [x0, #0x8]\n\t" /* context->X0 */
187 "str x1, [x0, #0x10]\n\t" /* context->X1 */
188 "str x2, [x0, #0x18]\n\t" /* context->X2 */
189 "str x3, [x0, #0x20]\n\t" /* context->X3 */
190 "str x4, [x0, #0x28]\n\t" /* context->X4 */
191 "str x5, [x0, #0x30]\n\t" /* context->X5 */
192 "str x6, [x0, #0x38]\n\t" /* context->X6 */
193 "str x7, [x0, #0x40]\n\t" /* context->X7 */
194 "str x8, [x0, #0x48]\n\t" /* context->X8 */
195 "str x9, [x0, #0x50]\n\t" /* context->X9 */
196 "str x10, [x0, #0x58]\n\t" /* context->X10 */
197 "str x11, [x0, #0x60]\n\t" /* context->X11 */
198 "str x12, [x0, #0x68]\n\t" /* context->X12 */
199 "str x13, [x0, #0x70]\n\t" /* context->X13 */
200 "str x14, [x0, #0x78]\n\t" /* context->X14 */
201 "str x15, [x0, #0x80]\n\t" /* context->X15 */
202 "str x16, [x0, #0x88]\n\t" /* context->X16 */
203 "str x17, [x0, #0x90]\n\t" /* context->X17 */
204 "str x18, [x0, #0x98]\n\t" /* context->X18 */
205 "str x19, [x0, #0xa0]\n\t" /* context->X19 */
206 "str x20, [x0, #0xa8]\n\t" /* context->X20 */
207 "str x21, [x0, #0xb0]\n\t" /* context->X21 */
208 "str x22, [x0, #0xb8]\n\t" /* context->X22 */
209 "str x23, [x0, #0xc0]\n\t" /* context->X23 */
210 "str x24, [x0, #0xc8]\n\t" /* context->X24 */
211 "str x25, [x0, #0xd0]\n\t" /* context->X25 */
212 "str x26, [x0, #0xd8]\n\t" /* context->X26 */
213 "str x27, [x0, #0xe0]\n\t" /* context->X27 */
214 "str x28, [x0, #0xe8]\n\t" /* context->X28 */
215 "str x29, [x0, #0xf0]\n\t" /* context->Fp */
216 "str x30, [x0, #0xf8]\n\t" /* context->Lr */
217 "mov x1, sp\n\t"
218 "str x1, [x0, #0x100]\n\t" /* context->Sp */
219 "adr x1, 1f\n\t"
220 "1: str x1, [x0, #0x108]\n\t" /* context->Pc */
221 "ret"
222 )
223
224 /***********************************************************************
225 * set_cpu_context
226 *
227 * Set the new CPU context.
228 */
229 static void set_cpu_context( const CONTEXT *context )
230 {
231 FIXME( "Not implemented on ARM64\n" );
232 }
233
234 /***********************************************************************
235 * get_server_context_flags
236 *
237 * Convert CPU-specific flags to generic server flags
238 */
239 static unsigned int get_server_context_flags( DWORD flags )
240 {
241 unsigned int ret = 0;
242
243 flags &= ~CONTEXT_ARM64; /* get rid of CPU id */
244 if (flags & CONTEXT_CONTROL) ret |= SERVER_CTX_CONTROL;
245 if (flags & CONTEXT_INTEGER) ret |= SERVER_CTX_INTEGER;
246 if (flags & CONTEXT_FLOATING_POINT) ret |= SERVER_CTX_FLOATING_POINT;
247 if (flags & CONTEXT_DEBUG_REGISTERS) ret |= SERVER_CTX_DEBUG_REGISTERS;
248 return ret;
249 }
250
251 /***********************************************************************
252 * copy_context
253 *
254 * Copy a register context according to the flags.
255 */
256 static void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
257 {
258 flags &= ~CONTEXT_ARM64; /* get rid of CPU id */
259 if (flags & CONTEXT_CONTROL)
260 {
261 to->u.s.Fp = from->u.s.Fp;
262 to->u.s.Lr = from->u.s.Lr;
263 to->Sp = from->Sp;
264 to->Pc = from->Pc;
265 to->Cpsr = from->Cpsr;
266 }
267 if (flags & CONTEXT_INTEGER)
268 {
269 memcpy( to->u.X, from->u.X, sizeof(to->u.X) );
270 }
271 if (flags & CONTEXT_FLOATING_POINT)
272 {
273 memcpy( to->V, from->V, sizeof(to->V) );
274 to->Fpcr = from->Fpcr;
275 to->Fpsr = from->Fpsr;
276 }
277 if (flags & CONTEXT_DEBUG_REGISTERS)
278 {
279 memcpy( to->Bcr, from->Bcr, sizeof(to->Bcr) );
280 memcpy( to->Bvr, from->Bvr, sizeof(to->Bvr) );
281 memcpy( to->Wcr, from->Wcr, sizeof(to->Wcr) );
282 memcpy( to->Wvr, from->Wvr, sizeof(to->Wvr) );
283 }
284 }
285
286 /***********************************************************************
287 * context_to_server
288 *
289 * Convert a register context to the server format.
290 */
291 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
292 {
293 DWORD i, flags = from->ContextFlags & ~CONTEXT_ARM64; /* get rid of CPU id */
294
295 memset( to, 0, sizeof(*to) );
296 to->cpu = CPU_ARM64;
297
298 if (flags & CONTEXT_CONTROL)
299 {
300 to->flags |= SERVER_CTX_CONTROL;
301 to->integer.arm64_regs.x[29] = from->u.s.Fp;
302 to->integer.arm64_regs.x[30] = from->u.s.Lr;
303 to->ctl.arm64_regs.sp = from->Sp;
304 to->ctl.arm64_regs.pc = from->Pc;
305 to->ctl.arm64_regs.pstate = from->Cpsr;
306 }
307 if (flags & CONTEXT_INTEGER)
308 {
309 to->flags |= SERVER_CTX_INTEGER;
310 for (i = 0; i <= 28; i++) to->integer.arm64_regs.x[i] = from->u.X[i];
311 }
312 if (flags & CONTEXT_FLOATING_POINT)
313 {
314 to->flags |= SERVER_CTX_FLOATING_POINT;
315 for (i = 0; i < 64; i++) to->fp.arm64_regs.d[i] = from->V[i / 2].D[i % 2];
316 to->fp.arm64_regs.fpcr = from->Fpcr;
317 to->fp.arm64_regs.fpsr = from->Fpsr;
318 }
319 if (flags & CONTEXT_DEBUG_REGISTERS)
320 {
321 to->flags |= SERVER_CTX_DEBUG_REGISTERS;
322 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->debug.arm64_regs.bcr[i] = from->Bcr[i];
323 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->debug.arm64_regs.bvr[i] = from->Bvr[i];
324 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->debug.arm64_regs.wcr[i] = from->Wcr[i];
325 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->debug.arm64_regs.wvr[i] = from->Wvr[i];
326 }
327 return STATUS_SUCCESS;
328 }
329
330
331 /***********************************************************************
332 * context_from_server
333 *
334 * Convert a register context from the server format.
335 */
336 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
337 {
338 DWORD i;
339
340 if (from->cpu != CPU_ARM64) return STATUS_INVALID_PARAMETER;
341
342 to->ContextFlags = CONTEXT_ARM64;
343 if (from->flags & SERVER_CTX_CONTROL)
344 {
345 to->ContextFlags |= CONTEXT_CONTROL;
346 to->u.s.Fp = from->integer.arm64_regs.x[29];
347 to->u.s.Lr = from->integer.arm64_regs.x[30];
348 to->Sp = from->ctl.arm64_regs.sp;
349 to->Pc = from->ctl.arm64_regs.pc;
350 to->Cpsr = from->ctl.arm64_regs.pstate;
351 }
352 if (from->flags & SERVER_CTX_INTEGER)
353 {
354 to->ContextFlags |= CONTEXT_INTEGER;
355 for (i = 0; i <= 28; i++) to->u.X[i] = from->integer.arm64_regs.x[i];
356 }
357 if (from->flags & SERVER_CTX_FLOATING_POINT)
358 {
359 to->ContextFlags |= CONTEXT_FLOATING_POINT;
360 for (i = 0; i < 64; i++) to->V[i / 2].D[i % 2] = from->fp.arm64_regs.d[i];
361 to->Fpcr = from->fp.arm64_regs.fpcr;
362 to->Fpsr = from->fp.arm64_regs.fpsr;
363 }
364 if (from->flags & SERVER_CTX_DEBUG_REGISTERS)
365 {
366 to->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
367 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->Bcr[i] = from->debug.arm64_regs.bcr[i];
368 for (i = 0; i < ARM64_MAX_BREAKPOINTS; i++) to->Bvr[i] = from->debug.arm64_regs.bvr[i];
369 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->Wcr[i] = from->debug.arm64_regs.wcr[i];
370 for (i = 0; i < ARM64_MAX_WATCHPOINTS; i++) to->Wvr[i] = from->debug.arm64_regs.wvr[i];
371 }
372 return STATUS_SUCCESS;
373 }
374
375 /***********************************************************************
376 * NtSetContextThread (NTDLL.@)
377 * ZwSetContextThread (NTDLL.@)
378 */
379 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
380 {
381 NTSTATUS ret;
382 BOOL self;
383 context_t server_context;
384
385 context_to_server( &server_context, context );
386 ret = set_thread_context( handle, &server_context, &self );
387 if (self && ret == STATUS_SUCCESS) set_cpu_context( context );
388 return ret;
389 }
390
391
392 /***********************************************************************
393 * NtGetContextThread (NTDLL.@)
394 * ZwGetContextThread (NTDLL.@)
395 */
396 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
397 {
398 NTSTATUS ret;
399 DWORD needed_flags = context->ContextFlags;
400 BOOL self = (handle == GetCurrentThread());
401
402 if (!self)
403 {
404 context_t server_context;
405 unsigned int server_flags = get_server_context_flags( context->ContextFlags );
406
407 if ((ret = get_thread_context( handle, &server_context, server_flags, &self ))) return ret;
408 if ((ret = context_from_server( context, &server_context ))) return ret;
409 needed_flags &= ~context->ContextFlags;
410 }
411
412 if (self && needed_flags)
413 {
414 CONTEXT ctx;
415 RtlCaptureContext( &ctx );
416 copy_context( context, &ctx, ctx.ContextFlags & needed_flags );
417 context->ContextFlags |= ctx.ContextFlags & needed_flags;
418 }
419 return STATUS_SUCCESS;
420 }
421
422
423 /***********************************************************************
424 * setup_exception_record
425 *
426 * Setup the exception record and context on the thread stack.
427 */
428 static EXCEPTION_RECORD *setup_exception( ucontext_t *sigcontext, raise_func func )
429 {
430 struct stack_layout
431 {
432 CONTEXT context;
433 EXCEPTION_RECORD rec;
434 } *stack;
435 DWORD exception_code = 0;
436
437 /* push the stack_layout structure */
438 stack = (struct stack_layout *)((SP_sig(sigcontext) - sizeof(*stack)) & ~15);
439
440 stack->rec.ExceptionRecord = NULL;
441 stack->rec.ExceptionCode = exception_code;
442 stack->rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
443 stack->rec.ExceptionAddress = (LPVOID)PC_sig(sigcontext);
444 stack->rec.NumberParameters = 0;
445
446 save_context( &stack->context, sigcontext );
447
448 /* now modify the sigcontext to return to the raise function */
449 SP_sig(sigcontext) = (ULONG_PTR)stack;
450 PC_sig(sigcontext) = (ULONG_PTR)func;
451 REGn_sig(0, sigcontext) = (ULONG_PTR)&stack->rec; /* first arg for raise_func */
452 REGn_sig(1, sigcontext) = (ULONG_PTR)&stack->context; /* second arg for raise_func */
453
454 return &stack->rec;
455 }
456
457 /**********************************************************************
458 * raise_segv_exception
459 */
460 static void WINAPI raise_segv_exception( EXCEPTION_RECORD *rec, CONTEXT *context )
461 {
462 NTSTATUS status;
463
464 switch(rec->ExceptionCode)
465 {
466 case EXCEPTION_ACCESS_VIOLATION:
467 if (rec->NumberParameters == 2)
468 {
469 if (!(rec->ExceptionCode = virtual_handle_fault( (void *)rec->ExceptionInformation[1],
470 rec->ExceptionInformation[0], FALSE )))
471 goto done;
472 }
473 break;
474 }
475 status = NtRaiseException( rec, context, TRUE );
476 if (status) raise_status( status, rec );
477 done:
478 set_cpu_context( context );
479 }
480
481 /**********************************************************************
482 * call_stack_handlers
483 *
484 * Call the stack handlers chain.
485 */
486 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
487 {
488 EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
489 DWORD res;
490
491 frame = NtCurrentTeb()->Tib.ExceptionList;
492 nested_frame = NULL;
493 while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
494 {
495 /* Check frame address */
496 if (!is_valid_frame( frame ))
497 {
498 rec->ExceptionFlags |= EH_STACK_INVALID;
499 break;
500 }
501
502 /* Call handler */
503 TRACE( "calling handler at %p code=%x flags=%x\n",
504 frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
505 res = frame->Handler( rec, frame, context, &dispatch );
506 TRACE( "handler at %p returned %x\n", frame->Handler, res );
507
508 if (frame == nested_frame)
509 {
510 /* no longer nested */
511 nested_frame = NULL;
512 rec->ExceptionFlags &= ~EH_NESTED_CALL;
513 }
514
515 switch(res)
516 {
517 case ExceptionContinueExecution:
518 if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
519 return STATUS_NONCONTINUABLE_EXCEPTION;
520 case ExceptionContinueSearch:
521 break;
522 case ExceptionNestedException:
523 if (nested_frame < dispatch) nested_frame = dispatch;
524 rec->ExceptionFlags |= EH_NESTED_CALL;
525 break;
526 default:
527 return STATUS_INVALID_DISPOSITION;
528 }
529 frame = frame->Prev;
530 }
531 return STATUS_UNHANDLED_EXCEPTION;
532 }
533
534
535 /*******************************************************************
536 * raise_exception
537 *
538 * Implementation of NtRaiseException.
539 */
540 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
541 {
542 NTSTATUS status;
543
544 if (first_chance)
545 {
546 DWORD c;
547
548 TRACE( "code=%x flags=%x addr=%p pc=%lx tid=%04x\n",
549 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
550 context->Pc, GetCurrentThreadId() );
551 for (c = 0; c < rec->NumberParameters; c++)
552 TRACE( " info[%d]=%016lx\n", c, rec->ExceptionInformation[c] );
553 if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
554 {
555 if (rec->ExceptionInformation[1] >> 16)
556 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
557 rec->ExceptionAddress,
558 (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
559 else
560 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
561 rec->ExceptionAddress,
562 (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
563 }
564 else
565 {
566 TRACE(" x0=%016lx x1=%016lx x2=%016lx x3=%016lx\n",
567 context->u.s.X0, context->u.s.X1, context->u.s.X2, context->u.s.X3 );
568 TRACE(" x4=%016lx x5=%016lx x6=%016lx x7=%016lx\n",
569 context->u.s.X4, context->u.s.X5, context->u.s.X6, context->u.s.X7 );
570 TRACE(" x8=%016lx x9=%016lx x10=%016lx x11=%016lx\n",
571 context->u.s.X8, context->u.s.X9, context->u.s.X10, context->u.s.X11 );
572 TRACE(" x12=%016lx x13=%016lx x14=%016lx x15=%016lx\n",
573 context->u.s.X12, context->u.s.X13, context->u.s.X14, context->u.s.X15 );
574 TRACE(" x16=%016lx x17=%016lx x18=%016lx x19=%016lx\n",
575 context->u.s.X16, context->u.s.X17, context->u.s.X18, context->u.s.X19 );
576 TRACE(" x20=%016lx x21=%016lx x22=%016lx x23=%016lx\n",
577 context->u.s.X20, context->u.s.X21, context->u.s.X22, context->u.s.X23 );
578 TRACE(" x24=%016lx x25=%016lx x26=%016lx x27=%016lx\n",
579 context->u.s.X24, context->u.s.X25, context->u.s.X26, context->u.s.X27 );
580 TRACE(" x28=%016lx fp=%016lx lr=%016lx sp=%016lx\n",
581 context->u.s.X28, context->u.s.Fp, context->u.s.Lr, context->Sp );
582 TRACE(" pc=%016lx\n",
583 context->Pc );
584 }
585
586 status = send_debug_event( rec, TRUE, context );
587 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
588 return STATUS_SUCCESS;
589
590 if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
591 return STATUS_SUCCESS;
592
593 if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
594 return status;
595 }
596
597 /* last chance exception */
598
599 status = send_debug_event( rec, FALSE, context );
600 if (status != DBG_CONTINUE)
601 {
602 if (rec->ExceptionFlags & EH_STACK_INVALID)
603 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
604 else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
605 ERR("Process attempted to continue execution after noncontinuable exception.\n");
606 else
607 ERR("Unhandled exception code %x flags %x addr %p\n",
608 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
609 NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
610 }
611 return STATUS_SUCCESS;
612 }
613
614 static inline DWORD is_write_fault( DWORD *pc )
615 {
616 DWORD inst = *pc;
617 if ((inst & 0xbfff0000) == 0x0c000000 /* C3.3.1 */ ||
618 (inst & 0xbfe00000) == 0x0c800000 /* C3.3.2 */ ||
619 (inst & 0xbfdf0000) == 0x0d000000 /* C3.3.3 */ ||
620 (inst & 0xbfc00000) == 0x0d800000 /* C3.3.4 */ ||
621 (inst & 0x3f400000) == 0x08000000 /* C3.3.6 */ ||
622 (inst & 0x3bc00000) == 0x38000000 /* C3.3.8-12 */ ||
623 (inst & 0x3fe00000) == 0x3c800000 /* C3.3.8-12 128bit */ ||
624 (inst & 0x3bc00000) == 0x39000000 /* C3.3.13 */ ||
625 (inst & 0x3fc00000) == 0x3d800000 /* C3.3.13 128bit */ ||
626 (inst & 0x3a400000) == 0x28000000) /* C3.3.7,14-16 */
627 return EXCEPTION_WRITE_FAULT;
628 return EXCEPTION_READ_FAULT;
629 }
630
631 /**********************************************************************
632 * segv_handler
633 *
634 * Handler for SIGSEGV and related errors.
635 */
636 static void segv_handler( int signal, siginfo_t *info, void *ucontext )
637 {
638 EXCEPTION_RECORD *rec;
639 ucontext_t *context = ucontext;
640 DWORD *orig_pc = (DWORD *)PC_sig(context);
641
642 /* check for page fault inside the thread stack */
643 if (signal == SIGSEGV &&
644 (char *)info->si_addr >= (char *)NtCurrentTeb()->DeallocationStack &&
645 (char *)info->si_addr < (char *)NtCurrentTeb()->Tib.StackBase &&
646 virtual_handle_stack_fault( info->si_addr ))
647 {
648 /* check if this was the last guard page */
649 if ((char *)info->si_addr < (char *)NtCurrentTeb()->DeallocationStack + 2*4096)
650 {
651 rec = setup_exception( context, raise_segv_exception );
652 rec->ExceptionCode = EXCEPTION_STACK_OVERFLOW;
653 }
654 return;
655 }
656
657 rec = setup_exception( context, raise_segv_exception );
658 if (rec->ExceptionCode == EXCEPTION_STACK_OVERFLOW) return;
659
660 switch(signal)
661 {
662 case SIGILL: /* Invalid opcode exception */
663 rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
664 break;
665 case SIGSEGV: /* Segmentation fault */
666 rec->ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
667 rec->NumberParameters = 2;
668 rec->ExceptionInformation[0] = is_write_fault(orig_pc);
669 rec->ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
670 break;
671 case SIGBUS: /* Alignment check exception */
672 rec->ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
673 break;
674 default:
675 ERR("Got unexpected signal %i\n", signal);
676 rec->ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
677 break;
678 }
679 }
680
681 /**********************************************************************
682 * trap_handler
683 *
684 * Handler for SIGTRAP.
685 */
686 static void trap_handler( int signal, siginfo_t *info, void *ucontext )
687 {
688 EXCEPTION_RECORD rec;
689 CONTEXT context;
690 NTSTATUS status;
691
692 switch ( info->si_code )
693 {
694 case TRAP_TRACE:
695 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
696 break;
697 case TRAP_BRKPT:
698 default:
699 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
700 break;
701 }
702
703 save_context( &context, ucontext );
704 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
705 rec.ExceptionRecord = NULL;
706 rec.ExceptionAddress = (LPVOID)context.Pc;
707 rec.NumberParameters = 0;
708 status = raise_exception( &rec, &context, TRUE );
709 if (status) raise_status( status, &rec );
710 restore_context( &context, ucontext );
711 }
712
713 /**********************************************************************
714 * fpe_handler
715 *
716 * Handler for SIGFPE.
717 */
718 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
719 {
720 EXCEPTION_RECORD rec;
721 CONTEXT context;
722 NTSTATUS status;
723
724 save_fpu( &context, sigcontext );
725 save_context( &context, sigcontext );
726
727 switch (siginfo->si_code & 0xffff )
728 {
729 #ifdef FPE_FLTSUB
730 case FPE_FLTSUB:
731 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
732 break;
733 #endif
734 #ifdef FPE_INTDIV
735 case FPE_INTDIV:
736 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
737 break;
738 #endif
739 #ifdef FPE_INTOVF
740 case FPE_INTOVF:
741 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
742 break;
743 #endif
744 #ifdef FPE_FLTDIV
745 case FPE_FLTDIV:
746 rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
747 break;
748 #endif
749 #ifdef FPE_FLTOVF
750 case FPE_FLTOVF:
751 rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
752 break;
753 #endif
754 #ifdef FPE_FLTUND
755 case FPE_FLTUND:
756 rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
757 break;
758 #endif
759 #ifdef FPE_FLTRES
760 case FPE_FLTRES:
761 rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
762 break;
763 #endif
764 #ifdef FPE_FLTINV
765 case FPE_FLTINV:
766 #endif
767 default:
768 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
769 break;
770 }
771 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
772 rec.ExceptionRecord = NULL;
773 rec.ExceptionAddress = (LPVOID)context.Pc;
774 rec.NumberParameters = 0;
775 status = raise_exception( &rec, &context, TRUE );
776 if (status) raise_status( status, &rec );
777
778 restore_context( &context, sigcontext );
779 restore_fpu( &context, sigcontext );
780 }
781
782 /**********************************************************************
783 * int_handler
784 *
785 * Handler for SIGINT.
786 */
787 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
788 {
789 if (!dispatch_signal(SIGINT))
790 {
791 EXCEPTION_RECORD rec;
792 CONTEXT context;
793 NTSTATUS status;
794
795 save_context( &context, sigcontext );
796 rec.ExceptionCode = CONTROL_C_EXIT;
797 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
798 rec.ExceptionRecord = NULL;
799 rec.ExceptionAddress = (LPVOID)context.Pc;
800 rec.NumberParameters = 0;
801 status = raise_exception( &rec, &context, TRUE );
802 if (status) raise_status( status, &rec );
803 restore_context( &context, sigcontext );
804 }
805 }
806
807
808 /**********************************************************************
809 * abrt_handler
810 *
811 * Handler for SIGABRT.
812 */
813 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
814 {
815 EXCEPTION_RECORD rec;
816 CONTEXT context;
817 NTSTATUS status;
818
819 save_context( &context, sigcontext );
820 rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
821 rec.ExceptionFlags = EH_NONCONTINUABLE;
822 rec.ExceptionRecord = NULL;
823 rec.ExceptionAddress = (LPVOID)context.Pc;
824 rec.NumberParameters = 0;
825 status = raise_exception( &rec, &context, TRUE );
826 if (status) raise_status( status, &rec );
827 restore_context( &context, sigcontext );
828 }
829
830
831 /**********************************************************************
832 * quit_handler
833 *
834 * Handler for SIGQUIT.
835 */
836 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
837 {
838 abort_thread(0);
839 }
840
841
842 /**********************************************************************
843 * usr1_handler
844 *
845 * Handler for SIGUSR1, used to signal a thread that it got suspended.
846 */
847 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
848 {
849 CONTEXT context;
850
851 save_context( &context, sigcontext );
852 wait_suspend( &context );
853 restore_context( &context, sigcontext );
854 }
855
856
857 /***********************************************************************
858 * __wine_set_signal_handler (NTDLL.@)
859 */
860 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
861 {
862 if (sig >= ARRAY_SIZE(handlers)) return -1;
863 if (handlers[sig] != NULL) return -2;
864 handlers[sig] = wsh;
865 return 0;
866 }
867
868
869 /**********************************************************************
870 * signal_alloc_thread
871 */
872 NTSTATUS signal_alloc_thread( TEB **teb )
873 {
874 static size_t sigstack_zero_bits;
875 SIZE_T size;
876 NTSTATUS status;
877
878 if (!sigstack_zero_bits)
879 {
880 size_t min_size = teb_size + max( MINSIGSTKSZ, 8192 );
881 /* find the first power of two not smaller than min_size */
882 sigstack_zero_bits = 12;
883 while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
884 signal_stack_size = (1 << sigstack_zero_bits) - teb_size;
885 assert( sizeof(TEB) <= teb_size );
886 }
887
888 size = 1 << sigstack_zero_bits;
889 *teb = NULL;
890 if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
891 &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
892 {
893 (*teb)->Tib.Self = &(*teb)->Tib;
894 (*teb)->Tib.ExceptionList = (void *)~0UL;
895 }
896 return status;
897 }
898
899
900 /**********************************************************************
901 * signal_free_thread
902 */
903 void signal_free_thread( TEB *teb )
904 {
905 SIZE_T size = 0;
906
907 NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
908 }
909
910
911 /**********************************************************************
912 * signal_init_thread
913 */
914 void signal_init_thread( TEB *teb )
915 {
916 static BOOL init_done;
917
918 if (!init_done)
919 {
920 pthread_key_create( &teb_key, NULL );
921 init_done = TRUE;
922 }
923
924 /* Win64/ARM applications expect the TEB pointer to be in the x18 platform register. */
925 __asm__ __volatile__( "mov x18, %0" : : "r" (teb) );
926
927 pthread_setspecific( teb_key, teb );
928 }
929
930
931 /**********************************************************************
932 * signal_init_process
933 */
934 void signal_init_process(void)
935 {
936 struct sigaction sig_act;
937
938 sig_act.sa_mask = server_block_set;
939 sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
940
941 sig_act.sa_sigaction = int_handler;
942 if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
943 sig_act.sa_sigaction = fpe_handler;
944 if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
945 sig_act.sa_sigaction = abrt_handler;
946 if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
947 sig_act.sa_sigaction = quit_handler;
948 if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
949 sig_act.sa_sigaction = usr1_handler;
950 if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
951
952 sig_act.sa_sigaction = segv_handler;
953 if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
954 if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
955 #ifdef SIGBUS
956 if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
957 #endif
958
959 #ifdef SIGTRAP
960 sig_act.sa_sigaction = trap_handler;
961 if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
962 #endif
963 return;
964
965 error:
966 perror("sigaction");
967 exit(1);
968 }
969
970
971 /**********************************************************************
972 * RtlAddFunctionTable (NTDLL.@)
973 */
974 BOOLEAN CDECL RtlAddFunctionTable( RUNTIME_FUNCTION *table, DWORD count, ULONG_PTR addr )
975 {
976 FIXME( "%p %u %lx: stub\n", table, count, addr );
977 return TRUE;
978 }
979
980 /**********************************************************************
981 * RtlInstallFunctionTableCallback (NTDLL.@)
982 */
983 BOOLEAN CDECL RtlInstallFunctionTableCallback( ULONG_PTR table, ULONG_PTR base, DWORD length,
984 PGET_RUNTIME_FUNCTION_CALLBACK callback, PVOID context, PCWSTR dll )
985 {
986 FIXME( "%lx %lx %d %p %p %s: stub\n", table, base, length, callback, context, wine_dbgstr_w(dll) );
987 return TRUE;
988 }
989
990
991 /*************************************************************************
992 * RtlAddGrowableFunctionTable (NTDLL.@)
993 */
994 DWORD WINAPI RtlAddGrowableFunctionTable( void **table, RUNTIME_FUNCTION *functions, DWORD count, DWORD max_count,
995 ULONG_PTR base, ULONG_PTR end )
996 {
997 FIXME( "(%p, %p, %d, %d, %ld, %ld) stub!\n", table, functions, count, max_count, base, end );
998 if (table) *table = NULL;
999 return STATUS_SUCCESS;
1000 }
1001
1002
1003 /*************************************************************************
1004 * RtlGrowFunctionTable (NTDLL.@)
1005 */
1006 void WINAPI RtlGrowFunctionTable( void *table, DWORD count )
1007 {
1008 FIXME( "(%p, %d) stub!\n", table, count );
1009 }
1010
1011 /*************************************************************************
1012 * RtlDeleteGrowableFunctionTable (NTDLL.@)
1013 */
1014 void WINAPI RtlDeleteGrowableFunctionTable( void *table )
1015 {
1016 FIXME( "(%p) stub!\n", table );
1017 }
1018
1019 /**********************************************************************
1020 * RtlDeleteFunctionTable (NTDLL.@)
1021 */
1022 BOOLEAN CDECL RtlDeleteFunctionTable( RUNTIME_FUNCTION *table )
1023 {
1024 FIXME( "%p: stub\n", table );
1025 return TRUE;
1026 }
1027
1028 /***********************************************************************
1029 * RtlUnwind (NTDLL.@)
1030 */
1031 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
1032 {
1033 FIXME( "Not implemented on ARM64\n" );
1034 }
1035
1036 /*******************************************************************
1037 * NtRaiseException (NTDLL.@)
1038 */
1039 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
1040 {
1041 NTSTATUS status = raise_exception( rec, context, first_chance );
1042 if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
1043 return status;
1044 }
1045
1046 /***********************************************************************
1047 * RtlRaiseException (NTDLL.@)
1048 */
1049 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
1050 {
1051 CONTEXT context;
1052 NTSTATUS status;
1053
1054 RtlCaptureContext( &context );
1055 rec->ExceptionAddress = (LPVOID)context.Pc;
1056 status = raise_exception( rec, &context, TRUE );
1057 if (status) raise_status( status, rec );
1058 }
1059
1060 /*************************************************************************
1061 * RtlCaptureStackBackTrace (NTDLL.@)
1062 */
1063 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
1064 {
1065 FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
1066 return 0;
1067 }
1068
1069 /***********************************************************************
1070 * call_thread_entry_point
1071 */
1072 static void WINAPI call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
1073 {
1074 __TRY
1075 {
1076 TRACE_(relay)( "\1Starting thread proc %p (arg=%p)\n", entry, arg );
1077 RtlExitUserThread( entry( arg ));
1078 }
1079 __EXCEPT(call_unhandled_exception_filter)
1080 {
1081 NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
1082 }
1083 __ENDTRY
1084 abort(); /* should not be reached */
1085 }
1086
1087 typedef void (WINAPI *thread_start_func)(LPTHREAD_START_ROUTINE,void *);
1088
1089 struct startup_info
1090 {
1091 thread_start_func start;
1092 LPTHREAD_START_ROUTINE entry;
1093 void *arg;
1094 BOOL suspend;
1095 };
1096
1097 /***********************************************************************
1098 * thread_startup
1099 */
1100 static void thread_startup( void *param )
1101 {
1102 CONTEXT context = { 0 };
1103 struct startup_info *info = param;
1104
1105 /* build the initial context */
1106 context.ContextFlags = CONTEXT_FULL;
1107 context.u.s.X0 = (DWORD_PTR)info->entry;
1108 context.u.s.X1 = (DWORD_PTR)info->arg;
1109 context.Sp = (DWORD_PTR)NtCurrentTeb()->Tib.StackBase;
1110 context.Pc = (DWORD_PTR)info->start;
1111
1112 if (info->suspend) wait_suspend( &context );
1113 LdrInitializeThunk( &context, (void **)&context.u.s.X0, 0, 0 );
1114
1115 ((thread_start_func)context.Pc)( (LPTHREAD_START_ROUTINE)context.u.s.X0, (void *)context.u.s.X1 );
1116 }
1117
1118 /***********************************************************************
1119 * signal_start_thread
1120 *
1121 * Thread startup sequence:
1122 * signal_start_thread()
1123 * -> thread_startup()
1124 * -> call_thread_entry_point()
1125 */
1126 void signal_start_thread( LPTHREAD_START_ROUTINE entry, void *arg, BOOL suspend )
1127 {
1128 struct startup_info info = { call_thread_entry_point, entry, arg, suspend };
1129 wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
1130 }
1131
1132 /**********************************************************************
1133 * signal_start_process
1134 *
1135 * Process startup sequence:
1136 * signal_start_process()
1137 * -> thread_startup()
1138 * -> kernel32_start_process()
1139 */
1140 void signal_start_process( LPTHREAD_START_ROUTINE entry, BOOL suspend )
1141 {
1142 struct startup_info info = { kernel32_start_process, entry, NtCurrentTeb()->Peb, suspend };
1143 wine_switch_to_stack( thread_startup, &info, NtCurrentTeb()->Tib.StackBase );
1144 }
1145
1146 /***********************************************************************
1147 * signal_exit_thread
1148 */
1149 void signal_exit_thread( int status )
1150 {
1151 exit_thread( status );
1152 }
1153
1154 /***********************************************************************
1155 * signal_exit_process
1156 */
1157 void signal_exit_process( int status )
1158 {
1159 exit( status );
1160 }
1161
1162 /**********************************************************************
1163 * DbgBreakPoint (NTDLL.@)
1164 */
1165 void WINAPI DbgBreakPoint(void)
1166 {
1167 kill(getpid(), SIGTRAP);
1168 }
1169
1170 /**********************************************************************
1171 * DbgUserBreakPoint (NTDLL.@)
1172 */
1173 void WINAPI DbgUserBreakPoint(void)
1174 {
1175 kill(getpid(), SIGTRAP);
1176 }
1177
1178 /**********************************************************************
1179 * NtCurrentTeb (NTDLL.@)
1180 */
1181 TEB * WINAPI NtCurrentTeb(void)
1182 {
1183 return pthread_getspecific( teb_key );
1184 }
1185
1186 #endif /* __aarch64__ */
Windows API implementation