?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push e9c4c6cdd0babd7b2cb4288f191bb331b756eaf2
[wine/hacks.git] / dlls / ntdll / signal_x86_64.c
blob1748221e63dbdf535bd9dbb66f11e049a3b68c39
1 /*
2 * x86-64 signal handling routines
3 *
4 * Copyright 1999, 2005 Alexandre Julliard
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 __x86_64__
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34
35 #ifdef HAVE_SYS_PARAM_H
36 # include <sys/param.h>
37 #endif
38 #ifdef HAVE_SYS_SIGNAL_H
39 # include <sys/signal.h>
40 #endif
41
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
44 #include "ntstatus.h"
45 #define WIN32_NO_STATUS
46 #include "windef.h"
47 #include "winternl.h"
48 #include "wine/library.h"
49 #include "wine/exception.h"
50 #include "ntdll_misc.h"
51 #include "wine/debug.h"
52
53 WINE_DEFAULT_DEBUG_CHANNEL(seh);
54
55 struct _DISPATCHER_CONTEXT;
56
57 typedef LONG (WINAPI *PC_LANGUAGE_EXCEPTION_HANDLER)( EXCEPTION_POINTERS *ptrs, ULONG64 frame );
58 typedef EXCEPTION_DISPOSITION (WINAPI *PEXCEPTION_ROUTINE)( EXCEPTION_RECORD *rec,
59 ULONG64 frame,
60 CONTEXT *context,
61 struct _DISPATCHER_CONTEXT *dispatch );
62
63 typedef struct _DISPATCHER_CONTEXT
64 {
65 ULONG64 ControlPc;
66 ULONG64 ImageBase;
67 PRUNTIME_FUNCTION FunctionEntry;
68 ULONG64 EstablisherFrame;
69 ULONG64 TargetIp;
70 PCONTEXT ContextRecord;
71 PEXCEPTION_ROUTINE LanguageHandler;
72 PVOID HandlerData;
73 PUNWIND_HISTORY_TABLE HistoryTable;
74 ULONG ScopeIndex;
75 } DISPATCHER_CONTEXT, *PDISPATCHER_CONTEXT;
76
77 typedef struct _SCOPE_TABLE
78 {
79 ULONG Count;
80 struct
81 {
82 ULONG BeginAddress;
83 ULONG EndAddress;
84 ULONG HandlerAddress;
85 ULONG JumpTarget;
86 } ScopeRecord[1];
87 } SCOPE_TABLE, *PSCOPE_TABLE;
88
89
90 /***********************************************************************
91 * signal context platform-specific definitions
92 */
93 #ifdef linux
94
95 #include <asm/prctl.h>
96 extern int arch_prctl(int func, void *ptr);
97
98 #define RAX_sig(context) ((context)->uc_mcontext.gregs[REG_RAX])
99 #define RBX_sig(context) ((context)->uc_mcontext.gregs[REG_RBX])
100 #define RCX_sig(context) ((context)->uc_mcontext.gregs[REG_RCX])
101 #define RDX_sig(context) ((context)->uc_mcontext.gregs[REG_RDX])
102 #define RSI_sig(context) ((context)->uc_mcontext.gregs[REG_RSI])
103 #define RDI_sig(context) ((context)->uc_mcontext.gregs[REG_RDI])
104 #define RBP_sig(context) ((context)->uc_mcontext.gregs[REG_RBP])
105 #define R8_sig(context) ((context)->uc_mcontext.gregs[REG_R8])
106 #define R9_sig(context) ((context)->uc_mcontext.gregs[REG_R9])
107 #define R10_sig(context) ((context)->uc_mcontext.gregs[REG_R10])
108 #define R11_sig(context) ((context)->uc_mcontext.gregs[REG_R11])
109 #define R12_sig(context) ((context)->uc_mcontext.gregs[REG_R12])
110 #define R13_sig(context) ((context)->uc_mcontext.gregs[REG_R13])
111 #define R14_sig(context) ((context)->uc_mcontext.gregs[REG_R14])
112 #define R15_sig(context) ((context)->uc_mcontext.gregs[REG_R15])
113
114 #define CS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 0))
115 #define GS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 1))
116 #define FS_sig(context) (*((WORD *)&(context)->uc_mcontext.gregs[REG_CSGSFS] + 2))
117
118 #define RSP_sig(context) ((context)->uc_mcontext.gregs[REG_RSP])
119 #define RIP_sig(context) ((context)->uc_mcontext.gregs[REG_RIP])
120 #define EFL_sig(context) ((context)->uc_mcontext.gregs[REG_EFL])
121 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
122 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
123
124 #define FPU_sig(context) ((XMM_SAVE_AREA32 *)((context)->uc_mcontext.fpregs))
125
126 #endif /* linux */
127
128 #if defined(__NetBSD__)
129 # include <sys/ucontext.h>
130 # include <sys/types.h>
131 # include <signal.h>
132
133 #define RAX_sig(context) ((context)->uc_mcontext.__gregs[_REG_RAX])
134 #define RBX_sig(context) ((context)->uc_mcontext.__gregs[_REG_RBX])
135 #define RCX_sig(context) ((context)->uc_mcontext.__gregs[_REG_RCX])
136 #define RDX_sig(context) ((context)->uc_mcontext.__gregs[_REG_RDX])
137 #define RSI_sig(context) ((context)->uc_mcontext.__gregs[_REG_RSI])
138 #define RDI_sig(context) ((context)->uc_mcontext.__gregs[_REG_RDI])
139 #define RBP_sig(context) ((context)->uc_mcontext.__gregs[_REG_RBP])
140 #define R8_sig(context) ((context)->uc_mcontext.__gregs[_REG_R8])
141 #define R9_sig(context) ((context)->uc_mcontext.__gregs[_REG_R9])
142 #define R10_sig(context) ((context)->uc_mcontext.__gregs[_REG_R10])
143 #define R11_sig(context) ((context)->uc_mcontext.__gregs[_REG_R11])
144 #define R12_sig(context) ((context)->uc_mcontext.__gregs[_REG_R12])
145 #define R13_sig(context) ((context)->uc_mcontext.__gregs[_REG_R13])
146 #define R14_sig(context) ((context)->uc_mcontext.__gregs[_REG_R14])
147 #define R15_sig(context) ((context)->uc_mcontext.__gregs[_REG_R15])
148
149 #define CS_sig(context) ((context)->uc_mcontext.__gregs[_REG_CS])
150 #define DS_sig(context) ((context)->uc_mcontext.__gregs[_REG_DS])
151 #define ES_sig(context) ((context)->uc_mcontext.__gregs[_REG_ES])
152 #define FS_sig(context) ((context)->uc_mcontext.__gregs[_REG_FS])
153 #define GS_sig(context) ((context)->uc_mcontext.__gregs[_REG_GS])
154 #define SS_sig(context) ((context)->uc_mcontext.__gregs[_REG_SS])
155
156 #define EFL_sig(context) ((context)->uc_mcontext.__gregs[_REG_RFL])
157
158 #define RIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext.__gregs[_REG_RIP]))
159 #define RSP_sig(context) (*((unsigned long*)&(context)->uc_mcontext.__gregs[_REG_URSP]))
160
161 #define TRAP_sig(context) ((context)->uc_mcontext.__gregs[_REG_TRAPNO])
162 #define ERROR_sig(context) ((context)->uc_mcontext.__gregs[_REG_ERR])
163
164 #define FPU_sig(context) ((XMM_SAVE_AREA32 *)((context)->uc_mcontext.__fpregs))
165 #endif /* __NetBSD__ */
166
167 enum i386_trap_code
168 {
169 TRAP_x86_UNKNOWN = -1, /* Unknown fault (TRAP_sig not defined) */
170 TRAP_x86_DIVIDE = 0, /* Division by zero exception */
171 TRAP_x86_TRCTRAP = 1, /* Single-step exception */
172 TRAP_x86_NMI = 2, /* NMI interrupt */
173 TRAP_x86_BPTFLT = 3, /* Breakpoint exception */
174 TRAP_x86_OFLOW = 4, /* Overflow exception */
175 TRAP_x86_BOUND = 5, /* Bound range exception */
176 TRAP_x86_PRIVINFLT = 6, /* Invalid opcode exception */
177 TRAP_x86_DNA = 7, /* Device not available exception */
178 TRAP_x86_DOUBLEFLT = 8, /* Double fault exception */
179 TRAP_x86_FPOPFLT = 9, /* Coprocessor segment overrun */
180 TRAP_x86_TSSFLT = 10, /* Invalid TSS exception */
181 TRAP_x86_SEGNPFLT = 11, /* Segment not present exception */
182 TRAP_x86_STKFLT = 12, /* Stack fault */
183 TRAP_x86_PROTFLT = 13, /* General protection fault */
184 TRAP_x86_PAGEFLT = 14, /* Page fault */
185 TRAP_x86_ARITHTRAP = 16, /* Floating point exception */
186 TRAP_x86_ALIGNFLT = 17, /* Alignment check exception */
187 TRAP_x86_MCHK = 18, /* Machine check exception */
188 TRAP_x86_CACHEFLT = 19 /* Cache flush exception */
189 };
190
191 typedef int (*wine_signal_handler)(unsigned int sig);
192
193 static wine_signal_handler handlers[256];
194
195 /* definitions for unwind tables */
196
197 union handler_data
198 {
199 RUNTIME_FUNCTION chain;
200 ULONG handler;
201 };
202
203 struct opcode
204 {
205 BYTE offset;
206 BYTE code : 4;
207 BYTE info : 4;
208 };
209
210 struct UNWIND_INFO
211 {
212 BYTE version : 3;
213 BYTE flags : 5;
214 BYTE prolog;
215 BYTE count;
216 BYTE frame_reg : 4;
217 BYTE frame_offset : 4;
218 struct opcode opcodes[1]; /* info->count entries */
219 /* followed by handler_data */
220 };
221
222 #define UWOP_PUSH_NONVOL 0
223 #define UWOP_ALLOC_LARGE 1
224 #define UWOP_ALLOC_SMALL 2
225 #define UWOP_SET_FPREG 3
226 #define UWOP_SAVE_NONVOL 4
227 #define UWOP_SAVE_NONVOL_FAR 5
228 #define UWOP_SAVE_XMM128 8
229 #define UWOP_SAVE_XMM128_FAR 9
230 #define UWOP_PUSH_MACHFRAME 10
231
232 static void dump_unwind_info( ULONG64 base, RUNTIME_FUNCTION *function )
233 {
234 static const char * const reg_names[16] =
235 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
236 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" };
237
238 union handler_data *handler_data;
239 struct UNWIND_INFO *info;
240 unsigned int i, count;
241
242 TRACE( "**** func %x-%x\n", function->BeginAddress, function->EndAddress );
243 for (;;)
244 {
245 if (function->UnwindData & 1)
246 {
247 RUNTIME_FUNCTION *next = (RUNTIME_FUNCTION *)((char *)base + (function->UnwindData & ~1));
248 TRACE( "unwind info for function %p-%p chained to function %p-%p\n",
249 (char *)base + function->BeginAddress, (char *)base + function->EndAddress,
250 (char *)base + next->BeginAddress, (char *)base + next->EndAddress );
251 function = next;
252 continue;
253 }
254 info = (struct UNWIND_INFO *)((char *)base + function->UnwindData);
255
256 TRACE( "unwind info at %p flags %x prolog 0x%x bytes function %p-%p\n",
257 info, info->flags, info->prolog,
258 (char *)base + function->BeginAddress, (char *)base + function->EndAddress );
259
260 if (info->frame_reg)
261 TRACE( " frame register %s offset 0x%x(%%rsp)\n",
262 reg_names[info->frame_reg], info->frame_offset * 16 );
263
264 for (i = 0; i < info->count; i++)
265 {
266 TRACE( " 0x%x: ", info->opcodes[i].offset );
267 switch (info->opcodes[i].code)
268 {
269 case UWOP_PUSH_NONVOL:
270 TRACE( "pushq %%%s\n", reg_names[info->opcodes[i].info] );
271 break;
272 case UWOP_ALLOC_LARGE:
273 if (info->opcodes[i].info)
274 {
275 count = *(DWORD *)&info->opcodes[i+1];
276 i += 2;
277 }
278 else
279 {
280 count = *(USHORT *)&info->opcodes[i+1] * 8;
281 i++;
282 }
283 TRACE( "subq $0x%x,%%rsp\n", count );
284 break;
285 case UWOP_ALLOC_SMALL:
286 count = (info->opcodes[i].info + 1) * 8;
287 TRACE( "subq $0x%x,%%rsp\n", count );
288 break;
289 case UWOP_SET_FPREG:
290 TRACE( "leaq 0x%x(%%rsp),%s\n",
291 info->frame_offset * 16, reg_names[info->frame_reg] );
292 break;
293 case UWOP_SAVE_NONVOL:
294 count = *(USHORT *)&info->opcodes[i+1] * 8;
295 TRACE( "movq %%%s,0x%x(%%rsp)\n", reg_names[info->opcodes[i].info], count );
296 i++;
297 break;
298 case UWOP_SAVE_NONVOL_FAR:
299 count = *(DWORD *)&info->opcodes[i+1];
300 TRACE( "movq %%%s,0x%x(%%rsp)\n", reg_names[info->opcodes[i].info], count );
301 i += 2;
302 break;
303 case UWOP_SAVE_XMM128:
304 count = *(USHORT *)&info->opcodes[i+1] * 16;
305 TRACE( "movaps %%xmm%u,0x%x(%%rsp)\n", info->opcodes[i].info, count );
306 i++;
307 break;
308 case UWOP_SAVE_XMM128_FAR:
309 count = *(DWORD *)&info->opcodes[i+1];
310 TRACE( "movaps %%xmm%u,0x%x(%%rsp)\n", info->opcodes[i].info, count );
311 i += 2;
312 break;
313 case UWOP_PUSH_MACHFRAME:
314 TRACE( "PUSH_MACHFRAME %u\n", info->opcodes[i].info );
315 break;
316 default:
317 FIXME( "unknown code %u\n", info->opcodes[i].code );
318 break;
319 }
320 }
321
322 handler_data = (union handler_data *)&info->opcodes[(info->count + 1) & ~1];
323 if (info->flags & UNW_FLAG_CHAININFO)
324 {
325 TRACE( " chained to function %p-%p\n",
326 (char *)base + handler_data->chain.BeginAddress,
327 (char *)base + handler_data->chain.EndAddress );
328 function = &handler_data->chain;
329 continue;
330 }
331 if (info->flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
332 TRACE( " handler %p data at %p\n",
333 (char *)base + handler_data->handler, &handler_data->handler + 1 );
334 break;
335 }
336 }
337
338 static void dump_scope_table( ULONG64 base, const SCOPE_TABLE *table )
339 {
340 unsigned int i;
341
342 TRACE( "scope table at %p\n", table );
343 for (i = 0; i < table->Count; i++)
344 TRACE( " %u: %lx-%lx handler %lx target %lx\n", i,
345 base + table->ScopeRecord[i].BeginAddress,
346 base + table->ScopeRecord[i].EndAddress,
347 base + table->ScopeRecord[i].HandlerAddress,
348 base + table->ScopeRecord[i].JumpTarget );
349 }
350
351 /***********************************************************************
352 * dispatch_signal
353 */
354 static inline int dispatch_signal(unsigned int sig)
355 {
356 if (handlers[sig] == NULL) return 0;
357 return handlers[sig](sig);
358 }
359
360 /***********************************************************************
361 * save_context
362 *
363 * Set the register values from a sigcontext.
364 */
365 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
366 {
367 context->ContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS;
368 context->Rax = RAX_sig(sigcontext);
369 context->Rcx = RCX_sig(sigcontext);
370 context->Rdx = RDX_sig(sigcontext);
371 context->Rbx = RBX_sig(sigcontext);
372 context->Rsp = RSP_sig(sigcontext);
373 context->Rbp = RBP_sig(sigcontext);
374 context->Rsi = RSI_sig(sigcontext);
375 context->Rdi = RDI_sig(sigcontext);
376 context->R8 = R8_sig(sigcontext);
377 context->R9 = R9_sig(sigcontext);
378 context->R10 = R10_sig(sigcontext);
379 context->R11 = R11_sig(sigcontext);
380 context->R12 = R12_sig(sigcontext);
381 context->R13 = R13_sig(sigcontext);
382 context->R14 = R14_sig(sigcontext);
383 context->R15 = R15_sig(sigcontext);
384 context->Rip = RIP_sig(sigcontext);
385 context->SegCs = CS_sig(sigcontext);
386 context->SegFs = FS_sig(sigcontext);
387 context->SegGs = GS_sig(sigcontext);
388 context->EFlags = EFL_sig(sigcontext);
389 #ifdef DS_sig
390 context->SegDs = DS_sig(sigcontext);
391 #else
392 __asm__("movw %%ds,%0" : "=m" (context->SegDs));
393 #endif
394 #ifdef ES_sig
395 context->SegEs = ES_sig(sigcontext);
396 #else
397 __asm__("movw %%es,%0" : "=m" (context->SegEs));
398 #endif
399 #ifdef SS_sig
400 context->SegSs = SS_sig(sigcontext);
401 #else
402 __asm__("movw %%ss,%0" : "=m" (context->SegSs));
403 #endif
404 context->MxCsr = 0; /* FIXME */
405 if (FPU_sig(sigcontext))
406 {
407 context->ContextFlags |= CONTEXT_FLOATING_POINT;
408 context->u.FltSave = *FPU_sig(sigcontext);
409 }
410 }
411
412
413 /***********************************************************************
414 * restore_context
415 *
416 * Build a sigcontext from the register values.
417 */
418 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
419 {
420 RAX_sig(sigcontext) = context->Rax;
421 RCX_sig(sigcontext) = context->Rcx;
422 RDX_sig(sigcontext) = context->Rdx;
423 RBX_sig(sigcontext) = context->Rbx;
424 RSP_sig(sigcontext) = context->Rsp;
425 RBP_sig(sigcontext) = context->Rbp;
426 RSI_sig(sigcontext) = context->Rsi;
427 RDI_sig(sigcontext) = context->Rdi;
428 R8_sig(sigcontext) = context->R8;
429 R9_sig(sigcontext) = context->R9;
430 R10_sig(sigcontext) = context->R10;
431 R11_sig(sigcontext) = context->R11;
432 R12_sig(sigcontext) = context->R12;
433 R13_sig(sigcontext) = context->R13;
434 R14_sig(sigcontext) = context->R14;
435 R15_sig(sigcontext) = context->R15;
436 RIP_sig(sigcontext) = context->Rip;
437 CS_sig(sigcontext) = context->SegCs;
438 FS_sig(sigcontext) = context->SegFs;
439 GS_sig(sigcontext) = context->SegGs;
440 EFL_sig(sigcontext) = context->EFlags;
441 #ifdef DS_sig
442 DS_sig(sigcontext) = context->SegDs;
443 #endif
444 #ifdef ES_sig
445 ES_sig(sigcontext) = context->SegEs;
446 #endif
447 #ifdef SS_sig
448 SS_sig(sigcontext) = context->SegSs;
449 #endif
450 if (FPU_sig(sigcontext)) *FPU_sig(sigcontext) = context->u.FltSave;
451 }
452
453
454 /***********************************************************************
455 * RtlCaptureContext (NTDLL.@)
456 */
457 void WINAPI __regs_RtlCaptureContext( CONTEXT *context, CONTEXT *regs )
458 {
459 *context = *regs;
460 }
461 DEFINE_REGS_ENTRYPOINT( RtlCaptureContext, 1 )
462
463
464 /***********************************************************************
465 * set_cpu_context
466 *
467 * Set the new CPU context.
468 */
469 void set_cpu_context( const CONTEXT *context )
470 {
471 extern void CDECL __wine_restore_regs( const CONTEXT * ) DECLSPEC_NORETURN;
472 __wine_restore_regs( context );
473 }
474
475
476 /***********************************************************************
477 * copy_context
478 *
479 * Copy a register context according to the flags.
480 */
481 void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
482 {
483 flags &= ~CONTEXT_AMD64; /* get rid of CPU id */
484 if (flags & CONTEXT_CONTROL)
485 {
486 to->Rbp = from->Rbp;
487 to->Rip = from->Rip;
488 to->Rsp = from->Rsp;
489 to->SegCs = from->SegCs;
490 to->SegSs = from->SegSs;
491 to->EFlags = from->EFlags;
492 to->MxCsr = from->MxCsr;
493 }
494 if (flags & CONTEXT_INTEGER)
495 {
496 to->Rax = from->Rax;
497 to->Rcx = from->Rcx;
498 to->Rdx = from->Rdx;
499 to->Rbx = from->Rbx;
500 to->Rsi = from->Rsi;
501 to->Rdi = from->Rdi;
502 to->R8 = from->R8;
503 to->R9 = from->R9;
504 to->R10 = from->R10;
505 to->R11 = from->R11;
506 to->R12 = from->R12;
507 to->R13 = from->R13;
508 to->R14 = from->R14;
509 to->R15 = from->R15;
510 }
511 if (flags & CONTEXT_SEGMENTS)
512 {
513 to->SegDs = from->SegDs;
514 to->SegEs = from->SegEs;
515 to->SegFs = from->SegFs;
516 to->SegGs = from->SegGs;
517 }
518 if (flags & CONTEXT_FLOATING_POINT)
519 {
520 to->u.FltSave = from->u.FltSave;
521 }
522 if (flags & CONTEXT_DEBUG_REGISTERS)
523 {
524 to->Dr0 = from->Dr0;
525 to->Dr1 = from->Dr1;
526 to->Dr2 = from->Dr2;
527 to->Dr3 = from->Dr3;
528 to->Dr6 = from->Dr6;
529 to->Dr7 = from->Dr7;
530 }
531 }
532
533
534 /***********************************************************************
535 * context_to_server
536 *
537 * Convert a register context to the server format.
538 */
539 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
540 {
541 DWORD flags = from->ContextFlags & ~CONTEXT_AMD64; /* get rid of CPU id */
542
543 memset( to, 0, sizeof(*to) );
544 to->cpu = CPU_x86_64;
545
546 if (flags & CONTEXT_CONTROL)
547 {
548 to->flags |= SERVER_CTX_CONTROL;
549 to->ctl.x86_64_regs.rbp = from->Rbp;
550 to->ctl.x86_64_regs.rip = from->Rip;
551 to->ctl.x86_64_regs.rsp = from->Rsp;
552 to->ctl.x86_64_regs.cs = from->SegCs;
553 to->ctl.x86_64_regs.ss = from->SegSs;
554 to->ctl.x86_64_regs.flags = from->EFlags;
555 to->ctl.x86_64_regs.mxcsr = from->MxCsr;
556 }
557 if (flags & CONTEXT_INTEGER)
558 {
559 to->flags |= SERVER_CTX_INTEGER;
560 to->integer.x86_64_regs.rax = from->Rax;
561 to->integer.x86_64_regs.rcx = from->Rcx;
562 to->integer.x86_64_regs.rdx = from->Rdx;
563 to->integer.x86_64_regs.rbx = from->Rbx;
564 to->integer.x86_64_regs.rsi = from->Rsi;
565 to->integer.x86_64_regs.rdi = from->Rdi;
566 to->integer.x86_64_regs.r8 = from->R8;
567 to->integer.x86_64_regs.r9 = from->R9;
568 to->integer.x86_64_regs.r10 = from->R10;
569 to->integer.x86_64_regs.r11 = from->R11;
570 to->integer.x86_64_regs.r12 = from->R12;
571 to->integer.x86_64_regs.r13 = from->R13;
572 to->integer.x86_64_regs.r14 = from->R14;
573 to->integer.x86_64_regs.r15 = from->R15;
574 }
575 if (flags & CONTEXT_SEGMENTS)
576 {
577 to->flags |= SERVER_CTX_SEGMENTS;
578 to->seg.x86_64_regs.ds = from->SegDs;
579 to->seg.x86_64_regs.es = from->SegEs;
580 to->seg.x86_64_regs.fs = from->SegFs;
581 to->seg.x86_64_regs.gs = from->SegGs;
582 }
583 if (flags & CONTEXT_FLOATING_POINT)
584 {
585 to->flags |= SERVER_CTX_FLOATING_POINT;
586 memcpy( to->fp.x86_64_regs.fpregs, &from->u.FltSave, sizeof(to->fp.x86_64_regs.fpregs) );
587 }
588 if (flags & CONTEXT_DEBUG_REGISTERS)
589 {
590 to->flags |= SERVER_CTX_DEBUG_REGISTERS;
591 to->debug.x86_64_regs.dr0 = from->Dr0;
592 to->debug.x86_64_regs.dr1 = from->Dr1;
593 to->debug.x86_64_regs.dr2 = from->Dr2;
594 to->debug.x86_64_regs.dr3 = from->Dr3;
595 to->debug.x86_64_regs.dr6 = from->Dr6;
596 to->debug.x86_64_regs.dr7 = from->Dr7;
597 }
598 return STATUS_SUCCESS;
599 }
600
601
602 /***********************************************************************
603 * context_from_server
604 *
605 * Convert a register context from the server format.
606 */
607 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
608 {
609 if (from->cpu != CPU_x86_64) return STATUS_INVALID_PARAMETER;
610
611 to->ContextFlags = CONTEXT_AMD64;
612 if (from->flags & SERVER_CTX_CONTROL)
613 {
614 to->ContextFlags |= CONTEXT_CONTROL;
615 to->Rbp = from->ctl.x86_64_regs.rbp;
616 to->Rip = from->ctl.x86_64_regs.rip;
617 to->Rsp = from->ctl.x86_64_regs.rsp;
618 to->SegCs = from->ctl.x86_64_regs.cs;
619 to->SegSs = from->ctl.x86_64_regs.ss;
620 to->EFlags = from->ctl.x86_64_regs.flags;
621 to->MxCsr = from->ctl.x86_64_regs.mxcsr;
622 }
623
624 if (from->flags & SERVER_CTX_INTEGER)
625 {
626 to->ContextFlags |= CONTEXT_INTEGER;
627 to->Rax = from->integer.x86_64_regs.rax;
628 to->Rcx = from->integer.x86_64_regs.rcx;
629 to->Rdx = from->integer.x86_64_regs.rdx;
630 to->Rbx = from->integer.x86_64_regs.rbx;
631 to->Rsi = from->integer.x86_64_regs.rsi;
632 to->Rdi = from->integer.x86_64_regs.rdi;
633 to->R8 = from->integer.x86_64_regs.r8;
634 to->R9 = from->integer.x86_64_regs.r9;
635 to->R10 = from->integer.x86_64_regs.r10;
636 to->R11 = from->integer.x86_64_regs.r11;
637 to->R12 = from->integer.x86_64_regs.r12;
638 to->R13 = from->integer.x86_64_regs.r13;
639 to->R14 = from->integer.x86_64_regs.r14;
640 to->R15 = from->integer.x86_64_regs.r15;
641 }
642 if (from->flags & SERVER_CTX_SEGMENTS)
643 {
644 to->ContextFlags |= CONTEXT_SEGMENTS;
645 to->SegDs = from->seg.x86_64_regs.ds;
646 to->SegEs = from->seg.x86_64_regs.es;
647 to->SegFs = from->seg.x86_64_regs.fs;
648 to->SegGs = from->seg.x86_64_regs.gs;
649 }
650 if (from->flags & SERVER_CTX_FLOATING_POINT)
651 {
652 to->ContextFlags |= CONTEXT_FLOATING_POINT;
653 memcpy( &to->u.FltSave, from->fp.x86_64_regs.fpregs, sizeof(from->fp.x86_64_regs.fpregs) );
654 }
655 if (from->flags & SERVER_CTX_DEBUG_REGISTERS)
656 {
657 to->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
658 to->Dr0 = from->debug.x86_64_regs.dr0;
659 to->Dr1 = from->debug.x86_64_regs.dr1;
660 to->Dr2 = from->debug.x86_64_regs.dr2;
661 to->Dr3 = from->debug.x86_64_regs.dr3;
662 to->Dr6 = from->debug.x86_64_regs.dr6;
663 to->Dr7 = from->debug.x86_64_regs.dr7;
664 }
665 return STATUS_SUCCESS;
666 }
667
668
669 /**********************************************************************
670 * find_function_info
671 */
672 static RUNTIME_FUNCTION *find_function_info( ULONG64 pc, HMODULE module,
673 RUNTIME_FUNCTION *func, ULONG size )
674 {
675 int min = 0;
676 int max = size/sizeof(*func) - 1;
677
678 while (min <= max)
679 {
680 int pos = (min + max) / 2;
681 if ((char *)pc < (char *)module + func[pos].BeginAddress) max = pos - 1;
682 else if ((char *)pc >= (char *)module + func[pos].EndAddress) min = pos + 1;
683 else
684 {
685 func += pos;
686 while (func->UnwindData & 1) /* follow chained entry */
687 func = (RUNTIME_FUNCTION *)((char *)module + (func->UnwindData & ~1));
688 return func;
689 }
690 }
691 return NULL;
692 }
693
694 /**********************************************************************
695 * call_stack_handlers
696 *
697 * Call the stack handlers chain.
698 */
699 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *orig_context )
700 {
701 EXCEPTION_POINTERS ptrs;
702 UNWIND_HISTORY_TABLE table;
703 ULONG64 frame;
704 RUNTIME_FUNCTION *dir, *info;
705 PEXCEPTION_ROUTINE handler;
706 DISPATCHER_CONTEXT dispatch;
707 CONTEXT context, new_context;
708 LDR_MODULE *module;
709 DWORD size;
710
711 context = *orig_context;
712 for (;;)
713 {
714 /* FIXME: should use the history table to make things faster */
715
716 if (LdrFindEntryForAddress( (void *)context.Rip, &module ))
717 {
718 ERR( "no module found for rip %p, can't dispatch exception\n", (void *)context.Rip );
719 break;
720 }
721 if (!(dir = RtlImageDirectoryEntryToData( module->BaseAddress, TRUE,
722 IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size )))
723 {
724 ERR( "module %s doesn't contain exception data, can't dispatch exception\n",
725 debugstr_w(module->BaseDllName.Buffer) );
726 break;
727 }
728 if (!(info = find_function_info( context.Rip, module->BaseAddress, dir, size )))
729 {
730 /* leaf function */
731 context.Rip = *(ULONG64 *)context.Rsp;
732 context.Rsp += sizeof(ULONG64);
733 continue;
734 }
735
736 new_context = context;
737
738 handler = RtlVirtualUnwind( UNW_FLAG_EHANDLER, (ULONG64)module->BaseAddress, context.Rip,
739 info, &new_context, &dispatch.HandlerData, &frame, NULL );
740
741 if ((frame & 7) ||
742 frame < (ULONG64)NtCurrentTeb()->Tib.StackLimit ||
743 frame >= (ULONG64)NtCurrentTeb()->Tib.StackBase)
744 {
745 ERR( "invalid frame %lx\n", frame );
746 rec->ExceptionFlags |= EH_STACK_INVALID;
747 break;
748 }
749
750 if (handler)
751 {
752 dispatch.ControlPc = context.Rip;
753 dispatch.ImageBase = (ULONG64)module->BaseAddress;
754 dispatch.FunctionEntry = info;
755 dispatch.EstablisherFrame = frame;
756 dispatch.TargetIp = 0; /* FIXME */
757 dispatch.ContextRecord = &context;
758 dispatch.LanguageHandler = handler;
759 dispatch.HistoryTable = &table;
760 dispatch.ScopeIndex = 0; /* FIXME */
761
762 TRACE( "calling handler %p (rec=%p, frame=%lx context=%p, dispatch=%p)\n",
763 handler, rec, frame, &context, &dispatch );
764
765 switch( handler( rec, frame, &context, &dispatch ))
766 {
767 case ExceptionContinueExecution:
768 if (rec->ExceptionFlags & EH_NONCONTINUABLE) return STATUS_NONCONTINUABLE_EXCEPTION;
769 *orig_context = context;
770 return STATUS_SUCCESS;
771 case ExceptionContinueSearch:
772 break;
773 case ExceptionNestedException:
774 break;
775 default:
776 return STATUS_INVALID_DISPOSITION;
777 }
778 }
779 context = new_context;
780 }
781
782 /* hack: call unhandled exception filter directly */
783 ptrs.ExceptionRecord = rec;
784 ptrs.ContextRecord = orig_context;
785 unhandled_exception_filter( &ptrs );
786 return STATUS_UNHANDLED_EXCEPTION;
787 }
788
789
790 /*******************************************************************
791 * raise_exception
792 *
793 * Implementation of NtRaiseException.
794 */
795 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
796 {
797 NTSTATUS status;
798
799 if (first_chance)
800 {
801 DWORD c;
802
803 TRACE( "code=%x flags=%x addr=%p ip=%lx tid=%04x\n",
804 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
805 context->Rip, GetCurrentThreadId() );
806 for (c = 0; c < min( EXCEPTION_MAXIMUM_PARAMETERS, rec->NumberParameters ); c++)
807 TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
808 if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
809 {
810 if (rec->ExceptionInformation[1] >> 16)
811 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
812 rec->ExceptionAddress,
813 (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
814 else
815 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
816 rec->ExceptionAddress,
817 (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
818 }
819 else
820 {
821 TRACE(" rax=%016lx rbx=%016lx rcx=%016lx rdx=%016lx\n",
822 context->Rax, context->Rbx, context->Rcx, context->Rdx );
823 TRACE(" rsi=%016lx rdi=%016lx rbp=%016lx rsp=%016lx\n",
824 context->Rsi, context->Rdi, context->Rbp, context->Rsp );
825 TRACE(" r8=%016lx r9=%016lx r10=%016lx r11=%016lx\n",
826 context->R8, context->R9, context->R10, context->R11 );
827 TRACE(" r12=%016lx r13=%016lx r14=%016lx r15=%016lx\n",
828 context->R12, context->R13, context->R14, context->R15 );
829 }
830 status = send_debug_event( rec, TRUE, context );
831 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
832 return STATUS_SUCCESS;
833
834 if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
835 return STATUS_SUCCESS;
836
837 if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
838 return status;
839 }
840
841 /* last chance exception */
842
843 status = send_debug_event( rec, FALSE, context );
844 if (status != DBG_CONTINUE)
845 {
846 if (rec->ExceptionFlags & EH_STACK_INVALID)
847 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
848 else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
849 ERR("Process attempted to continue execution after noncontinuable exception.\n");
850 else
851 ERR("Unhandled exception code %x flags %x addr %p\n",
852 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
853 NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
854 }
855 return STATUS_SUCCESS;
856 }
857
858
859 /**********************************************************************
860 * segv_handler
861 *
862 * Handler for SIGSEGV and related errors.
863 */
864 static void segv_handler( int signal, siginfo_t *siginfo, void *sigcontext )
865 {
866 EXCEPTION_RECORD rec;
867 CONTEXT context;
868 NTSTATUS status;
869 ucontext_t *ucontext = sigcontext;
870
871 save_context( &context, ucontext );
872
873 rec.ExceptionRecord = NULL;
874 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
875 rec.ExceptionAddress = (LPVOID)context.Rip;
876 rec.NumberParameters = 0;
877
878 switch(TRAP_sig(ucontext))
879 {
880 case TRAP_x86_OFLOW: /* Overflow exception */
881 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
882 break;
883 case TRAP_x86_BOUND: /* Bound range exception */
884 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
885 break;
886 case TRAP_x86_PRIVINFLT: /* Invalid opcode exception */
887 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
888 break;
889 case TRAP_x86_STKFLT: /* Stack fault */
890 rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
891 break;
892 case TRAP_x86_SEGNPFLT: /* Segment not present exception */
893 case TRAP_x86_PROTFLT: /* General protection fault */
894 case TRAP_x86_UNKNOWN: /* Unknown fault code */
895 rec.ExceptionCode = ERROR_sig(ucontext) ? EXCEPTION_ACCESS_VIOLATION
896 : EXCEPTION_PRIV_INSTRUCTION;
897 break;
898 case TRAP_x86_PAGEFLT: /* Page fault */
899 rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
900 rec.NumberParameters = 2;
901 rec.ExceptionInformation[0] = (ERROR_sig(ucontext) & 2) != 0;
902 rec.ExceptionInformation[1] = (ULONG_PTR)siginfo->si_addr;
903 if (!(rec.ExceptionCode = virtual_handle_fault( siginfo->si_addr, rec.ExceptionInformation[0] )))
904 goto done;
905 break;
906 case TRAP_x86_ALIGNFLT: /* Alignment check exception */
907 rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
908 break;
909 default:
910 ERR( "Got unexpected trap %ld\n", TRAP_sig(ucontext) );
911 /* fall through */
912 case TRAP_x86_NMI: /* NMI interrupt */
913 case TRAP_x86_DNA: /* Device not available exception */
914 case TRAP_x86_DOUBLEFLT: /* Double fault exception */
915 case TRAP_x86_TSSFLT: /* Invalid TSS exception */
916 case TRAP_x86_MCHK: /* Machine check exception */
917 case TRAP_x86_CACHEFLT: /* Cache flush exception */
918 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
919 break;
920 }
921
922 status = raise_exception( &rec, &context, TRUE );
923 if (status) raise_status( status, &rec );
924 done:
925 restore_context( &context, ucontext );
926 }
927
928 /**********************************************************************
929 * trap_handler
930 *
931 * Handler for SIGTRAP.
932 */
933 static void trap_handler( int signal, siginfo_t *siginfo, void *sigcontext )
934 {
935 EXCEPTION_RECORD rec;
936 CONTEXT context;
937 NTSTATUS status;
938 ucontext_t *ucontext = sigcontext;
939
940 save_context( &context, ucontext );
941 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
942 rec.ExceptionRecord = NULL;
943 rec.ExceptionAddress = (LPVOID)context.Rip;
944 rec.NumberParameters = 0;
945
946 switch (siginfo->si_code)
947 {
948 case TRAP_TRACE: /* Single-step exception */
949 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
950 EFL_sig(ucontext) &= ~0x100; /* clear single-step flag */
951 break;
952 case TRAP_BRKPT: /* Breakpoint exception */
953 rec.ExceptionAddress = (char *)rec.ExceptionAddress - 1; /* back up over the int3 instruction */
954 /* fall through */
955 default:
956 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
957 break;
958 }
959
960 status = raise_exception( &rec, &context, TRUE );
961 if (status) raise_status( status, &rec );
962 restore_context( &context, ucontext );
963 }
964
965 /**********************************************************************
966 * fpe_handler
967 *
968 * Handler for SIGFPE.
969 */
970 static void fpe_handler( int signal, siginfo_t *siginfo, void *ucontext )
971 {
972 EXCEPTION_RECORD rec;
973 CONTEXT context;
974 NTSTATUS status;
975
976 save_context( &context, ucontext );
977 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
978 rec.ExceptionRecord = NULL;
979 rec.ExceptionAddress = (LPVOID)context.Rip;
980 rec.NumberParameters = 0;
981
982 switch (siginfo->si_code)
983 {
984 case FPE_FLTSUB:
985 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
986 break;
987 case FPE_INTDIV:
988 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
989 break;
990 case FPE_INTOVF:
991 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
992 break;
993 case FPE_FLTDIV:
994 rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
995 break;
996 case FPE_FLTOVF:
997 rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
998 break;
999 case FPE_FLTUND:
1000 rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
1001 break;
1002 case FPE_FLTRES:
1003 rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
1004 break;
1005 case FPE_FLTINV:
1006 default:
1007 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
1008 break;
1009 }
1010
1011 status = raise_exception( &rec, &context, TRUE );
1012 if (status) raise_status( status, &rec );
1013 restore_context( &context, ucontext );
1014 }
1015
1016 /**********************************************************************
1017 * int_handler
1018 *
1019 * Handler for SIGINT.
1020 */
1021 static void int_handler( int signal, siginfo_t *siginfo, void *ucontext )
1022 {
1023 if (!dispatch_signal(SIGINT))
1024 {
1025 EXCEPTION_RECORD rec;
1026 CONTEXT context;
1027 NTSTATUS status;
1028
1029 save_context( &context, ucontext );
1030 rec.ExceptionCode = CONTROL_C_EXIT;
1031 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
1032 rec.ExceptionRecord = NULL;
1033 rec.ExceptionAddress = (LPVOID)context.Rip;
1034 rec.NumberParameters = 0;
1035 status = raise_exception( &rec, &context, TRUE );
1036 if (status) raise_status( status, &rec );
1037 restore_context( &context, ucontext );
1038 }
1039 }
1040
1041
1042 /**********************************************************************
1043 * abrt_handler
1044 *
1045 * Handler for SIGABRT.
1046 */
1047 static void abrt_handler( int signal, siginfo_t *siginfo, void *ucontext )
1048 {
1049 EXCEPTION_RECORD rec;
1050 CONTEXT context;
1051 NTSTATUS status;
1052
1053 save_context( &context, ucontext );
1054 rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
1055 rec.ExceptionFlags = EH_NONCONTINUABLE;
1056 rec.ExceptionRecord = NULL;
1057 rec.ExceptionAddress = (LPVOID)context.Rip;
1058 rec.NumberParameters = 0;
1059 status = raise_exception( &rec, &context, TRUE );
1060 if (status) raise_status( status, &rec );
1061 restore_context( &context, ucontext );
1062 }
1063
1064
1065 /**********************************************************************
1066 * quit_handler
1067 *
1068 * Handler for SIGQUIT.
1069 */
1070 static void quit_handler( int signal, siginfo_t *siginfo, void *ucontext )
1071 {
1072 abort_thread(0);
1073 }
1074
1075
1076 /**********************************************************************
1077 * usr1_handler
1078 *
1079 * Handler for SIGUSR1, used to signal a thread that it got suspended.
1080 */
1081 static void usr1_handler( int signal, siginfo_t *siginfo, void *ucontext )
1082 {
1083 CONTEXT context;
1084
1085 save_context( &context, ucontext );
1086 wait_suspend( &context );
1087 restore_context( &context, ucontext );
1088 }
1089
1090
1091 /**********************************************************************
1092 * get_signal_stack_total_size
1093 *
1094 * Retrieve the size to allocate for the signal stack, including the TEB at the bottom.
1095 * Must be a power of two.
1096 */
1097 size_t get_signal_stack_total_size(void)
1098 {
1099 assert( sizeof(TEB) <= 2*getpagesize() );
1100 return 2*getpagesize(); /* this is just for the TEB, we don't need a signal stack */
1101 }
1102
1103
1104 /***********************************************************************
1105 * __wine_set_signal_handler (NTDLL.@)
1106 */
1107 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
1108 {
1109 if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
1110 if (handlers[sig] != NULL) return -2;
1111 handlers[sig] = wsh;
1112 return 0;
1113 }
1114
1115
1116 /**********************************************************************
1117 * signal_init_thread
1118 */
1119 void signal_init_thread( TEB *teb )
1120 {
1121 #ifdef __linux__
1122 arch_prctl( ARCH_SET_GS, teb );
1123 #else
1124 # error Please define setting %gs for your architecture
1125 #endif
1126 }
1127
1128 /**********************************************************************
1129 * signal_init_process
1130 */
1131 void signal_init_process(void)
1132 {
1133 struct sigaction sig_act;
1134
1135 sig_act.sa_mask = server_block_set;
1136 sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
1137
1138 sig_act.sa_sigaction = int_handler;
1139 if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
1140 sig_act.sa_sigaction = fpe_handler;
1141 if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
1142 sig_act.sa_sigaction = abrt_handler;
1143 if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
1144 sig_act.sa_sigaction = quit_handler;
1145 if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
1146 sig_act.sa_sigaction = usr1_handler;
1147 if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
1148
1149 sig_act.sa_sigaction = segv_handler;
1150 if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
1151 if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
1152 #ifdef SIGBUS
1153 if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
1154 #endif
1155
1156 #ifdef SIGTRAP
1157 sig_act.sa_sigaction = trap_handler;
1158 if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
1159 #endif
1160 return;
1161
1162 error:
1163 perror("sigaction");
1164 exit(1);
1165 }
1166
1167
1168 /**********************************************************************
1169 * RtlLookupFunctionEntry (NTDLL.@)
1170 */
1171 PRUNTIME_FUNCTION WINAPI RtlLookupFunctionEntry( ULONG64 pc, ULONG64 *base, UNWIND_HISTORY_TABLE *table )
1172 {
1173 LDR_MODULE *module;
1174 RUNTIME_FUNCTION *func;
1175 ULONG size;
1176
1177 /* FIXME: should use the history table to make things faster */
1178
1179 if (LdrFindEntryForAddress( (void *)pc, &module ))
1180 {
1181 WARN( "module not found for %lx\n", pc );
1182 return NULL;
1183 }
1184 if (!(func = RtlImageDirectoryEntryToData( module->BaseAddress, TRUE,
1185 IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size )))
1186 {
1187 WARN( "no exception table found in module %p pc %lx\n", module->BaseAddress, pc );
1188 return NULL;
1189 }
1190 func = find_function_info( pc, module->BaseAddress, func, size );
1191 if (func) *base = (ULONG64)module->BaseAddress;
1192 return func;
1193 }
1194
1195 static ULONG64 get_int_reg( CONTEXT *context, int reg )
1196 {
1197 return *(&context->Rax + reg);
1198 }
1199
1200 static void set_int_reg( CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *ctx_ptr, int reg, ULONG64 val )
1201 {
1202 *(&context->Rax + reg) = val;
1203 if (ctx_ptr) ctx_ptr->u2.IntegerContext[reg] = &context->Rax + reg;
1204 }
1205
1206 static void set_float_reg( CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *ctx_ptr, int reg, M128A val )
1207 {
1208 *(&context->u.s.Xmm0 + reg) = val;
1209 if (ctx_ptr) ctx_ptr->u1.FloatingContext[reg] = &context->u.s.Xmm0 + reg;
1210 }
1211
1212 static int get_opcode_size( struct opcode op )
1213 {
1214 switch (op.code)
1215 {
1216 case UWOP_ALLOC_LARGE:
1217 return 2 + (op.info != 0);
1218 case UWOP_SAVE_NONVOL:
1219 case UWOP_SAVE_XMM128:
1220 return 2;
1221 case UWOP_SAVE_NONVOL_FAR:
1222 case UWOP_SAVE_XMM128_FAR:
1223 return 3;
1224 default:
1225 return 1;
1226 }
1227 }
1228
1229 static BOOL is_inside_epilog( BYTE *pc )
1230 {
1231 /* add or lea must be the first instruction, and it must have a rex.W prefix */
1232 if ((pc[0] & 0xf8) == 0x48)
1233 {
1234 switch (pc[1])
1235 {
1236 case 0x81: /* add $nnnn,%rsp */
1237 if (pc[0] == 0x48 && pc[2] == 0xc4)
1238 {
1239 pc += 7;
1240 break;
1241 }
1242 return FALSE;
1243 case 0x83: /* add $n,%rsp */
1244 if (pc[0] == 0x48 && pc[2] == 0xc4)
1245 {
1246 pc += 4;
1247 break;
1248 }
1249 return FALSE;
1250 case 0x8d: /* lea n(reg),%rsp */
1251 if (pc[0] & 0x06) return FALSE; /* rex.RX must be cleared */
1252 if (((pc[2] >> 3) & 7) != 4) return FALSE; /* dest reg mus be %rsp */
1253 if ((pc[2] & 7) == 4) return FALSE; /* no SIB byte allowed */
1254 if ((pc[2] >> 6) == 1) /* 8-bit offset */
1255 {
1256 pc += 4;
1257 break;
1258 }
1259 if ((pc[2] >> 6) == 2) /* 32-bit offset */
1260 {
1261 pc += 7;
1262 break;
1263 }
1264 return FALSE;
1265 }
1266 }
1267
1268 /* now check for various pop instructions */
1269
1270 for (;;)
1271 {
1272 BYTE rex = 0;
1273
1274 if ((*pc & 0xf0) == 0x40) rex = *pc++ & 0x0f; /* rex prefix */
1275
1276 switch (*pc)
1277 {
1278 case 0x58: /* pop %rax/%r8 */
1279 case 0x59: /* pop %rcx/%r9 */
1280 case 0x5a: /* pop %rdx/%r10 */
1281 case 0x5b: /* pop %rbx/%r11 */
1282 case 0x5c: /* pop %rsp/%r12 */
1283 case 0x5d: /* pop %rbp/%r13 */
1284 case 0x5e: /* pop %rsi/%r14 */
1285 case 0x5f: /* pop %rdi/%r15 */
1286 pc++;
1287 continue;
1288 case 0xc2: /* ret $nn */
1289 case 0xc3: /* ret */
1290 return TRUE;
1291 /* FIXME: add various jump instructions */
1292 }
1293 return FALSE;
1294 }
1295 }
1296
1297 /* execute a function epilog, which must have been validated with is_inside_epilog() */
1298 static void interpret_epilog( BYTE *pc, CONTEXT *context, KNONVOLATILE_CONTEXT_POINTERS *ctx_ptr )
1299 {
1300 for (;;)
1301 {
1302 BYTE rex = 0;
1303
1304 if ((*pc & 0xf0) == 0x40) rex = *pc++ & 0x0f; /* rex prefix */
1305
1306 switch (*pc)
1307 {
1308 case 0x58: /* pop %rax/r8 */
1309 case 0x59: /* pop %rcx/r9 */
1310 case 0x5a: /* pop %rdx/r10 */
1311 case 0x5b: /* pop %rbx/r11 */
1312 case 0x5c: /* pop %rsp/r12 */
1313 case 0x5d: /* pop %rbp/r13 */
1314 case 0x5e: /* pop %rsi/r14 */
1315 case 0x5f: /* pop %rdi/r15 */
1316 set_int_reg( context, ctx_ptr, *pc - 0x58 + (rex & 1) * 8, *(ULONG64 *)context->Rsp );
1317 context->Rsp += sizeof(ULONG64);
1318 pc++;
1319 continue;
1320 case 0x81: /* add $nnnn,%rsp */
1321 context->Rsp += *(LONG *)(pc + 2);
1322 pc += 2 + sizeof(LONG);
1323 continue;
1324 case 0x83: /* add $n,%rsp */
1325 context->Rsp += (signed char)pc[2];
1326 pc += 3;
1327 continue;
1328 case 0x8d:
1329 if ((pc[1] >> 6) == 1) /* lea n(reg),%rsp */
1330 {
1331 context->Rsp = get_int_reg( context, (pc[1] & 7) + (rex & 1) * 8 ) + (signed char)pc[2];
1332 pc += 3;
1333 }
1334 else /* lea nnnn(reg),%rsp */
1335 {
1336 context->Rsp = get_int_reg( context, (pc[1] & 7) + (rex & 1) * 8 ) + *(LONG *)(pc + 2);
1337 pc += 2 + sizeof(LONG);
1338 }
1339 continue;
1340 case 0xc2: /* ret $nn */
1341 context->Rip = *(ULONG64 *)context->Rsp;
1342 context->Rsp += sizeof(ULONG64) + *(WORD *)(pc + 1);
1343 return;
1344 case 0xc3: /* ret */
1345 context->Rip = *(ULONG64 *)context->Rsp;
1346 context->Rsp += sizeof(ULONG64);
1347 return;
1348 /* FIXME: add various jump instructions */
1349 }
1350 return;
1351 }
1352 }
1353
1354 /**********************************************************************
1355 * RtlVirtualUnwind (NTDLL.@)
1356 */
1357 PVOID WINAPI RtlVirtualUnwind( ULONG type, ULONG64 base, ULONG64 pc,
1358 RUNTIME_FUNCTION *function, CONTEXT *context,
1359 PVOID *data, ULONG64 *frame_ret,
1360 KNONVOLATILE_CONTEXT_POINTERS *ctx_ptr )
1361 {
1362 union handler_data *handler_data;
1363 ULONG64 frame, off;
1364 struct UNWIND_INFO *info;
1365 unsigned int i, prolog_offset;
1366
1367 TRACE( "type %x rip %lx rsp %lx\n", type, pc, context->Rsp );
1368 if (TRACE_ON(seh)) dump_unwind_info( base, function );
1369
1370 frame = *frame_ret = context->Rsp;
1371 for (;;)
1372 {
1373 info = (struct UNWIND_INFO *)((char *)base + function->UnwindData);
1374 handler_data = (union handler_data *)&info->opcodes[(info->count + 1) & ~1];
1375
1376 if (info->version != 1)
1377 {
1378 FIXME( "unknown unwind info version %u at %p\n", info->version, info );
1379 return NULL;
1380 }
1381
1382 if (info->frame_reg)
1383 frame = get_int_reg( context, info->frame_reg ) - info->frame_offset * 16;
1384
1385 /* check if in prolog */
1386 if (pc >= base + function->BeginAddress && pc < base + function->BeginAddress + info->prolog)
1387 {
1388 prolog_offset = pc - base - function->BeginAddress;
1389 }
1390 else
1391 {
1392 prolog_offset = ~0;
1393 if (is_inside_epilog( (BYTE *)pc ))
1394 {
1395 interpret_epilog( (BYTE *)pc, context, ctx_ptr );
1396 *frame_ret = frame;
1397 return NULL;
1398 }
1399 }
1400
1401 for (i = 0; i < info->count; i += get_opcode_size(info->opcodes[i]))
1402 {
1403 if (prolog_offset < info->opcodes[i].offset) continue; /* skip it */
1404
1405 switch (info->opcodes[i].code)
1406 {
1407 case UWOP_PUSH_NONVOL: /* pushq %reg */
1408 set_int_reg( context, ctx_ptr, info->opcodes[i].info, *(ULONG64 *)context->Rsp );
1409 context->Rsp += sizeof(ULONG64);
1410 break;
1411 case UWOP_ALLOC_LARGE: /* subq $nn,%rsp */
1412 if (info->opcodes[i].info) context->Rsp += *(DWORD *)&info->opcodes[i+1];
1413 else context->Rsp += *(USHORT *)&info->opcodes[i+1] * 8;
1414 break;
1415 case UWOP_ALLOC_SMALL: /* subq $n,%rsp */
1416 context->Rsp += (info->opcodes[i].info + 1) * 8;
1417 break;
1418 case UWOP_SET_FPREG: /* leaq nn(%rsp),%framereg */
1419 context->Rsp = *frame_ret = frame;
1420 break;
1421 case UWOP_SAVE_NONVOL: /* movq %reg,n(%rsp) */
1422 off = frame + *(USHORT *)&info->opcodes[i+1] * 8;
1423 set_int_reg( context, ctx_ptr, info->opcodes[i].info, *(ULONG64 *)off );
1424 break;
1425 case UWOP_SAVE_NONVOL_FAR: /* movq %reg,nn(%rsp) */
1426 off = frame + *(DWORD *)&info->opcodes[i+1];
1427 set_int_reg( context, ctx_ptr, info->opcodes[i].info, *(ULONG64 *)off );
1428 break;
1429 case UWOP_SAVE_XMM128: /* movaps %xmmreg,n(%rsp) */
1430 off = frame + *(USHORT *)&info->opcodes[i+1] * 16;
1431 set_float_reg( context, ctx_ptr, info->opcodes[i].info, *(M128A *)off );
1432 break;
1433 case UWOP_SAVE_XMM128_FAR: /* movaps %xmmreg,nn(%rsp) */
1434 off = frame + *(DWORD *)&info->opcodes[i+1];
1435 set_float_reg( context, ctx_ptr, info->opcodes[i].info, *(M128A *)off );
1436 break;
1437 case UWOP_PUSH_MACHFRAME:
1438 FIXME( "PUSH_MACHFRAME %u\n", info->opcodes[i].info );
1439 break;
1440 default:
1441 FIXME( "unknown code %u\n", info->opcodes[i].code );
1442 break;
1443 }
1444 }
1445
1446 if (!(info->flags & UNW_FLAG_CHAININFO)) break;
1447 function = &handler_data->chain; /* restart with the chained info */
1448 }
1449
1450 /* now pop return address */
1451 context->Rip = *(ULONG64 *)context->Rsp;
1452 context->Rsp += sizeof(ULONG64);
1453
1454 if (!(info->flags & type)) return NULL; /* no matching handler */
1455 if (prolog_offset != ~0) return NULL; /* inside prolog */
1456
1457 *data = &handler_data->handler + 1;
1458 return (char *)base + handler_data->handler;
1459 }
1460
1461
1462 /*******************************************************************
1463 * RtlUnwindEx (NTDLL.@)
1464 */
1465 void WINAPI RtlUnwindEx( ULONG64 end_frame, ULONG64 target_ip, EXCEPTION_RECORD *rec,
1466 ULONG64 retval, CONTEXT *context, UNWIND_HISTORY_TABLE *table )
1467 {
1468 EXCEPTION_RECORD record;
1469 ULONG64 frame;
1470 RUNTIME_FUNCTION *dir, *info;
1471 PEXCEPTION_ROUTINE handler;
1472 DISPATCHER_CONTEXT dispatch;
1473 CONTEXT new_context;
1474 LDR_MODULE *module;
1475 DWORD size;
1476
1477 /* build an exception record, if we do not have one */
1478 if (!rec)
1479 {
1480 record.ExceptionCode = STATUS_UNWIND;
1481 record.ExceptionFlags = 0;
1482 record.ExceptionRecord = NULL;
1483 record.ExceptionAddress = (void *)context->Rip;
1484 record.NumberParameters = 0;
1485 rec = &record;
1486 }
1487
1488 rec->ExceptionFlags |= EH_UNWINDING | (end_frame ? 0 : EH_EXIT_UNWIND);
1489
1490 FIXME( "code=%x flags=%x end_frame=%lx target_ip=%lx\n",
1491 rec->ExceptionCode, rec->ExceptionFlags, end_frame, target_ip );
1492
1493 frame = context->Rsp;
1494 while (frame != end_frame)
1495 {
1496 /* FIXME: should use the history table to make things faster */
1497
1498 if (LdrFindEntryForAddress( (void *)context->Rip, &module ))
1499 {
1500 ERR( "no module found for rip %p, can't unwind exception\n", (void *)context->Rip );
1501 raise_status( STATUS_BAD_FUNCTION_TABLE, rec );
1502 }
1503 if (!(dir = RtlImageDirectoryEntryToData( module->BaseAddress, TRUE,
1504 IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size )))
1505 {
1506 ERR( "module %s doesn't contain exception data, can't unwind exception\n",
1507 debugstr_w(module->BaseDllName.Buffer) );
1508 raise_status( STATUS_BAD_FUNCTION_TABLE, rec );
1509 }
1510 if (!(info = find_function_info( context->Rip, module->BaseAddress, dir, size )))
1511 {
1512 /* leaf function */
1513 context->Rip = *(ULONG64 *)context->Rsp;
1514 context->Rsp += sizeof(ULONG64);
1515 continue;
1516 }
1517
1518 new_context = *context;
1519
1520 handler = RtlVirtualUnwind( UNW_FLAG_UHANDLER, (ULONG64)module->BaseAddress, context->Rip,
1521 info, &new_context, &dispatch.HandlerData, &frame, NULL );
1522
1523 if ((frame & 7) ||
1524 frame < (ULONG64)NtCurrentTeb()->Tib.StackLimit ||
1525 frame >= (ULONG64)NtCurrentTeb()->Tib.StackBase)
1526 {
1527 ERR( "invalid frame %lx\n", frame );
1528 raise_status( STATUS_BAD_STACK, rec );
1529 }
1530
1531 if (end_frame && (frame > end_frame))
1532 {
1533 ERR( "invalid frame %lx/%lx\n", frame, end_frame );
1534 raise_status( STATUS_INVALID_UNWIND_TARGET, rec );
1535 }
1536
1537 if (handler)
1538 {
1539 dispatch.ControlPc = context->Rip;
1540 dispatch.ImageBase = (ULONG64)module->BaseAddress;
1541 dispatch.FunctionEntry = info;
1542 dispatch.EstablisherFrame = frame;
1543 dispatch.TargetIp = target_ip;
1544 dispatch.ContextRecord = context;
1545 dispatch.LanguageHandler = handler;
1546 dispatch.HistoryTable = table;
1547 dispatch.ScopeIndex = 0; /* FIXME */
1548
1549 TRACE( "calling handler %p (rec=%p, frame=%lx context=%p, dispatch=%p)\n",
1550 handler, rec, frame, context, &dispatch );
1551
1552 switch( handler( rec, frame, context, &dispatch ))
1553 {
1554 case ExceptionContinueSearch:
1555 break;
1556 case ExceptionCollidedUnwind:
1557 FIXME( "ExceptionCollidedUnwind not supported yet\n" );
1558 break;
1559 default:
1560 raise_status( STATUS_INVALID_DISPOSITION, rec );
1561 break;
1562 }
1563 }
1564 *context = new_context;
1565 }
1566 context->Rax = retval;
1567 context->Rip = target_ip;
1568 TRACE( "returning to %lx stack %lx\n", context->Rip, context->Rsp );
1569 set_cpu_context( context );
1570 }
1571
1572
1573 /*******************************************************************
1574 * RtlUnwind (NTDLL.@)
1575 */
1576 void WINAPI __regs_RtlUnwind( ULONG64 frame, ULONG64 target_ip, EXCEPTION_RECORD *rec,
1577 ULONG64 retval, CONTEXT *context )
1578 {
1579 RtlUnwindEx( frame, target_ip, rec, retval, context, NULL );
1580 }
1581 DEFINE_REGS_ENTRYPOINT( RtlUnwind, 4 )
1582
1583
1584 /*******************************************************************
1585 * __C_specific_handler (NTDLL.@)
1586 */
1587 EXCEPTION_DISPOSITION WINAPI __C_specific_handler( EXCEPTION_RECORD *rec,
1588 ULONG64 frame,
1589 CONTEXT *context,
1590 struct _DISPATCHER_CONTEXT *dispatch )
1591 {
1592 SCOPE_TABLE *table = dispatch->HandlerData;
1593 ULONG i;
1594
1595 TRACE( "%p %lx %p %p\n", rec, frame, context, dispatch );
1596 if (TRACE_ON(seh)) dump_scope_table( dispatch->ImageBase, table );
1597
1598 if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)) /* FIXME */
1599 return ExceptionContinueSearch;
1600
1601 for (i = 0; i < table->Count; i++)
1602 {
1603 if (context->Rip >= dispatch->ImageBase + table->ScopeRecord[i].BeginAddress &&
1604 context->Rip < dispatch->ImageBase + table->ScopeRecord[i].EndAddress)
1605 {
1606 if (!table->ScopeRecord[i].JumpTarget) continue;
1607 if (table->ScopeRecord[i].HandlerAddress != EXCEPTION_EXECUTE_HANDLER)
1608 {
1609 EXCEPTION_POINTERS ptrs;
1610 PC_LANGUAGE_EXCEPTION_HANDLER filter;
1611
1612 filter = (PC_LANGUAGE_EXCEPTION_HANDLER)(dispatch->ImageBase + table->ScopeRecord[i].HandlerAddress);
1613 ptrs.ExceptionRecord = rec;
1614 ptrs.ContextRecord = context;
1615 TRACE( "calling filter %p ptrs %p frame %lx\n", filter, &ptrs, frame );
1616 switch (filter( &ptrs, frame ))
1617 {
1618 case EXCEPTION_EXECUTE_HANDLER:
1619 break;
1620 case EXCEPTION_CONTINUE_SEARCH:
1621 continue;
1622 case EXCEPTION_CONTINUE_EXECUTION:
1623 return ExceptionContinueExecution;
1624 }
1625 }
1626 TRACE( "unwinding to target %lx\n", dispatch->ImageBase + table->ScopeRecord[i].JumpTarget );
1627 RtlUnwindEx( frame, dispatch->ImageBase + table->ScopeRecord[i].JumpTarget,
1628 rec, 0, context, dispatch->HistoryTable );
1629 }
1630 }
1631 return ExceptionContinueSearch;
1632 }
1633
1634
1635 /*******************************************************************
1636 * NtRaiseException (NTDLL.@)
1637 */
1638 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
1639 {
1640 NTSTATUS status = raise_exception( rec, context, first_chance );
1641 if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
1642 return status;
1643 }
1644
1645
1646 /***********************************************************************
1647 * RtlRaiseException (NTDLL.@)
1648 */
1649 void WINAPI __regs_RtlRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context )
1650 {
1651 NTSTATUS status;
1652
1653 rec->ExceptionAddress = (void *)context->Rip;
1654 status = raise_exception( rec, context, TRUE );
1655 if (status != STATUS_SUCCESS) raise_status( status, rec );
1656 }
1657 DEFINE_REGS_ENTRYPOINT( RtlRaiseException, 1 )
1658
1659
1660 /**********************************************************************
1661 * __wine_enter_vm86 (NTDLL.@)
1662 */
1663 void __wine_enter_vm86( CONTEXT *context )
1664 {
1665 MESSAGE("vm86 mode not supported on this platform\n");
1666 }
1667
1668 /**********************************************************************
1669 * DbgBreakPoint (NTDLL.@)
1670 */
1671 __ASM_GLOBAL_FUNC( DbgBreakPoint, "int $3; ret")
1672
1673 /**********************************************************************
1674 * DbgUserBreakPoint (NTDLL.@)
1675 */
1676 __ASM_GLOBAL_FUNC( DbgUserBreakPoint, "int $3; ret")
1677
1678 #endif /* __x86_64__ */
useful hacks and other patches not (yet) suitable for mainline