2 * msvcrt C++ exception handling
4 * Copyright 2002 Alexandre Julliard
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * A good reference is the article "How a C++ compiler implements
22 * exception handling" by Vishal Kochhar, available on
23 * www.thecodeproject.com.
27 #include "wine/port.h"
36 #include "wine/exception.h"
38 #include "wine/debug.h"
40 #include "cppexcept.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(seh
);
44 #ifdef __i386__ /* CxxFrameHandler is not supported on non-i386 */
46 static DWORD
cxx_frame_handler( PEXCEPTION_RECORD rec
, cxx_exception_frame
* frame
,
47 PCONTEXT exc_context
, EXCEPTION_REGISTRATION_RECORD
** dispatch
,
48 cxx_function_descr
*descr
, EXCEPTION_REGISTRATION_RECORD
* nested_frame
,
49 int nested_trylevel
, CONTEXT86
*context
);
51 /* call a function with a given ebp */
52 inline static void *call_ebp_func( void *func
, void *ebp
)
55 __asm__
__volatile__ ("pushl %%ebp; movl %2,%%ebp; call *%%eax; popl %%ebp" \
56 : "=a" (ret
) : "0" (func
), "g" (ebp
) : "ecx", "edx", "memory" );
60 /* call a copy constructor */
61 inline static void call_copy_ctor( void *func
, void *this, void *src
, int has_vbase
)
63 TRACE( "calling copy ctor %p object %p src %p\n", func
, this, src
);
65 /* in that case copy ctor takes an extra bool indicating whether to copy the base class */
66 __asm__
__volatile__("pushl $1; pushl %2; call *%0"
67 : : "r" (func
), "c" (this), "g" (src
) : "eax", "edx", "memory" );
69 __asm__
__volatile__("pushl %2; call *%0"
70 : : "r" (func
), "c" (this), "g" (src
) : "eax", "edx", "memory" );
73 /* call the destructor of the exception object */
74 inline static void call_dtor( void *func
, void *object
)
76 __asm__
__volatile__("call *%0" : : "r" (func
), "c" (object
) : "eax", "edx", "memory" );
79 static void dump_type( const cxx_type_info
*type
)
81 DPRINTF( "flags %x type %p", type
->flags
, type
->type_info
);
82 if (type
->type_info
) DPRINTF( " (%p %s)", type
->type_info
->name
, type
->type_info
->mangled
);
83 DPRINTF( " offset %d vbase %d,%d size %d copy ctor %p\n", type
->this_offset
,
84 type
->vbase_descr
, type
->vbase_offset
, type
->size
, type
->copy_ctor
);
87 static void dump_exception_type( const cxx_exception_type
*type
)
91 DPRINTF( "exception type:\n" );
92 DPRINTF( "flags %x destr %p handler %p type info %p\n",
93 type
->flags
, type
->destructor
, type
->custom_handler
, type
->type_info_table
);
94 for (i
= 0; i
< type
->type_info_table
->count
; i
++)
96 DPRINTF( " %d: ", i
);
97 dump_type( type
->type_info_table
->info
[i
] );
101 static void dump_function_descr( const cxx_function_descr
*descr
, const cxx_exception_type
*info
)
106 DPRINTF( "function descr:\n" );
107 DPRINTF( "magic %x\n", descr
->magic
);
108 DPRINTF( "unwind table: %p %d\n", descr
->unwind_table
, descr
->unwind_count
);
109 for (i
= 0; i
< descr
->unwind_count
; i
++)
111 DPRINTF( " %d: prev %d func %p\n", i
,
112 descr
->unwind_table
[i
].prev
, descr
->unwind_table
[i
].handler
);
114 DPRINTF( "try table: %p %d\n", descr
->tryblock
, descr
->tryblock_count
);
115 for (i
= 0; i
< descr
->tryblock_count
; i
++)
117 DPRINTF( " %d: start %d end %d catchlevel %d catch %p %d\n", i
,
118 descr
->tryblock
[i
].start_level
, descr
->tryblock
[i
].end_level
,
119 descr
->tryblock
[i
].catch_level
, descr
->tryblock
[i
].catchblock
,
120 descr
->tryblock
[i
].catchblock_count
);
121 for (j
= 0; j
< descr
->tryblock
[i
].catchblock_count
; j
++)
123 catchblock_info
*ptr
= &descr
->tryblock
[i
].catchblock
[j
];
124 DPRINTF( " %d: flags %x offset %d handler %p type %p",
125 j
, ptr
->flags
, ptr
->offset
, ptr
->handler
, ptr
->type_info
);
126 if (ptr
->type_info
) DPRINTF( " (%p %s)", ptr
->type_info
->name
, ptr
->type_info
->mangled
);
132 /* compute the this pointer for a base class of a given type */
133 static void *get_this_pointer( const cxx_type_info
*type
, void *object
)
138 if (!object
) return NULL
;
139 this_ptr
= (char *)object
+ type
->this_offset
;
140 if (type
->vbase_descr
>= 0)
142 /* move this ptr to vbase descriptor */
143 this_ptr
= (char *)this_ptr
+ type
->vbase_descr
;
144 /* and fetch additional offset from vbase descriptor */
145 offset_ptr
= (int *)(*(char **)this_ptr
+ type
->vbase_offset
);
146 this_ptr
= (char *)this_ptr
+ *offset_ptr
;
151 /* check if the exception type is caught by a given catch block, and return the type that matched */
152 static const cxx_type_info
*find_caught_type( cxx_exception_type
*exc_type
, catchblock_info
*catchblock
)
156 for (i
= 0; i
< exc_type
->type_info_table
->count
; i
++)
158 const cxx_type_info
*type
= exc_type
->type_info_table
->info
[i
];
160 if (!catchblock
->type_info
) return type
; /* catch(...) matches any type */
161 if (catchblock
->type_info
!= type
->type_info
)
163 if (strcmp( catchblock
->type_info
->mangled
, type
->type_info
->mangled
)) continue;
165 /* type is the same, now check the flags */
166 if ((exc_type
->flags
& TYPE_FLAG_CONST
) &&
167 !(catchblock
->flags
& TYPE_FLAG_CONST
)) continue;
168 if ((exc_type
->flags
& TYPE_FLAG_VOLATILE
) &&
169 !(catchblock
->flags
& TYPE_FLAG_VOLATILE
)) continue;
170 return type
; /* it matched */
176 /* copy the exception object where the catch block wants it */
177 static void copy_exception( void *object
, cxx_exception_frame
*frame
,
178 catchblock_info
*catchblock
, const cxx_type_info
*type
)
182 if (!catchblock
->type_info
|| !catchblock
->type_info
->mangled
[0]) return;
183 if (!catchblock
->offset
) return;
184 dest_ptr
= (void **)((char *)&frame
->ebp
+ catchblock
->offset
);
186 if (catchblock
->flags
& TYPE_FLAG_REFERENCE
)
188 *dest_ptr
= get_this_pointer( type
, object
);
190 else if (type
->flags
& CLASS_IS_SIMPLE_TYPE
)
192 memmove( dest_ptr
, object
, type
->size
);
193 /* if it is a pointer, adjust it */
194 if (type
->size
== sizeof(void *)) *dest_ptr
= get_this_pointer( type
, *dest_ptr
);
196 else /* copy the object */
199 call_copy_ctor( type
->copy_ctor
, dest_ptr
, get_this_pointer(type
,object
),
200 (type
->flags
& CLASS_HAS_VIRTUAL_BASE_CLASS
) );
202 memmove( dest_ptr
, get_this_pointer(type
,object
), type
->size
);
206 /* unwind the local function up to a given trylevel */
207 static void cxx_local_unwind( cxx_exception_frame
* frame
, cxx_function_descr
*descr
, int last_level
)
210 int trylevel
= frame
->trylevel
;
212 while (trylevel
!= last_level
)
214 if (trylevel
< 0 || trylevel
>= descr
->unwind_count
)
216 ERR( "invalid trylevel %d\n", trylevel
);
219 handler
= descr
->unwind_table
[trylevel
].handler
;
222 TRACE( "calling unwind handler %p trylevel %d last %d ebp %p\n",
223 handler
, trylevel
, last_level
, &frame
->ebp
);
224 call_ebp_func( handler
, &frame
->ebp
);
226 trylevel
= descr
->unwind_table
[trylevel
].prev
;
228 frame
->trylevel
= last_level
;
231 /* exception frame for nested exceptions in catch block */
232 struct catch_func_nested_frame
234 EXCEPTION_REGISTRATION_RECORD frame
; /* standard exception frame */
235 EXCEPTION_RECORD
*prev_rec
; /* previous record to restore in thread data */
236 cxx_exception_frame
*cxx_frame
; /* frame of parent exception */
237 cxx_function_descr
*descr
; /* descriptor of parent exception */
238 int trylevel
; /* current try level */
241 /* handler for exceptions happening while calling a catch function */
242 static DWORD
catch_function_nested_handler( EXCEPTION_RECORD
*rec
, EXCEPTION_REGISTRATION_RECORD
*frame
,
243 CONTEXT
*context
, EXCEPTION_REGISTRATION_RECORD
**dispatcher
)
245 struct catch_func_nested_frame
*nested_frame
= (struct catch_func_nested_frame
*)frame
;
247 if (rec
->ExceptionFlags
& (EH_UNWINDING
| EH_EXIT_UNWIND
))
249 msvcrt_get_thread_data()->exc_record
= nested_frame
->prev_rec
;
250 return ExceptionContinueSearch
;
254 TRACE( "got nested exception in catch function\n" );
255 return cxx_frame_handler( rec
, nested_frame
->cxx_frame
, context
,
256 NULL
, nested_frame
->descr
, &nested_frame
->frame
,
257 nested_frame
->trylevel
, context
);
261 /* find and call the appropriate catch block for an exception */
262 /* returns the address to continue execution to after the catch block was called */
263 inline static void *call_catch_block( PEXCEPTION_RECORD rec
, cxx_exception_frame
*frame
,
264 cxx_function_descr
*descr
, int nested_trylevel
,
265 cxx_exception_type
*info
)
269 void *addr
, *object
= (void *)rec
->ExceptionInformation
[1];
270 struct catch_func_nested_frame nested_frame
;
271 int trylevel
= frame
->trylevel
;
272 thread_data_t
*thread_data
= msvcrt_get_thread_data();
274 for (i
= 0; i
< descr
->tryblock_count
; i
++)
276 tryblock_info
*tryblock
= &descr
->tryblock
[i
];
278 if (trylevel
< tryblock
->start_level
) continue;
279 if (trylevel
> tryblock
->end_level
) continue;
281 /* got a try block */
282 for (j
= 0; j
< tryblock
->catchblock_count
; j
++)
284 catchblock_info
*catchblock
= &tryblock
->catchblock
[j
];
285 const cxx_type_info
*type
= find_caught_type( info
, catchblock
);
288 TRACE( "matched type %p in tryblock %d catchblock %d\n", type
, i
, j
);
290 /* copy the exception to its destination on the stack */
291 copy_exception( object
, frame
, catchblock
, type
);
293 /* unwind the stack */
294 RtlUnwind( frame
, 0, rec
, 0 );
295 cxx_local_unwind( frame
, descr
, tryblock
->start_level
);
296 frame
->trylevel
= tryblock
->end_level
+ 1;
298 /* call the catch block */
299 TRACE( "calling catch block %p for type %p addr %p ebp %p\n",
300 catchblock
, type
, catchblock
->handler
, &frame
->ebp
);
302 /* setup an exception block for nested exceptions */
304 nested_frame
.frame
.Handler
= catch_function_nested_handler
;
305 nested_frame
.prev_rec
= thread_data
->exc_record
;
306 nested_frame
.cxx_frame
= frame
;
307 nested_frame
.descr
= descr
;
308 nested_frame
.trylevel
= nested_trylevel
+ 1;
310 __wine_push_frame( &nested_frame
.frame
);
311 thread_data
->exc_record
= rec
;
312 addr
= call_ebp_func( catchblock
->handler
, &frame
->ebp
);
313 thread_data
->exc_record
= nested_frame
.prev_rec
;
314 __wine_pop_frame( &nested_frame
.frame
);
316 if (info
->destructor
) call_dtor( info
->destructor
, object
);
317 TRACE( "done, continuing at %p\n", addr
);
325 /*********************************************************************
328 * Implementation of __CxxFrameHandler.
330 static DWORD
cxx_frame_handler( PEXCEPTION_RECORD rec
, cxx_exception_frame
* frame
,
331 PCONTEXT exc_context
, EXCEPTION_REGISTRATION_RECORD
** dispatch
,
332 cxx_function_descr
*descr
, EXCEPTION_REGISTRATION_RECORD
* nested_frame
,
333 int nested_trylevel
, CONTEXT86
*context
)
335 cxx_exception_type
*exc_type
;
338 if (descr
->magic
!= CXX_FRAME_MAGIC
)
340 ERR( "invalid frame magic %x\n", descr
->magic
);
341 return ExceptionContinueSearch
;
343 if (rec
->ExceptionFlags
& (EH_UNWINDING
|EH_EXIT_UNWIND
))
345 if (descr
->unwind_count
&& !nested_trylevel
) cxx_local_unwind( frame
, descr
, -1 );
346 return ExceptionContinueSearch
;
348 if (!descr
->tryblock_count
) return ExceptionContinueSearch
;
350 exc_type
= (cxx_exception_type
*)rec
->ExceptionInformation
[2];
351 if (rec
->ExceptionCode
== CXX_EXCEPTION
&&
352 rec
->ExceptionInformation
[0] > CXX_FRAME_MAGIC
&&
353 exc_type
->custom_handler
)
355 return exc_type
->custom_handler( rec
, frame
, exc_context
, dispatch
,
356 descr
, nested_trylevel
, nested_frame
, 0 );
359 if (!exc_type
) /* nested exception, fetch info from original exception */
361 rec
= msvcrt_get_thread_data()->exc_record
;
362 exc_type
= (cxx_exception_type
*)rec
->ExceptionInformation
[2];
367 TRACE("handling C++ exception rec %p frame %p trylevel %d descr %p nested_frame %p\n",
368 rec
, frame
, frame
->trylevel
, descr
, nested_frame
);
369 dump_exception_type( exc_type
);
370 dump_function_descr( descr
, exc_type
);
373 next_ip
= call_catch_block( rec
, frame
, descr
, frame
->trylevel
, exc_type
);
375 if (!next_ip
) return ExceptionContinueSearch
;
376 rec
->ExceptionFlags
&= ~EH_NONCONTINUABLE
;
377 context
->Eip
= (DWORD
)next_ip
;
378 context
->Ebp
= (DWORD
)&frame
->ebp
;
379 context
->Esp
= ((DWORD
*)frame
)[-1];
380 return ExceptionContinueExecution
;
384 /*********************************************************************
385 * __CxxFrameHandler (MSVCRT.@)
387 void MSVCRT__CxxFrameHandler( PEXCEPTION_RECORD rec
, EXCEPTION_REGISTRATION_RECORD
* frame
,
388 PCONTEXT exc_context
, EXCEPTION_REGISTRATION_RECORD
** dispatch
,
391 cxx_function_descr
*descr
= (cxx_function_descr
*)context
->Eax
;
392 context
->Eax
= cxx_frame_handler( rec
, (cxx_exception_frame
*)frame
,
393 exc_context
, dispatch
, descr
, NULL
, 0, context
);
395 DEFINE_REGS_ENTRYPOINT( __CxxFrameHandler
, MSVCRT__CxxFrameHandler
, 16, 0 );
397 #endif /* __i386__ */
399 /*********************************************************************
400 * _CxxThrowException (MSVCRT.@)
402 void _CxxThrowException( void *object
, const cxx_exception_type
*type
)
406 args
[0] = CXX_FRAME_MAGIC
;
407 args
[1] = (DWORD
)object
;
408 args
[2] = (DWORD
)type
;
409 RaiseException( CXX_EXCEPTION
, EH_NONCONTINUABLE
, 3, args
);
412 /*********************************************************************
413 * __CxxDetectRethrow (MSVCRT.@)
415 BOOL
__CxxDetectRethrow(PEXCEPTION_POINTERS ptrs
)
417 PEXCEPTION_RECORD rec
;
422 rec
= ptrs
->ExceptionRecord
;
424 if (rec
->ExceptionCode
== CXX_EXCEPTION
&&
425 rec
->NumberParameters
== 3 &&
426 rec
->ExceptionInformation
[0] == CXX_FRAME_MAGIC
&&
427 rec
->ExceptionInformation
[2])
429 ptrs
->ExceptionRecord
= msvcrt_get_thread_data()->exc_record
;
432 return (msvcrt_get_thread_data()->exc_record
== rec
);
435 /*********************************************************************
436 * __CxxQueryExceptionSize (MSVCRT.@)
438 unsigned int __CxxQueryExceptionSize(void)
440 return sizeof(cxx_exception_type
);