?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Handle synchronous flag for x64 C++ exceptions.
[wine.git] / dlls / msvcrt / except_x86_64.c
blob8210f7b5dff184f94b8a909fb4587b6136a6cfc0
1 /*
2 * msvcrt C++ exception handling
3 *
4 * Copyright 2011 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 #include "config.h"
22 #include "wine/port.h"
23
24 #ifdef __x86_64__
25
26 #include <stdarg.h>
27
28 #include "ntstatus.h"
29 #define WIN32_NO_STATUS
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winternl.h"
33 #include "msvcrt.h"
34 #include "wine/exception.h"
35 #include "excpt.h"
36 #include "wine/debug.h"
37
38 #include "cppexcept.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(seh);
41
42 struct _DISPATCHER_CONTEXT;
43
44 typedef LONG (WINAPI *PC_LANGUAGE_EXCEPTION_HANDLER)( EXCEPTION_POINTERS *ptrs, ULONG64 frame );
45 typedef EXCEPTION_DISPOSITION (WINAPI *PEXCEPTION_ROUTINE)( EXCEPTION_RECORD *rec,
46 ULONG64 frame,
47 CONTEXT *context,
48 struct _DISPATCHER_CONTEXT *dispatch );
49
50 typedef struct _DISPATCHER_CONTEXT
51 {
52 ULONG64 ControlPc;
53 ULONG64 ImageBase;
54 PRUNTIME_FUNCTION FunctionEntry;
55 ULONG64 EstablisherFrame;
56 ULONG64 TargetIp;
57 PCONTEXT ContextRecord;
58 PEXCEPTION_ROUTINE LanguageHandler;
59 PVOID HandlerData;
60 PUNWIND_HISTORY_TABLE HistoryTable;
61 ULONG ScopeIndex;
62 } DISPATCHER_CONTEXT;
63
64 typedef struct
65 {
66 int prev;
67 UINT handler;
68 } unwind_info;
69
70 typedef struct
71 {
72 UINT flags;
73 UINT type_info;
74 int offset;
75 UINT handler;
76 UINT frame;
77 } catchblock_info;
78 #define TYPE_FLAG_CONST 1
79 #define TYPE_FLAG_VOLATILE 2
80 #define TYPE_FLAG_REFERENCE 8
81
82 typedef struct
83 {
84 int start_level;
85 int end_level;
86 int catch_level;
87 int catchblock_count;
88 UINT catchblock;
89 } tryblock_info;
90
91 typedef struct
92 {
93 int ip;
94 int state;
95 } ipmap_info;
96
97 typedef struct __cxx_function_descr
98 {
99 UINT magic;
100 UINT unwind_count;
101 UINT unwind_table;
102 UINT tryblock_count;
103 UINT tryblock;
104 UINT ipmap_count;
105 UINT ipmap;
106 UINT unwind_help;
107 UINT expect_list;
108 UINT flags;
109 } cxx_function_descr;
110
111 static inline void* rva_to_ptr(UINT rva, ULONG64 base)
112 {
113 return rva ? (void*)(base+rva) : NULL;
114 }
115
116 static inline void dump_type(UINT type_rva, ULONG64 base)
117 {
118 const cxx_type_info *type = rva_to_ptr(type_rva, base);
119
120 TRACE("flags %x type %x %s offsets %d,%d,%d size %d copy ctor %x(%p)\n",
121 type->flags, type->type_info, dbgstr_type_info(rva_to_ptr(type->type_info, base)),
122 type->offsets.this_offset, type->offsets.vbase_descr, type->offsets.vbase_offset,
123 type->size, type->copy_ctor, rva_to_ptr(type->copy_ctor, base));
124 }
125
126 static void dump_exception_type(const cxx_exception_type *type, ULONG64 base)
127 {
128 const cxx_type_info_table *type_info_table = rva_to_ptr(type->type_info_table, base);
129 UINT i;
130
131 TRACE("flags %x destr %x(%p) handler %x(%p) type info %x(%p)\n",
132 type->flags, type->destructor, rva_to_ptr(type->destructor, base),
133 type->custom_handler, rva_to_ptr(type->custom_handler, base),
134 type->type_info_table, type_info_table);
135 for (i = 0; i < type_info_table->count; i++)
136 {
137 TRACE(" %d: ", i);
138 dump_type(type_info_table->info[i], base);
139 }
140 }
141
142 static void dump_function_descr(const cxx_function_descr *descr, ULONG64 image_base)
143 {
144 unwind_info *unwind_table = rva_to_ptr(descr->unwind_table, image_base);
145 tryblock_info *tryblock = rva_to_ptr(descr->tryblock, image_base);
146 ipmap_info *ipmap = rva_to_ptr(descr->ipmap, image_base);
147 UINT i, j;
148
149 TRACE("magic %x\n", descr->magic);
150 TRACE("unwind table: %x(%p) %d\n", descr->unwind_table, unwind_table, descr->unwind_count);
151 for (i=0; i<descr->unwind_count; i++)
152 {
153 TRACE(" %d: prev %d func %x(%p)\n", i, unwind_table[i].prev,
154 unwind_table[i].handler, rva_to_ptr(unwind_table[i].handler, image_base));
155 }
156 TRACE("try table: %x(%p) %d\n", descr->tryblock, tryblock, descr->tryblock_count);
157 for (i=0; i<descr->tryblock_count; i++)
158 {
159 catchblock_info *catchblock = rva_to_ptr(tryblock[i].catchblock, image_base);
160
161 TRACE(" %d: start %d end %d catchlevel %d catch %x(%p) %d\n", i,
162 tryblock[i].start_level, tryblock[i].end_level,
163 tryblock[i].catch_level, tryblock[i].catchblock,
164 catchblock, tryblock[i].catchblock_count);
165 for (j=0; j<tryblock[i].catchblock_count; j++)
166 {
167 TRACE(" %d: flags %x offset %d handler %x(%p) frame %x type %x %s\n",
168 j, catchblock[j].flags, catchblock[j].offset, catchblock[j].handler,
169 rva_to_ptr(catchblock[j].handler, image_base), catchblock[j].frame,
170 catchblock[j].type_info,
171 dbgstr_type_info(rva_to_ptr(catchblock[j].type_info, image_base)));
172 }
173 }
174 TRACE("ipmap: %x(%p) %d\n", descr->ipmap, ipmap, descr->ipmap_count);
175 for (i=0; i<descr->ipmap_count; i++)
176 {
177 TRACE(" %d: ip %x state %d\n", i, ipmap[i].ip, ipmap[i].state);
178 }
179 TRACE("unwind_help %d\n", descr->unwind_help);
180 if (descr->magic <= CXX_FRAME_MAGIC_VC6) return;
181 TRACE("expect list: %x\n", descr->expect_list);
182 if (descr->magic <= CXX_FRAME_MAGIC_VC7) return;
183 TRACE("flags: %08x\n", descr->flags);
184 }
185
186 static inline int ip_to_state(ipmap_info *ipmap, UINT count, int ip)
187 {
188 UINT low = 0, high = count-1, med;
189
190 while (low < high) {
191 med = low + (high-low)/2;
192
193 if (ipmap[med].ip <= ip && ipmap[med+1].ip > ip)
194 {
195 low = med;
196 break;
197 }
198 if (ipmap[med].ip < ip) low = med+1;
199 else high = med-1;
200 }
201
202 TRACE("%x -> %d\n", ip, ipmap[low].state);
203 return ipmap[low].state;
204 }
205
206 /* check if the exception type is caught by a given catch block, and return the type that matched */
207 static const cxx_type_info *find_caught_type(cxx_exception_type *exc_type, ULONG64 exc_base,
208 const type_info *catch_ti, UINT catch_flags)
209 {
210 const cxx_type_info_table *type_info_table = rva_to_ptr(exc_type->type_info_table, exc_base);
211 UINT i;
212
213 for (i = 0; i < type_info_table->count; i++)
214 {
215 const cxx_type_info *type = rva_to_ptr(type_info_table->info[i], exc_base);
216 const type_info *ti = rva_to_ptr(type->type_info, exc_base);
217
218 if (!catch_ti) return type; /* catch(...) matches any type */
219 if (catch_ti != ti)
220 {
221 if (strcmp( catch_ti->mangled, ti->mangled )) continue;
222 }
223 /* type is the same, now check the flags */
224 if ((exc_type->flags & TYPE_FLAG_CONST) &&
225 !(catch_flags & TYPE_FLAG_CONST)) continue;
226 if ((exc_type->flags & TYPE_FLAG_VOLATILE) &&
227 !(catch_flags & TYPE_FLAG_VOLATILE)) continue;
228 return type; /* it matched */
229 }
230 return NULL;
231 }
232
233 static inline void copy_exception(void *object, ULONG64 frame,
234 DISPATCHER_CONTEXT *dispatch,
235 const catchblock_info *catchblock,
236 const cxx_type_info *type)
237 {
238 const type_info *catch_ti = rva_to_ptr(catchblock->type_info, dispatch->ImageBase);
239 void **dest = rva_to_ptr(catchblock->offset, frame);
240
241 if (!catch_ti || !catch_ti->mangled[0]) return;
242 if (!catchblock->offset) return;
243
244 if (catchblock->flags & TYPE_FLAG_REFERENCE)
245 {
246 *dest = get_this_pointer(&type->offsets, object);
247 }
248 else if (type->flags & CLASS_IS_SIMPLE_TYPE)
249 {
250 memmove(dest, object, type->size);
251 /* if it is a pointer, adjust it */
252 if (type->size == sizeof(void*)) *dest = get_this_pointer(&type->offsets, *dest);
253 }
254 else /* copy the object */
255 {
256 if (type->copy_ctor)
257 {
258 if (type->flags & CLASS_HAS_VIRTUAL_BASE_CLASS)
259 {
260 void (__cdecl *copy_ctor)(void*, void*, int) =
261 rva_to_ptr(type->copy_ctor, dispatch->ImageBase);
262 copy_ctor(dest, get_this_pointer(&type->offsets, object), 1);
263 }
264 else
265 {
266 void (__cdecl *copy_ctor)(void*, void*) =
267 rva_to_ptr(type->copy_ctor, dispatch->ImageBase);
268 copy_ctor(dest, get_this_pointer(&type->offsets, object));
269 }
270 }
271 else
272 memmove(dest, get_this_pointer(&type->offsets,object), type->size);
273 }
274 }
275
276 static void cxx_local_unwind(ULONG64 frame, DISPATCHER_CONTEXT *dispatch,
277 const cxx_function_descr *descr, int last_level)
278 {
279 const unwind_info *unwind_table = rva_to_ptr(descr->unwind_table, dispatch->ImageBase);
280 void (__cdecl *handler)(ULONG64 unk, ULONG64 rbp);
281 int *unwind_help = rva_to_ptr(descr->unwind_help, frame);
282 int trylevel;
283
284 if (unwind_help[0] == -2)
285 {
286 trylevel = ip_to_state(rva_to_ptr(descr->ipmap, dispatch->ImageBase),
287 descr->ipmap_count, dispatch->ControlPc-dispatch->ImageBase);
288 }
289 else
290 {
291 trylevel = unwind_help[0];
292 }
293
294 TRACE("current level: %d, last level: %d\n", trylevel, last_level);
295 while (trylevel != last_level)
296 {
297 if (trylevel<0 || trylevel>=descr->unwind_count)
298 {
299 ERR("invalid trylevel %d\n", trylevel);
300 MSVCRT_terminate();
301 }
302 handler = rva_to_ptr(unwind_table[trylevel].handler, dispatch->ImageBase);
303 if (handler)
304 {
305 TRACE("handler: %p\n", handler);
306 handler(0, frame);
307 }
308 trylevel = unwind_table[trylevel].prev;
309 }
310 unwind_help[0] = last_level;
311 }
312
313 static inline void* WINAPI call_catch_block(EXCEPTION_RECORD *rec)
314 {
315 ULONG64 frame = rec->ExceptionInformation[1];
316 const cxx_function_descr *descr = (void*)rec->ExceptionInformation[2];
317 EXCEPTION_RECORD *prev_rec = (void*)rec->ExceptionInformation[4];
318 void* (__cdecl *handler)(ULONG64 unk, ULONG64 rbp) = (void*)rec->ExceptionInformation[5];
319 int *unwind_help = rva_to_ptr(descr->unwind_help, frame);
320 cxx_frame_info frame_info;
321 void *ret_addr;
322
323 TRACE("calling handler %p\n", handler);
324
325 /* FIXME: native does local_unwind here in case of exception rethrow */
326 __CxxRegisterExceptionObject(&prev_rec, &frame_info);
327 ret_addr = handler(0, frame);
328 __CxxUnregisterExceptionObject(&frame_info, FALSE);
329 unwind_help[0] = -2;
330 unwind_help[1] = -1;
331 return ret_addr;
332 }
333
334 static inline BOOL cxx_is_consolidate(const EXCEPTION_RECORD *rec)
335 {
336 return rec->ExceptionCode==STATUS_UNWIND_CONSOLIDATE && rec->NumberParameters==6 &&
337 rec->ExceptionInformation[0]==(ULONG_PTR)call_catch_block;
338 }
339
340 static inline void find_catch_block(EXCEPTION_RECORD *rec, ULONG64 frame,
341 DISPATCHER_CONTEXT *dispatch,
342 const cxx_function_descr *descr,
343 cxx_exception_type *info, ULONG64 orig_frame)
344 {
345 ULONG64 exc_base = (rec->NumberParameters == 4 ? rec->ExceptionInformation[3] : 0);
346 int trylevel = ip_to_state(rva_to_ptr(descr->ipmap, dispatch->ImageBase),
347 descr->ipmap_count, dispatch->ControlPc-dispatch->ImageBase);
348 const tryblock_info *in_catch;
349 EXCEPTION_RECORD catch_record;
350 CONTEXT context;
351 UINT i, j;
352 INT *unwind_help;
353
354 for (i=descr->tryblock_count; i>0; i--)
355 {
356 in_catch = rva_to_ptr(descr->tryblock, dispatch->ImageBase);
357 in_catch = &in_catch[i-1];
358
359 if (trylevel>in_catch->end_level && trylevel<=in_catch->catch_level)
360 break;
361 }
362 if (!i)
363 in_catch = NULL;
364
365 unwind_help = rva_to_ptr(descr->unwind_help, orig_frame);
366 if (trylevel > unwind_help[1])
367 unwind_help[0] = unwind_help[1] = trylevel;
368 else
369 trylevel = unwind_help[1];
370 TRACE("current trylevel: %d\n", trylevel);
371
372 for (i=0; i<descr->tryblock_count; i++)
373 {
374 const tryblock_info *tryblock = rva_to_ptr(descr->tryblock, dispatch->ImageBase);
375 tryblock = &tryblock[i];
376
377 if (trylevel < tryblock->start_level) continue;
378 if (trylevel > tryblock->end_level) continue;
379
380 if (in_catch)
381 {
382 if(tryblock->start_level <= in_catch->end_level) continue;
383 if(tryblock->end_level > in_catch->catch_level) continue;
384 }
385
386 /* got a try block */
387 for (j=0; j<tryblock->catchblock_count; j++)
388 {
389 const catchblock_info *catchblock = rva_to_ptr(tryblock->catchblock, dispatch->ImageBase);
390 catchblock = &catchblock[j];
391
392 if (info)
393 {
394 const cxx_type_info *type = find_caught_type(info, exc_base,
395 rva_to_ptr(catchblock->type_info, dispatch->ImageBase),
396 catchblock->flags);
397 if (!type) continue;
398
399 TRACE("matched type %p in tryblock %d catchblock %d\n", type, i, j);
400
401 /* copy the exception to its destination on the stack */
402 copy_exception((void*)rec->ExceptionInformation[1],
403 orig_frame, dispatch, catchblock, type);
404 }
405 else
406 {
407 /* no CXX_EXCEPTION only proceed with a catch(...) block*/
408 if (catchblock->type_info)
409 continue;
410 TRACE("found catch(...) block\n");
411 }
412
413 /* unwind stack and call catch */
414 memset(&catch_record, 0, sizeof(catch_record));
415 catch_record.ExceptionCode = STATUS_UNWIND_CONSOLIDATE;
416 catch_record.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
417 catch_record.NumberParameters = 6;
418 catch_record.ExceptionInformation[0] = (ULONG_PTR)call_catch_block;
419 catch_record.ExceptionInformation[1] = orig_frame;
420 catch_record.ExceptionInformation[2] = (ULONG_PTR)descr;
421 catch_record.ExceptionInformation[3] = tryblock->start_level;
422 catch_record.ExceptionInformation[4] = (ULONG_PTR)rec;
423 catch_record.ExceptionInformation[5] =
424 (ULONG_PTR)rva_to_ptr(catchblock->handler, dispatch->ImageBase);
425 RtlUnwindEx((void*)frame, (void*)dispatch->ControlPc, &catch_record, NULL, &context, NULL);
426 }
427 }
428
429 TRACE("no matching catch block found\n");
430 }
431
432 static DWORD cxx_frame_handler(EXCEPTION_RECORD *rec, ULONG64 frame,
433 CONTEXT *context, DISPATCHER_CONTEXT *dispatch,
434 const cxx_function_descr *descr)
435 {
436 int trylevel = ip_to_state(rva_to_ptr(descr->ipmap, dispatch->ImageBase),
437 descr->ipmap_count, dispatch->ControlPc-dispatch->ImageBase);
438 cxx_exception_type *exc_type;
439 ULONG64 orig_frame = frame;
440 ULONG64 throw_base;
441 DWORD throw_func_off;
442 void *throw_func;
443 UINT i, j;
444
445 if (descr->magic<CXX_FRAME_MAGIC_VC6 || descr->magic>CXX_FRAME_MAGIC_VC8)
446 {
447 FIXME("unhandled frame magic %x\n", descr->magic);
448 return ExceptionContinueSearch;
449 }
450
451 if (descr->magic >= CXX_FRAME_MAGIC_VC8 &&
452 (descr->flags & FUNC_DESCR_SYNCHRONOUS) &&
453 (rec->ExceptionCode != CXX_EXCEPTION &&
454 !cxx_is_consolidate(rec) &&
455 rec->ExceptionCode != STATUS_LONGJUMP))
456 return ExceptionContinueSearch; /* handle only c++ exceptions */
457
458 /* update orig_frame if it's a nested exception */
459 throw_func_off = RtlLookupFunctionEntry(dispatch->ControlPc, &throw_base, NULL)->BeginAddress;
460 throw_func = rva_to_ptr(throw_func_off, throw_base);
461 TRACE("reconstructed handler pointer: %p\n", throw_func);
462 for (i=descr->tryblock_count; i>0; i--)
463 {
464 const tryblock_info *tryblock = rva_to_ptr(descr->tryblock, dispatch->ImageBase);
465 tryblock = &tryblock[i-1];
466
467 if (trylevel>tryblock->end_level && trylevel<=tryblock->catch_level)
468 {
469 for (j=0; j<tryblock->catchblock_count; j++)
470 {
471 const catchblock_info *catchblock = rva_to_ptr(tryblock->catchblock, dispatch->ImageBase);
472 catchblock = &catchblock[j];
473
474 if (rva_to_ptr(catchblock->handler, dispatch->ImageBase) == throw_func)
475 {
476 TRACE("nested exception detected\n");
477 orig_frame = *(ULONG64*)rva_to_ptr(catchblock->frame, frame);
478 TRACE("setting orig_frame to %lx\n", orig_frame);
479 }
480 }
481 }
482 }
483
484 if (rec->ExceptionFlags & (EH_UNWINDING|EH_EXIT_UNWIND))
485 {
486 if (cxx_is_consolidate(rec))
487 {
488 EXCEPTION_RECORD *new_rec = (void*)rec->ExceptionInformation[4];
489 thread_data_t *data = msvcrt_get_thread_data();
490 frame_info *cur;
491
492 if (rec->ExceptionFlags & EH_TARGET_UNWIND)
493 {
494 const cxx_function_descr *orig_descr = (void*)rec->ExceptionInformation[2];
495 int end_level = rec->ExceptionInformation[3];
496 orig_frame = rec->ExceptionInformation[1];
497
498 cxx_local_unwind(orig_frame, dispatch, orig_descr, end_level);
499 }
500 else if(frame == orig_frame)
501 cxx_local_unwind(frame, dispatch, descr, -1);
502
503 /* FIXME: we should only unregister frames registered by call_catch_block here */
504 for (cur = data->frame_info_head; cur; cur = cur->next)
505 {
506 if ((ULONG64)cur <= frame)
507 {
508 __CxxUnregisterExceptionObject((cxx_frame_info*)cur,
509 new_rec->ExceptionCode == CXX_EXCEPTION &&
510 data->exc_record->ExceptionCode == CXX_EXCEPTION &&
511 new_rec->ExceptionInformation[1] == data->exc_record->ExceptionInformation[1]);
512 }
513 }
514 return ExceptionContinueSearch;
515 }
516
517 if (frame == orig_frame)
518 cxx_local_unwind(frame, dispatch, descr, -1);
519 return ExceptionContinueSearch;
520 }
521 if (!descr->tryblock_count) return ExceptionContinueSearch;
522
523 if (rec->ExceptionCode == CXX_EXCEPTION &&
524 rec->ExceptionInformation[1] == 0 && rec->ExceptionInformation[2] == 0)
525 {
526 *rec = *msvcrt_get_thread_data()->exc_record;
527 rec->ExceptionFlags &= ~EH_UNWINDING;
528 if (TRACE_ON(seh)) {
529 TRACE("detect rethrow: exception code: %x\n", rec->ExceptionCode);
530 if (rec->ExceptionCode == CXX_EXCEPTION)
531 TRACE("re-propage: obj: %lx, type: %lx\n",
532 rec->ExceptionInformation[1], rec->ExceptionInformation[2]);
533 }
534 }
535
536 if (rec->ExceptionCode == CXX_EXCEPTION)
537 {
538 exc_type = (cxx_exception_type *)rec->ExceptionInformation[2];
539
540 if (TRACE_ON(seh))
541 {
542 TRACE("handling C++ exception rec %p frame %lx descr %p\n", rec, frame, descr);
543 dump_exception_type(exc_type, rec->ExceptionInformation[3]);
544 dump_function_descr(descr, dispatch->ImageBase);
545 }
546 }
547 else
548 {
549 thread_data_t *data = msvcrt_get_thread_data();
550
551 exc_type = NULL;
552 TRACE("handling C exception code %x rec %p frame %lx descr %p\n",
553 rec->ExceptionCode, rec, frame, descr);
554
555 if (data->se_translator) {
556 EXCEPTION_POINTERS except_ptrs;
557
558 except_ptrs.ExceptionRecord = rec;
559 except_ptrs.ContextRecord = context;
560 data->se_translator(rec->ExceptionCode, &except_ptrs);
561 }
562 }
563
564 find_catch_block(rec, frame, dispatch, descr, exc_type, orig_frame);
565 return ExceptionContinueSearch;
566 }
567
568 /*********************************************************************
569 * __CxxExceptionFilter (MSVCRT.@)
570 */
571 int CDECL __CxxExceptionFilter( PEXCEPTION_POINTERS ptrs,
572 const type_info *ti, int flags, void **copy )
573 {
574 FIXME( "%p %p %x %p: not implemented\n", ptrs, ti, flags, copy );
575 return EXCEPTION_CONTINUE_SEARCH;
576 }
577
578 /*********************************************************************
579 * __CxxFrameHandler (MSVCRT.@)
580 */
581 EXCEPTION_DISPOSITION CDECL __CxxFrameHandler( EXCEPTION_RECORD *rec, ULONG64 frame,
582 CONTEXT *context, DISPATCHER_CONTEXT *dispatch )
583 {
584 TRACE( "%p %lx %p %p\n", rec, frame, context, dispatch );
585 return cxx_frame_handler( rec, frame, context, dispatch,
586 rva_to_ptr(*(UINT*)dispatch->HandlerData, dispatch->ImageBase) );
587 }
588
589
590 /*********************************************************************
591 * __CppXcptFilter (MSVCRT.@)
592 */
593 int CDECL __CppXcptFilter(NTSTATUS ex, PEXCEPTION_POINTERS ptr)
594 {
595 /* only filter c++ exceptions */
596 if (ex != CXX_EXCEPTION) return EXCEPTION_CONTINUE_SEARCH;
597 return _XcptFilter( ex, ptr );
598 }
599
600
601 /*********************************************************************
602 * __CxxDetectRethrow (MSVCRT.@)
603 */
604 BOOL CDECL __CxxDetectRethrow(PEXCEPTION_POINTERS ptrs)
605 {
606 PEXCEPTION_RECORD rec;
607
608 if (!ptrs)
609 return FALSE;
610
611 rec = ptrs->ExceptionRecord;
612
613 if (rec->ExceptionCode == CXX_EXCEPTION &&
614 rec->NumberParameters == 4 &&
615 rec->ExceptionInformation[0] == CXX_FRAME_MAGIC_VC6 &&
616 rec->ExceptionInformation[2])
617 {
618 ptrs->ExceptionRecord = msvcrt_get_thread_data()->exc_record;
619 return TRUE;
620 }
621 return (msvcrt_get_thread_data()->exc_record == rec);
622 }
623
624
625 /*********************************************************************
626 * __CxxQueryExceptionSize (MSVCRT.@)
627 */
628 unsigned int CDECL __CxxQueryExceptionSize(void)
629 {
630 return sizeof(cxx_exception_type);
631 }
632
633
634 /*******************************************************************
635 * _setjmp (MSVCRT.@)
636 */
637 __ASM_GLOBAL_FUNC( MSVCRT__setjmp,
638 "jmp " __ASM_NAME("MSVCRT__setjmpex") );
639
640 /*******************************************************************
641 * _setjmpex (MSVCRT.@)
642 */
643 __ASM_GLOBAL_FUNC( MSVCRT__setjmpex,
644 "movq %rdx,(%rcx)\n\t" /* jmp_buf->Frame */
645 "movq %rbx,0x8(%rcx)\n\t" /* jmp_buf->Rbx */
646 "leaq 0x8(%rsp),%rax\n\t"
647 "movq %rax,0x10(%rcx)\n\t" /* jmp_buf->Rsp */
648 "movq %rbp,0x18(%rcx)\n\t" /* jmp_buf->Rbp */
649 "movq %rsi,0x20(%rcx)\n\t" /* jmp_buf->Rsi */
650 "movq %rdi,0x28(%rcx)\n\t" /* jmp_buf->Rdi */
651 "movq %r12,0x30(%rcx)\n\t" /* jmp_buf->R12 */
652 "movq %r13,0x38(%rcx)\n\t" /* jmp_buf->R13 */
653 "movq %r14,0x40(%rcx)\n\t" /* jmp_buf->R14 */
654 "movq %r15,0x48(%rcx)\n\t" /* jmp_buf->R15 */
655 "movq (%rsp),%rax\n\t"
656 "movq %rax,0x50(%rcx)\n\t" /* jmp_buf->Rip */
657 "movdqa %xmm6,0x60(%rcx)\n\t" /* jmp_buf->Xmm6 */
658 "movdqa %xmm7,0x70(%rcx)\n\t" /* jmp_buf->Xmm7 */
659 "movdqa %xmm8,0x80(%rcx)\n\t" /* jmp_buf->Xmm8 */
660 "movdqa %xmm9,0x90(%rcx)\n\t" /* jmp_buf->Xmm9 */
661 "movdqa %xmm10,0xa0(%rcx)\n\t" /* jmp_buf->Xmm10 */
662 "movdqa %xmm11,0xb0(%rcx)\n\t" /* jmp_buf->Xmm11 */
663 "movdqa %xmm12,0xc0(%rcx)\n\t" /* jmp_buf->Xmm12 */
664 "movdqa %xmm13,0xd0(%rcx)\n\t" /* jmp_buf->Xmm13 */
665 "movdqa %xmm14,0xe0(%rcx)\n\t" /* jmp_buf->Xmm14 */
666 "movdqa %xmm15,0xf0(%rcx)\n\t" /* jmp_buf->Xmm15 */
667 "xorq %rax,%rax\n\t"
668 "retq" );
669
670
671 extern void DECLSPEC_NORETURN CDECL longjmp_set_regs( struct MSVCRT___JUMP_BUFFER *jmp, int retval );
672 __ASM_GLOBAL_FUNC( longjmp_set_regs,
673 "movq %rdx,%rax\n\t" /* retval */
674 "movq 0x8(%rcx),%rbx\n\t" /* jmp_buf->Rbx */
675 "movq 0x18(%rcx),%rbp\n\t" /* jmp_buf->Rbp */
676 "movq 0x20(%rcx),%rsi\n\t" /* jmp_buf->Rsi */
677 "movq 0x28(%rcx),%rdi\n\t" /* jmp_buf->Rdi */
678 "movq 0x30(%rcx),%r12\n\t" /* jmp_buf->R12 */
679 "movq 0x38(%rcx),%r13\n\t" /* jmp_buf->R13 */
680 "movq 0x40(%rcx),%r14\n\t" /* jmp_buf->R14 */
681 "movq 0x48(%rcx),%r15\n\t" /* jmp_buf->R15 */
682 "movdqa 0x60(%rcx),%xmm6\n\t" /* jmp_buf->Xmm6 */
683 "movdqa 0x70(%rcx),%xmm7\n\t" /* jmp_buf->Xmm7 */
684 "movdqa 0x80(%rcx),%xmm8\n\t" /* jmp_buf->Xmm8 */
685 "movdqa 0x90(%rcx),%xmm9\n\t" /* jmp_buf->Xmm9 */
686 "movdqa 0xa0(%rcx),%xmm10\n\t" /* jmp_buf->Xmm10 */
687 "movdqa 0xb0(%rcx),%xmm11\n\t" /* jmp_buf->Xmm11 */
688 "movdqa 0xc0(%rcx),%xmm12\n\t" /* jmp_buf->Xmm12 */
689 "movdqa 0xd0(%rcx),%xmm13\n\t" /* jmp_buf->Xmm13 */
690 "movdqa 0xe0(%rcx),%xmm14\n\t" /* jmp_buf->Xmm14 */
691 "movdqa 0xf0(%rcx),%xmm15\n\t" /* jmp_buf->Xmm15 */
692 "movq 0x50(%rcx),%rdx\n\t" /* jmp_buf->Rip */
693 "movq 0x10(%rcx),%rsp\n\t" /* jmp_buf->Rsp */
694 "jmp *%rdx" );
695
696 /*******************************************************************
697 * longjmp (MSVCRT.@)
698 */
699 void __cdecl MSVCRT_longjmp( struct MSVCRT___JUMP_BUFFER *jmp, int retval )
700 {
701 EXCEPTION_RECORD rec;
702
703 if (!retval) retval = 1;
704 if (jmp->Frame)
705 {
706 rec.ExceptionCode = STATUS_LONGJUMP;
707 rec.ExceptionFlags = 0;
708 rec.ExceptionRecord = NULL;
709 rec.ExceptionAddress = NULL;
710 rec.NumberParameters = 1;
711 rec.ExceptionInformation[0] = (DWORD_PTR)jmp;
712 RtlUnwind( (void *)jmp->Frame, (void *)jmp->Rip, &rec, IntToPtr(retval) );
713 }
714 longjmp_set_regs( jmp, retval );
715 }
716
717 /*******************************************************************
718 * _local_unwind (MSVCRT.@)
719 */
720 void __cdecl _local_unwind( void *frame, void *target )
721 {
722 RtlUnwind( frame, target, NULL, 0 );
723 }
724
725 /*********************************************************************
726 * _fpieee_flt (MSVCRT.@)
727 */
728 int __cdecl _fpieee_flt(ULONG exception_code, EXCEPTION_POINTERS *ep,
729 int (__cdecl *handler)(_FPIEEE_RECORD*))
730 {
731 FIXME("(%x %p %p) opcode: %s\n", exception_code, ep, handler,
732 wine_dbgstr_longlong(*(ULONG64*)ep->ContextRecord->Rip));
733 return EXCEPTION_CONTINUE_SEARCH;
734 }
735
736 #endif /* __x86_64__ */
Windows API implementation