?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wow64: Add thunks for the I/O completion syscalls.
[wine.git] / dlls / msvcrt / cpp.c
blobffb91175a8ff2c25ad8a0164fd0495b158f0c785
1 /*
2 * msvcrt.dll C++ objects
3 *
4 * Copyright 2000 Jon Griffiths
5 * Copyright 2003, 2004 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <stdbool.h>
24
25 #include "windef.h"
26 #include "winternl.h"
27 #include "wine/exception.h"
28 #include "wine/debug.h"
29 #include "msvcrt.h"
30 #include "cppexcept.h"
31 #include "mtdll.h"
32 #include "cxx.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
35
36 struct __type_info_node
37 {
38 void *memPtr;
39 struct __type_info_node* next;
40 };
41
42 typedef exception bad_cast;
43 typedef exception bad_typeid;
44 typedef exception __non_rtti_object;
45
46 extern const vtable_ptr exception_vtable;
47 extern const vtable_ptr bad_typeid_vtable;
48 extern const vtable_ptr bad_cast_vtable;
49 extern const vtable_ptr __non_rtti_object_vtable;
50 extern const vtable_ptr type_info_vtable;
51
52 /* get the vtable pointer for a C++ object */
53 static inline const vtable_ptr *get_vtable( void *obj )
54 {
55 return *(const vtable_ptr **)obj;
56 }
57
58 static inline const rtti_object_locator *get_obj_locator( void *cppobj )
59 {
60 const vtable_ptr *vtable = get_vtable( cppobj );
61 return (const rtti_object_locator *)vtable[-1];
62 }
63
64 #ifndef __x86_64__
65 static void dump_obj_locator( const rtti_object_locator *ptr )
66 {
67 int i;
68 const rtti_object_hierarchy *h = ptr->type_hierarchy;
69
70 TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
71 ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
72 ptr->type_descriptor, dbgstr_type_info(ptr->type_descriptor), ptr->type_hierarchy );
73 TRACE( " hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
74 h->signature, h->attributes, h->array_len, h->base_classes );
75 for (i = 0; i < h->array_len; i++)
76 {
77 TRACE( " base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
78 h->base_classes->bases[i],
79 h->base_classes->bases[i]->num_base_classes,
80 h->base_classes->bases[i]->offsets.this_offset,
81 h->base_classes->bases[i]->offsets.vbase_descr,
82 h->base_classes->bases[i]->offsets.vbase_offset,
83 h->base_classes->bases[i]->attributes,
84 h->base_classes->bases[i]->type_descriptor,
85 dbgstr_type_info(h->base_classes->bases[i]->type_descriptor) );
86 }
87 }
88
89 #else
90
91 static void dump_obj_locator( const rtti_object_locator *ptr )
92 {
93 int i;
94 char *base = ptr->signature == 0 ? RtlPcToFileHeader((void*)ptr, (void**)&base) : (char*)ptr - ptr->object_locator;
95 const rtti_object_hierarchy *h = (const rtti_object_hierarchy*)(base + ptr->type_hierarchy);
96 const type_info *type_descriptor = (const type_info*)(base + ptr->type_descriptor);
97
98 TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
99 ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
100 type_descriptor, dbgstr_type_info(type_descriptor), h );
101 TRACE( " hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
102 h->signature, h->attributes, h->array_len, base + h->base_classes );
103 for (i = 0; i < h->array_len; i++)
104 {
105 const rtti_base_descriptor *bases = (rtti_base_descriptor*)(base +
106 ((const rtti_base_array*)(base + h->base_classes))->bases[i]);
107
108 TRACE( " base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
109 bases,
110 bases->num_base_classes,
111 bases->offsets.this_offset,
112 bases->offsets.vbase_descr,
113 bases->offsets.vbase_offset,
114 bases->attributes,
115 base + bases->type_descriptor,
116 dbgstr_type_info((const type_info*)(base + bases->type_descriptor)) );
117 }
118 }
119 #endif
120
121 /* Internal common ctor for exception */
122 static void EXCEPTION_ctor(exception *_this, const char** name)
123 {
124 _this->vtable = &exception_vtable;
125 if (*name)
126 {
127 unsigned int name_len = strlen(*name) + 1;
128 _this->name = malloc(name_len);
129 memcpy(_this->name, *name, name_len);
130 _this->do_free = TRUE;
131 }
132 else
133 {
134 _this->name = NULL;
135 _this->do_free = FALSE;
136 }
137 }
138
139 /******************************************************************
140 * ??0exception@@QAE@ABQBD@Z (MSVCRT.@)
141 */
142 DEFINE_THISCALL_WRAPPER(exception_ctor,8)
143 exception * __thiscall exception_ctor(exception * _this, const char ** name)
144 {
145 TRACE("(%p,%s)\n", _this, *name);
146 EXCEPTION_ctor(_this, name);
147 return _this;
148 }
149
150 /******************************************************************
151 * ??0exception@@QAE@ABQBDH@Z (MSVCRT.@)
152 */
153 DEFINE_THISCALL_WRAPPER(exception_ctor_noalloc,12)
154 exception * __thiscall exception_ctor_noalloc(exception * _this, char ** name, int noalloc)
155 {
156 TRACE("(%p,%s)\n", _this, *name);
157 _this->vtable = &exception_vtable;
158 _this->name = *name;
159 _this->do_free = FALSE;
160 return _this;
161 }
162
163 /******************************************************************
164 * ??0exception@@QAE@ABV0@@Z (MSVCRT.@)
165 */
166 DEFINE_THISCALL_WRAPPER(exception_copy_ctor,8)
167 exception * __thiscall exception_copy_ctor(exception * _this, const exception * rhs)
168 {
169 TRACE("(%p,%p)\n", _this, rhs);
170
171 if (!rhs->do_free)
172 {
173 _this->vtable = &exception_vtable;
174 _this->name = rhs->name;
175 _this->do_free = FALSE;
176 }
177 else
178 EXCEPTION_ctor(_this, (const char**)&rhs->name);
179 TRACE("name = %s\n", _this->name);
180 return _this;
181 }
182
183 /******************************************************************
184 * ??0exception@@QAE@XZ (MSVCRT.@)
185 */
186 DEFINE_THISCALL_WRAPPER(exception_default_ctor,4)
187 exception * __thiscall exception_default_ctor(exception * _this)
188 {
189 static const char* empty = NULL;
190
191 TRACE("(%p)\n", _this);
192 EXCEPTION_ctor(_this, &empty);
193 return _this;
194 }
195
196 /******************************************************************
197 * ??1exception@@UAE@XZ (MSVCRT.@)
198 */
199 DEFINE_THISCALL_WRAPPER(exception_dtor,4)
200 void __thiscall exception_dtor(exception * _this)
201 {
202 TRACE("(%p)\n", _this);
203 _this->vtable = &exception_vtable;
204 if (_this->do_free) free(_this->name);
205 }
206
207 /******************************************************************
208 * ??4exception@@QAEAAV0@ABV0@@Z (MSVCRT.@)
209 */
210 DEFINE_THISCALL_WRAPPER(exception_opequals,8)
211 exception * __thiscall exception_opequals(exception * _this, const exception * rhs)
212 {
213 TRACE("(%p %p)\n", _this, rhs);
214 if (_this != rhs)
215 {
216 exception_dtor(_this);
217 exception_copy_ctor(_this, rhs);
218 }
219 TRACE("name = %s\n", _this->name);
220 return _this;
221 }
222
223 /******************************************************************
224 * ??_Eexception@@UAEPAXI@Z (MSVCRT.@)
225 */
226 DEFINE_THISCALL_WRAPPER(exception_vector_dtor,8)
227 void * __thiscall exception_vector_dtor(exception * _this, unsigned int flags)
228 {
229 TRACE("(%p %x)\n", _this, flags);
230 if (flags & 2)
231 {
232 /* we have an array, with the number of elements stored before the first object */
233 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
234
235 for (i = *ptr - 1; i >= 0; i--) exception_dtor(_this + i);
236 operator_delete(ptr);
237 }
238 else
239 {
240 exception_dtor(_this);
241 if (flags & 1) operator_delete(_this);
242 }
243 return _this;
244 }
245
246 /******************************************************************
247 * ??_Gexception@@UAEPAXI@Z (MSVCRT.@)
248 */
249 DEFINE_THISCALL_WRAPPER(exception_scalar_dtor,8)
250 void * __thiscall exception_scalar_dtor(exception * _this, unsigned int flags)
251 {
252 TRACE("(%p %x)\n", _this, flags);
253 exception_dtor(_this);
254 if (flags & 1) operator_delete(_this);
255 return _this;
256 }
257
258 /******************************************************************
259 * ?what@exception@@UBEPBDXZ (MSVCRT.@)
260 */
261 DEFINE_THISCALL_WRAPPER(what_exception,4)
262 const char * __thiscall what_exception(exception * _this)
263 {
264 TRACE("(%p) returning %s\n", _this, _this->name);
265 return _this->name ? _this->name : "Unknown exception";
266 }
267
268 /******************************************************************
269 * ??0bad_typeid@@QAE@ABV0@@Z (MSVCRT.@)
270 */
271 DEFINE_THISCALL_WRAPPER(bad_typeid_copy_ctor,8)
272 bad_typeid * __thiscall bad_typeid_copy_ctor(bad_typeid * _this, const bad_typeid * rhs)
273 {
274 TRACE("(%p %p)\n", _this, rhs);
275 exception_copy_ctor(_this, rhs);
276 _this->vtable = &bad_typeid_vtable;
277 return _this;
278 }
279
280 /******************************************************************
281 * ??0bad_typeid@@QAE@PBD@Z (MSVCRT.@)
282 */
283 DEFINE_THISCALL_WRAPPER(bad_typeid_ctor,8)
284 bad_typeid * __thiscall bad_typeid_ctor(bad_typeid * _this, const char * name)
285 {
286 TRACE("(%p %s)\n", _this, name);
287 EXCEPTION_ctor(_this, &name);
288 _this->vtable = &bad_typeid_vtable;
289 return _this;
290 }
291
292 /******************************************************************
293 * ??_Fbad_typeid@@QAEXXZ (MSVCRT.@)
294 */
295 DEFINE_THISCALL_WRAPPER(bad_typeid_default_ctor,4)
296 bad_typeid * __thiscall bad_typeid_default_ctor(bad_typeid * _this)
297 {
298 return bad_typeid_ctor( _this, "bad typeid" );
299 }
300
301 /******************************************************************
302 * ??1bad_typeid@@UAE@XZ (MSVCRT.@)
303 */
304 DEFINE_THISCALL_WRAPPER(bad_typeid_dtor,4)
305 void __thiscall bad_typeid_dtor(bad_typeid * _this)
306 {
307 TRACE("(%p)\n", _this);
308 exception_dtor(_this);
309 }
310
311 /******************************************************************
312 * ??4bad_typeid@@QAEAAV0@ABV0@@Z (MSVCRT.@)
313 */
314 DEFINE_THISCALL_WRAPPER(bad_typeid_opequals,8)
315 bad_typeid * __thiscall bad_typeid_opequals(bad_typeid * _this, const bad_typeid * rhs)
316 {
317 TRACE("(%p %p)\n", _this, rhs);
318 exception_opequals(_this, rhs);
319 return _this;
320 }
321
322 /******************************************************************
323 * ??_Ebad_typeid@@UAEPAXI@Z (MSVCRT.@)
324 */
325 DEFINE_THISCALL_WRAPPER(bad_typeid_vector_dtor,8)
326 void * __thiscall bad_typeid_vector_dtor(bad_typeid * _this, unsigned int flags)
327 {
328 TRACE("(%p %x)\n", _this, flags);
329 if (flags & 2)
330 {
331 /* we have an array, with the number of elements stored before the first object */
332 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
333
334 for (i = *ptr - 1; i >= 0; i--) bad_typeid_dtor(_this + i);
335 operator_delete(ptr);
336 }
337 else
338 {
339 bad_typeid_dtor(_this);
340 if (flags & 1) operator_delete(_this);
341 }
342 return _this;
343 }
344
345 /******************************************************************
346 * ??_Gbad_typeid@@UAEPAXI@Z (MSVCRT.@)
347 */
348 DEFINE_THISCALL_WRAPPER(bad_typeid_scalar_dtor,8)
349 void * __thiscall bad_typeid_scalar_dtor(bad_typeid * _this, unsigned int flags)
350 {
351 TRACE("(%p %x)\n", _this, flags);
352 bad_typeid_dtor(_this);
353 if (flags & 1) operator_delete(_this);
354 return _this;
355 }
356
357 /******************************************************************
358 * ??0__non_rtti_object@@QAE@ABV0@@Z (MSVCRT.@)
359 */
360 DEFINE_THISCALL_WRAPPER(__non_rtti_object_copy_ctor,8)
361 __non_rtti_object * __thiscall __non_rtti_object_copy_ctor(__non_rtti_object * _this,
362 const __non_rtti_object * rhs)
363 {
364 TRACE("(%p %p)\n", _this, rhs);
365 bad_typeid_copy_ctor(_this, rhs);
366 _this->vtable = &__non_rtti_object_vtable;
367 return _this;
368 }
369
370 /******************************************************************
371 * ??0__non_rtti_object@@QAE@PBD@Z (MSVCRT.@)
372 */
373 DEFINE_THISCALL_WRAPPER(__non_rtti_object_ctor,8)
374 __non_rtti_object * __thiscall __non_rtti_object_ctor(__non_rtti_object * _this,
375 const char * name)
376 {
377 TRACE("(%p %s)\n", _this, name);
378 EXCEPTION_ctor(_this, &name);
379 _this->vtable = &__non_rtti_object_vtable;
380 return _this;
381 }
382
383 /******************************************************************
384 * ??1__non_rtti_object@@UAE@XZ (MSVCRT.@)
385 */
386 DEFINE_THISCALL_WRAPPER(__non_rtti_object_dtor,4)
387 void __thiscall __non_rtti_object_dtor(__non_rtti_object * _this)
388 {
389 TRACE("(%p)\n", _this);
390 bad_typeid_dtor(_this);
391 }
392
393 /******************************************************************
394 * ??4__non_rtti_object@@QAEAAV0@ABV0@@Z (MSVCRT.@)
395 */
396 DEFINE_THISCALL_WRAPPER(__non_rtti_object_opequals,8)
397 __non_rtti_object * __thiscall __non_rtti_object_opequals(__non_rtti_object * _this,
398 const __non_rtti_object *rhs)
399 {
400 TRACE("(%p %p)\n", _this, rhs);
401 bad_typeid_opequals(_this, rhs);
402 return _this;
403 }
404
405 /******************************************************************
406 * ??_E__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
407 */
408 DEFINE_THISCALL_WRAPPER(__non_rtti_object_vector_dtor,8)
409 void * __thiscall __non_rtti_object_vector_dtor(__non_rtti_object * _this, unsigned int flags)
410 {
411 TRACE("(%p %x)\n", _this, flags);
412 if (flags & 2)
413 {
414 /* we have an array, with the number of elements stored before the first object */
415 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
416
417 for (i = *ptr - 1; i >= 0; i--) __non_rtti_object_dtor(_this + i);
418 operator_delete(ptr);
419 }
420 else
421 {
422 __non_rtti_object_dtor(_this);
423 if (flags & 1) operator_delete(_this);
424 }
425 return _this;
426 }
427
428 /******************************************************************
429 * ??_G__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
430 */
431 DEFINE_THISCALL_WRAPPER(__non_rtti_object_scalar_dtor,8)
432 void * __thiscall __non_rtti_object_scalar_dtor(__non_rtti_object * _this, unsigned int flags)
433 {
434 TRACE("(%p %x)\n", _this, flags);
435 __non_rtti_object_dtor(_this);
436 if (flags & 1) operator_delete(_this);
437 return _this;
438 }
439
440 /******************************************************************
441 * ??0bad_cast@@AAE@PBQBD@Z (MSVCRT.@)
442 * ??0bad_cast@@QAE@ABQBD@Z (MSVCRT.@)
443 */
444 DEFINE_THISCALL_WRAPPER(bad_cast_ctor,8)
445 bad_cast * __thiscall bad_cast_ctor(bad_cast * _this, const char ** name)
446 {
447 TRACE("(%p %s)\n", _this, *name);
448 EXCEPTION_ctor(_this, name);
449 _this->vtable = &bad_cast_vtable;
450 return _this;
451 }
452
453 /******************************************************************
454 * ??0bad_cast@@QAE@ABV0@@Z (MSVCRT.@)
455 */
456 DEFINE_THISCALL_WRAPPER(bad_cast_copy_ctor,8)
457 bad_cast * __thiscall bad_cast_copy_ctor(bad_cast * _this, const bad_cast * rhs)
458 {
459 TRACE("(%p %p)\n", _this, rhs);
460 exception_copy_ctor(_this, rhs);
461 _this->vtable = &bad_cast_vtable;
462 return _this;
463 }
464
465 /******************************************************************
466 * ??0bad_cast@@QAE@PBD@Z (MSVCRT.@)
467 */
468 DEFINE_THISCALL_WRAPPER(bad_cast_ctor_charptr,8)
469 bad_cast * __thiscall bad_cast_ctor_charptr(bad_cast * _this, const char * name)
470 {
471 TRACE("(%p %s)\n", _this, name);
472 EXCEPTION_ctor(_this, &name);
473 _this->vtable = &bad_cast_vtable;
474 return _this;
475 }
476
477 /******************************************************************
478 * ??_Fbad_cast@@QAEXXZ (MSVCRT.@)
479 */
480 DEFINE_THISCALL_WRAPPER(bad_cast_default_ctor,4)
481 bad_cast * __thiscall bad_cast_default_ctor(bad_cast * _this)
482 {
483 return bad_cast_ctor_charptr( _this, "bad cast" );
484 }
485
486 /******************************************************************
487 * ??1bad_cast@@UAE@XZ (MSVCRT.@)
488 */
489 DEFINE_THISCALL_WRAPPER(bad_cast_dtor,4)
490 void __thiscall bad_cast_dtor(bad_cast * _this)
491 {
492 TRACE("(%p)\n", _this);
493 exception_dtor(_this);
494 }
495
496 /******************************************************************
497 * ??4bad_cast@@QAEAAV0@ABV0@@Z (MSVCRT.@)
498 */
499 DEFINE_THISCALL_WRAPPER(bad_cast_opequals,8)
500 bad_cast * __thiscall bad_cast_opequals(bad_cast * _this, const bad_cast * rhs)
501 {
502 TRACE("(%p %p)\n", _this, rhs);
503 exception_opequals(_this, rhs);
504 return _this;
505 }
506
507 /******************************************************************
508 * ??_Ebad_cast@@UAEPAXI@Z (MSVCRT.@)
509 */
510 DEFINE_THISCALL_WRAPPER(bad_cast_vector_dtor,8)
511 void * __thiscall bad_cast_vector_dtor(bad_cast * _this, unsigned int flags)
512 {
513 TRACE("(%p %x)\n", _this, flags);
514 if (flags & 2)
515 {
516 /* we have an array, with the number of elements stored before the first object */
517 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
518
519 for (i = *ptr - 1; i >= 0; i--) bad_cast_dtor(_this + i);
520 operator_delete(ptr);
521 }
522 else
523 {
524 bad_cast_dtor(_this);
525 if (flags & 1) operator_delete(_this);
526 }
527 return _this;
528 }
529
530 /******************************************************************
531 * ??_Gbad_cast@@UAEPAXI@Z (MSVCRT.@)
532 */
533 DEFINE_THISCALL_WRAPPER(bad_cast_scalar_dtor,8)
534 void * __thiscall bad_cast_scalar_dtor(bad_cast * _this, unsigned int flags)
535 {
536 TRACE("(%p %x)\n", _this, flags);
537 bad_cast_dtor(_this);
538 if (flags & 1) operator_delete(_this);
539 return _this;
540 }
541
542 /******************************************************************
543 * ??8type_info@@QBEHABV0@@Z (MSVCRT.@)
544 */
545 DEFINE_THISCALL_WRAPPER(type_info_opequals_equals,8)
546 int __thiscall type_info_opequals_equals(type_info * _this, const type_info * rhs)
547 {
548 int ret = !strcmp(_this->mangled + 1, rhs->mangled + 1);
549 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
550 return ret;
551 }
552
553 /******************************************************************
554 * ??9type_info@@QBEHABV0@@Z (MSVCRT.@)
555 */
556 DEFINE_THISCALL_WRAPPER(type_info_opnot_equals,8)
557 int __thiscall type_info_opnot_equals(type_info * _this, const type_info * rhs)
558 {
559 int ret = !!strcmp(_this->mangled + 1, rhs->mangled + 1);
560 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
561 return ret;
562 }
563
564 /******************************************************************
565 * ?before@type_info@@QBEHABV1@@Z (MSVCRT.@)
566 */
567 DEFINE_THISCALL_WRAPPER(type_info_before,8)
568 int __thiscall type_info_before(type_info * _this, const type_info * rhs)
569 {
570 int ret = strcmp(_this->mangled + 1, rhs->mangled + 1) < 0;
571 TRACE("(%p %p) returning %d\n", _this, rhs, ret);
572 return ret;
573 }
574
575 /******************************************************************
576 * ??1type_info@@UAE@XZ (MSVCRT.@)
577 */
578 DEFINE_THISCALL_WRAPPER(type_info_dtor,4)
579 void __thiscall type_info_dtor(type_info * _this)
580 {
581 TRACE("(%p)\n", _this);
582 free(_this->name);
583 }
584
585 /******************************************************************
586 * ?name@type_info@@QBEPBDXZ (MSVCRT.@)
587 */
588 DEFINE_THISCALL_WRAPPER(type_info_name,4)
589 const char * __thiscall type_info_name(type_info * _this)
590 {
591 if (!_this->name)
592 {
593 /* Create and set the demangled name */
594 /* Note: mangled name in type_info struct always starts with a '.', while
595 * it isn't valid for mangled name.
596 * Is this '.' really part of the mangled name, or has it some other meaning ?
597 */
598 char* name = __unDName(0, _this->mangled + 1, 0,
599 malloc, free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
600 if (name)
601 {
602 unsigned int len = strlen(name);
603
604 /* It seems _unDName may leave blanks at the end of the demangled name */
605 while (len && name[--len] == ' ')
606 name[len] = '\0';
607
608 if (InterlockedCompareExchangePointer((void**)&_this->name, name, NULL))
609 {
610 /* Another thread set this member since we checked above - use it */
611 free(name);
612 }
613 }
614 }
615 TRACE("(%p) returning %s\n", _this, _this->name);
616 return _this->name;
617 }
618
619 /******************************************************************
620 * ?raw_name@type_info@@QBEPBDXZ (MSVCRT.@)
621 */
622 DEFINE_THISCALL_WRAPPER(type_info_raw_name,4)
623 const char * __thiscall type_info_raw_name(type_info * _this)
624 {
625 TRACE("(%p) returning %s\n", _this, _this->mangled);
626 return _this->mangled;
627 }
628
629 /* Unexported */
630 DEFINE_THISCALL_WRAPPER(type_info_vector_dtor,8)
631 void * __thiscall type_info_vector_dtor(type_info * _this, unsigned int flags)
632 {
633 TRACE("(%p %x)\n", _this, flags);
634 if (flags & 2)
635 {
636 /* we have an array, with the number of elements stored before the first object */
637 INT_PTR i, *ptr = (INT_PTR *)_this - 1;
638
639 for (i = *ptr - 1; i >= 0; i--) type_info_dtor(_this + i);
640 operator_delete(ptr);
641 }
642 else
643 {
644 type_info_dtor(_this);
645 if (flags & 1) operator_delete(_this);
646 }
647 return _this;
648 }
649
650 #if _MSVCR_VER >= 80
651
652 typedef exception bad_alloc;
653 extern const vtable_ptr bad_alloc_vtable;
654
655 static void bad_alloc_ctor(bad_alloc *this, const char **name)
656 {
657 exception_ctor(this, name);
658 this->vtable = &bad_alloc_vtable;
659 }
660
661 /* bad_alloc class implementation */
662 DEFINE_THISCALL_WRAPPER(bad_alloc_copy_ctor,8)
663 bad_alloc * __thiscall bad_alloc_copy_ctor(bad_alloc * _this, const bad_alloc * rhs)
664 {
665 TRACE("(%p %p)\n", _this, rhs);
666 exception_copy_ctor(_this, rhs);
667 _this->vtable = &bad_alloc_vtable;
668 return _this;
669 }
670
671 DEFINE_THISCALL_WRAPPER(bad_alloc_dtor,4)
672 void __thiscall bad_alloc_dtor(bad_alloc * _this)
673 {
674 TRACE("(%p)\n", _this);
675 exception_dtor(_this);
676 }
677
678 #endif /* _MSVCR_VER >= 80 */
679
680 #if _MSVCR_VER >= 100
681
682 typedef struct {
683 exception e;
684 HRESULT hr;
685 } scheduler_resource_allocation_error;
686 extern const vtable_ptr scheduler_resource_allocation_error_vtable;
687
688 /* ??0scheduler_resource_allocation_error@Concurrency@@QAE@PBDJ@Z */
689 /* ??0scheduler_resource_allocation_error@Concurrency@@QEAA@PEBDJ@Z */
690 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_ctor_name, 12)
691 scheduler_resource_allocation_error* __thiscall scheduler_resource_allocation_error_ctor_name(
692 scheduler_resource_allocation_error *this, const char *name, HRESULT hr)
693 {
694 TRACE("(%p %s %x)\n", this, wine_dbgstr_a(name), hr);
695 exception_ctor(&this->e, &name);
696 this->e.vtable = &scheduler_resource_allocation_error_vtable;
697 this->hr = hr;
698 return this;
699 }
700
701 /* ??0scheduler_resource_allocation_error@Concurrency@@QAE@J@Z */
702 /* ??0scheduler_resource_allocation_error@Concurrency@@QEAA@J@Z */
703 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_ctor, 8)
704 scheduler_resource_allocation_error* __thiscall scheduler_resource_allocation_error_ctor(
705 scheduler_resource_allocation_error *this, HRESULT hr)
706 {
707 return scheduler_resource_allocation_error_ctor_name(this, NULL, hr);
708 }
709
710 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_copy_ctor,8)
711 scheduler_resource_allocation_error* __thiscall scheduler_resource_allocation_error_copy_ctor(
712 scheduler_resource_allocation_error *this,
713 const scheduler_resource_allocation_error *rhs)
714 {
715 TRACE("(%p,%p)\n", this, rhs);
716
717 if (!rhs->e.do_free)
718 memcpy(this, rhs, sizeof(*this));
719 else
720 scheduler_resource_allocation_error_ctor_name(this, rhs->e.name, rhs->hr);
721 return this;
722 }
723
724 /* ?get_error_code@scheduler_resource_allocation_error@Concurrency@@QBEJXZ */
725 /* ?get_error_code@scheduler_resource_allocation_error@Concurrency@@QEBAJXZ */
726 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_get_error_code, 4)
727 HRESULT __thiscall scheduler_resource_allocation_error_get_error_code(
728 const scheduler_resource_allocation_error *this)
729 {
730 TRACE("(%p)\n", this);
731 return this->hr;
732 }
733
734 DEFINE_THISCALL_WRAPPER(scheduler_resource_allocation_error_dtor,4)
735 void __thiscall scheduler_resource_allocation_error_dtor(
736 scheduler_resource_allocation_error * this)
737 {
738 TRACE("(%p)\n", this);
739 exception_dtor(&this->e);
740 }
741
742 typedef exception improper_lock;
743 extern const vtable_ptr improper_lock_vtable;
744
745 /* ??0improper_lock@Concurrency@@QAE@PBD@Z */
746 /* ??0improper_lock@Concurrency@@QEAA@PEBD@Z */
747 DEFINE_THISCALL_WRAPPER(improper_lock_ctor_str, 8)
748 improper_lock* __thiscall improper_lock_ctor_str(improper_lock *this, const char *str)
749 {
750 TRACE("(%p %p)\n", this, str);
751 exception_ctor(this, &str);
752 this->vtable = &improper_lock_vtable;
753 return this;
754 }
755
756 /* ??0improper_lock@Concurrency@@QAE@XZ */
757 /* ??0improper_lock@Concurrency@@QEAA@XZ */
758 DEFINE_THISCALL_WRAPPER(improper_lock_ctor, 4)
759 improper_lock* __thiscall improper_lock_ctor(improper_lock *this)
760 {
761 return improper_lock_ctor_str(this, NULL);
762 }
763
764 DEFINE_THISCALL_WRAPPER(improper_lock_copy_ctor,8)
765 improper_lock * __thiscall improper_lock_copy_ctor(improper_lock * _this, const improper_lock * rhs)
766 {
767 TRACE("(%p %p)\n", _this, rhs);
768 exception_copy_ctor(_this, rhs);
769 _this->vtable = &improper_lock_vtable;
770 return _this;
771 }
772
773 DEFINE_THISCALL_WRAPPER(improper_lock_dtor,4)
774 void __thiscall improper_lock_dtor(improper_lock * _this)
775 {
776 TRACE("(%p)\n", _this);
777 exception_dtor(_this);
778 }
779
780 typedef exception invalid_scheduler_policy_key;
781 extern const vtable_ptr invalid_scheduler_policy_key_vtable;
782
783 /* ??0invalid_scheduler_policy_key@Concurrency@@QAE@PBD@Z */
784 /* ??0invalid_scheduler_policy_key@Concurrency@@QEAA@PEBD@Z */
785 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_ctor_str, 8)
786 invalid_scheduler_policy_key* __thiscall invalid_scheduler_policy_key_ctor_str(
787 invalid_scheduler_policy_key *this, const char *str)
788 {
789 TRACE("(%p %p)\n", this, str);
790 exception_ctor(this, &str);
791 this->vtable = &invalid_scheduler_policy_key_vtable;
792 return this;
793 }
794
795 /* ??0invalid_scheduler_policy_key@Concurrency@@QAE@XZ */
796 /* ??0invalid_scheduler_policy_key@Concurrency@@QEAA@XZ */
797 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_ctor, 4)
798 invalid_scheduler_policy_key* __thiscall invalid_scheduler_policy_key_ctor(
799 invalid_scheduler_policy_key *this)
800 {
801 return invalid_scheduler_policy_key_ctor_str(this, NULL);
802 }
803
804 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_copy_ctor,8)
805 invalid_scheduler_policy_key * __thiscall invalid_scheduler_policy_key_copy_ctor(
806 invalid_scheduler_policy_key * _this, const invalid_scheduler_policy_key * rhs)
807 {
808 TRACE("(%p %p)\n", _this, rhs);
809 exception_copy_ctor(_this, rhs);
810 _this->vtable = &invalid_scheduler_policy_key_vtable;
811 return _this;
812 }
813
814 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_key_dtor,4)
815 void __thiscall invalid_scheduler_policy_key_dtor(
816 invalid_scheduler_policy_key * _this)
817 {
818 TRACE("(%p)\n", _this);
819 exception_dtor(_this);
820 }
821
822 typedef exception invalid_scheduler_policy_value;
823 extern const vtable_ptr invalid_scheduler_policy_value_vtable;
824
825 /* ??0invalid_scheduler_policy_value@Concurrency@@QAE@PBD@Z */
826 /* ??0invalid_scheduler_policy_value@Concurrency@@QEAA@PEBD@Z */
827 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_ctor_str, 8)
828 invalid_scheduler_policy_value* __thiscall invalid_scheduler_policy_value_ctor_str(
829 invalid_scheduler_policy_value *this, const char *str)
830 {
831 TRACE("(%p %p)\n", this, str);
832 exception_ctor(this, &str);
833 this->vtable = &invalid_scheduler_policy_value_vtable;
834 return this;
835 }
836
837 /* ??0invalid_scheduler_policy_value@Concurrency@@QAE@XZ */
838 /* ??0invalid_scheduler_policy_value@Concurrency@@QEAA@XZ */
839 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_ctor, 4)
840 invalid_scheduler_policy_value* __thiscall invalid_scheduler_policy_value_ctor(
841 invalid_scheduler_policy_value *this)
842 {
843 return invalid_scheduler_policy_value_ctor_str(this, NULL);
844 }
845
846 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_copy_ctor,8)
847 invalid_scheduler_policy_value * __thiscall invalid_scheduler_policy_value_copy_ctor(
848 invalid_scheduler_policy_value * _this, const invalid_scheduler_policy_value * rhs)
849 {
850 TRACE("(%p %p)\n", _this, rhs);
851 exception_copy_ctor(_this, rhs);
852 _this->vtable = &invalid_scheduler_policy_value_vtable;
853 return _this;
854 }
855
856 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_value_dtor,4)
857 void __thiscall invalid_scheduler_policy_value_dtor(
858 invalid_scheduler_policy_value * _this)
859 {
860 TRACE("(%p)\n", _this);
861 exception_dtor(_this);
862 }
863
864 typedef exception invalid_scheduler_policy_thread_specification;
865 extern const vtable_ptr invalid_scheduler_policy_thread_specification_vtable;
866
867 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@PBD@Z */
868 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QEAA@PEBD@Z */
869 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_ctor_str, 8)
870 invalid_scheduler_policy_thread_specification* __thiscall invalid_scheduler_policy_thread_specification_ctor_str(
871 invalid_scheduler_policy_thread_specification *this, const char *str)
872 {
873 TRACE("(%p %p)\n", this, str);
874 exception_ctor(this, &str);
875 this->vtable = &invalid_scheduler_policy_thread_specification_vtable;
876 return this;
877 }
878
879 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QAE@XZ */
880 /* ??0invalid_scheduler_policy_thread_specification@Concurrency@@QEAA@XZ */
881 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_ctor, 4)
882 invalid_scheduler_policy_thread_specification* __thiscall invalid_scheduler_policy_thread_specification_ctor(
883 invalid_scheduler_policy_thread_specification *this)
884 {
885 return invalid_scheduler_policy_thread_specification_ctor_str(this, NULL);
886 }
887
888 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_copy_ctor,8)
889 invalid_scheduler_policy_thread_specification * __thiscall invalid_scheduler_policy_thread_specification_copy_ctor(
890 invalid_scheduler_policy_thread_specification * _this, const invalid_scheduler_policy_thread_specification * rhs)
891 {
892 TRACE("(%p %p)\n", _this, rhs);
893 exception_copy_ctor(_this, rhs);
894 _this->vtable = &invalid_scheduler_policy_thread_specification_vtable;
895 return _this;
896 }
897
898 DEFINE_THISCALL_WRAPPER(invalid_scheduler_policy_thread_specification_dtor,4)
899 void __thiscall invalid_scheduler_policy_thread_specification_dtor(
900 invalid_scheduler_policy_thread_specification * _this)
901 {
902 TRACE("(%p)\n", _this);
903 exception_dtor(_this);
904 }
905
906 typedef exception improper_scheduler_attach;
907 extern const vtable_ptr improper_scheduler_attach_vtable;
908
909 /* ??0improper_scheduler_attach@Concurrency@@QAE@PBD@Z */
910 /* ??0improper_scheduler_attach@Concurrency@@QEAA@PEBD@Z */
911 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_ctor_str, 8)
912 improper_scheduler_attach* __thiscall improper_scheduler_attach_ctor_str(
913 improper_scheduler_attach *this, const char *str)
914 {
915 TRACE("(%p %p)\n", this, str);
916 exception_ctor(this, &str);
917 this->vtable = &improper_scheduler_attach_vtable;
918 return this;
919 }
920
921 /* ??0improper_scheduler_attach@Concurrency@@QAE@XZ */
922 /* ??0improper_scheduler_attach@Concurrency@@QEAA@XZ */
923 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_ctor, 4)
924 improper_scheduler_attach* __thiscall improper_scheduler_attach_ctor(
925 improper_scheduler_attach *this)
926 {
927 return improper_scheduler_attach_ctor_str(this, NULL);
928 }
929
930 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_copy_ctor,8)
931 improper_scheduler_attach * __thiscall improper_scheduler_attach_copy_ctor(
932 improper_scheduler_attach * _this, const improper_scheduler_attach * rhs)
933 {
934 TRACE("(%p %p)\n", _this, rhs);
935 exception_copy_ctor(_this, rhs);
936 _this->vtable = &improper_scheduler_attach_vtable;
937 return _this;
938 }
939
940 DEFINE_THISCALL_WRAPPER(improper_scheduler_attach_dtor,4)
941 void __thiscall improper_scheduler_attach_dtor(
942 improper_scheduler_attach * _this)
943 {
944 TRACE("(%p)\n", _this);
945 exception_dtor(_this);
946 }
947
948 typedef exception improper_scheduler_detach;
949 extern const vtable_ptr improper_scheduler_detach_vtable;
950
951 /* ??0improper_scheduler_detach@Concurrency@@QAE@PBD@Z */
952 /* ??0improper_scheduler_detach@Concurrency@@QEAA@PEBD@Z */
953 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_ctor_str, 8)
954 improper_scheduler_detach* __thiscall improper_scheduler_detach_ctor_str(
955 improper_scheduler_detach *this, const char *str)
956 {
957 TRACE("(%p %p)\n", this, str);
958 exception_ctor(this, &str);
959 this->vtable = &improper_scheduler_detach_vtable;
960 return this;
961 }
962
963 /* ??0improper_scheduler_detach@Concurrency@@QAE@XZ */
964 /* ??0improper_scheduler_detach@Concurrency@@QEAA@XZ */
965 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_ctor, 4)
966 improper_scheduler_detach* __thiscall improper_scheduler_detach_ctor(
967 improper_scheduler_detach *this)
968 {
969 return improper_scheduler_detach_ctor_str(this, NULL);
970 }
971
972 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_copy_ctor,8)
973 improper_scheduler_detach * __thiscall improper_scheduler_detach_copy_ctor(
974 improper_scheduler_detach * _this, const improper_scheduler_detach * rhs)
975 {
976 TRACE("(%p %p)\n", _this, rhs);
977 exception_copy_ctor(_this, rhs);
978 _this->vtable = &improper_scheduler_detach_vtable;
979 return _this;
980 }
981
982 DEFINE_THISCALL_WRAPPER(improper_scheduler_detach_dtor,4)
983 void __thiscall improper_scheduler_detach_dtor(
984 improper_scheduler_detach * _this)
985 {
986 TRACE("(%p)\n", _this);
987 exception_dtor(_this);
988 }
989
990 #endif /* _MSVCR_VER >= 100 */
991
992 __ASM_BLOCK_BEGIN(vtables)
993
994 __ASM_VTABLE(type_info,
995 VTABLE_ADD_FUNC(type_info_vector_dtor));
996 __ASM_VTABLE(exception,
997 VTABLE_ADD_FUNC(exception_vector_dtor)
998 VTABLE_ADD_FUNC(what_exception));
999 #if _MSVCR_VER >= 80
1000 __ASM_VTABLE(exception_old,
1001 VTABLE_ADD_FUNC(exception_vector_dtor)
1002 VTABLE_ADD_FUNC(what_exception));
1003 __ASM_VTABLE(bad_alloc,
1004 VTABLE_ADD_FUNC(exception_vector_dtor)
1005 VTABLE_ADD_FUNC(what_exception));
1006 #endif
1007 __ASM_VTABLE(bad_typeid,
1008 VTABLE_ADD_FUNC(bad_typeid_vector_dtor)
1009 VTABLE_ADD_FUNC(what_exception));
1010 __ASM_VTABLE(bad_cast,
1011 VTABLE_ADD_FUNC(bad_cast_vector_dtor)
1012 VTABLE_ADD_FUNC(what_exception));
1013 __ASM_VTABLE(__non_rtti_object,
1014 VTABLE_ADD_FUNC(__non_rtti_object_vector_dtor)
1015 VTABLE_ADD_FUNC(what_exception));
1016 #if _MSVCR_VER >= 100
1017 __ASM_VTABLE(scheduler_resource_allocation_error,
1018 VTABLE_ADD_FUNC(exception_vector_dtor)
1019 VTABLE_ADD_FUNC(what_exception));
1020 __ASM_VTABLE(improper_lock,
1021 VTABLE_ADD_FUNC(exception_vector_dtor)
1022 VTABLE_ADD_FUNC(what_exception));
1023 __ASM_VTABLE(invalid_scheduler_policy_key,
1024 VTABLE_ADD_FUNC(exception_vector_dtor)
1025 VTABLE_ADD_FUNC(what_exception));
1026 __ASM_VTABLE(invalid_scheduler_policy_value,
1027 VTABLE_ADD_FUNC(exception_vector_dtor)
1028 VTABLE_ADD_FUNC(what_exception));
1029 __ASM_VTABLE(invalid_scheduler_policy_thread_specification,
1030 VTABLE_ADD_FUNC(exception_vector_dtor)
1031 VTABLE_ADD_FUNC(what_exception));
1032 __ASM_VTABLE(improper_scheduler_attach,
1033 VTABLE_ADD_FUNC(exception_vector_dtor)
1034 VTABLE_ADD_FUNC(what_exception));
1035 __ASM_VTABLE(improper_scheduler_detach,
1036 VTABLE_ADD_FUNC(exception_vector_dtor)
1037 VTABLE_ADD_FUNC(what_exception));
1038 #endif
1039
1040 __ASM_BLOCK_END
1041
1042 DEFINE_RTTI_DATA0( type_info, 0, ".?AVtype_info@@" )
1043 #if _MSVCR_VER >= 80
1044 DEFINE_RTTI_DATA0( exception, 0, ".?AVexception@std@@" )
1045 DEFINE_RTTI_DATA0( exception_old, 0, ".?AVexception@@" )
1046 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@std@@" )
1047 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@std@@" )
1048 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@std@@" )
1049 DEFINE_RTTI_DATA1( bad_alloc, 0, &exception_rtti_base_descriptor, ".?AVbad_alloc@std@@" )
1050 #else
1051 DEFINE_RTTI_DATA0( exception, 0, ".?AVexception@@" )
1052 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@@" )
1053 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@@" )
1054 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@@" )
1055 #endif
1056 #if _MSVCR_VER >= 100
1057 DEFINE_RTTI_DATA1(scheduler_resource_allocation_error, 0, &exception_rtti_base_descriptor,
1058 ".?AVscheduler_resource_allocation_error@Concurrency@@")
1059 DEFINE_RTTI_DATA1(improper_lock, 0, &exception_rtti_base_descriptor, ".?AVimproper_lock@Concurrency@@" )
1060 DEFINE_RTTI_DATA1(invalid_scheduler_policy_key, 0, &exception_rtti_base_descriptor,
1061 ".?AVinvalid_scheduler_policy_key@Concurrency@@" )
1062 DEFINE_RTTI_DATA1(invalid_scheduler_policy_value, 0, &exception_rtti_base_descriptor,
1063 ".?AVinvalid_scheduler_policy_value@Concurrency@@" )
1064 DEFINE_RTTI_DATA1(invalid_scheduler_policy_thread_specification, 0, &exception_rtti_base_descriptor,
1065 ".?AVinvalid_scheduler_policy_thread_specification@Concurrency@@" )
1066 DEFINE_RTTI_DATA1(improper_scheduler_attach, 0, &exception_rtti_base_descriptor,
1067 ".?AVimproper_scheduler_attach@Concurrency@@" )
1068 DEFINE_RTTI_DATA1(improper_scheduler_detach, 0, &exception_rtti_base_descriptor,
1069 ".?AVimproper_scheduler_detach@Concurrency@@" )
1070 #endif
1071
1072 DEFINE_EXCEPTION_TYPE_INFO( exception, 0, NULL, NULL )
1073 DEFINE_EXCEPTION_TYPE_INFO( bad_typeid, 1, &exception_cxx_type_info, NULL )
1074 DEFINE_EXCEPTION_TYPE_INFO( bad_cast, 1, &exception_cxx_type_info, NULL )
1075 DEFINE_EXCEPTION_TYPE_INFO( __non_rtti_object, 2, &bad_typeid_cxx_type_info, &exception_cxx_type_info )
1076 #if _MSVCR_VER >= 80
1077 DEFINE_EXCEPTION_TYPE_INFO( bad_alloc, 1, &exception_cxx_type_info, NULL )
1078 #endif
1079 #if _MSVCR_VER >= 100
1080 DEFINE_EXCEPTION_TYPE_INFO(scheduler_resource_allocation_error, 1, &exception_cxx_type_info, NULL)
1081 DEFINE_EXCEPTION_TYPE_INFO(improper_lock, 1, &exception_cxx_type_info, NULL)
1082 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_key, 1, &exception_cxx_type_info, NULL)
1083 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_value, 1, &exception_cxx_type_info, NULL)
1084 DEFINE_EXCEPTION_TYPE_INFO(invalid_scheduler_policy_thread_specification, 1, &exception_cxx_type_info, NULL)
1085 DEFINE_EXCEPTION_TYPE_INFO(improper_scheduler_attach, 1, &exception_cxx_type_info, NULL)
1086 DEFINE_EXCEPTION_TYPE_INFO(improper_scheduler_detach, 1, &exception_cxx_type_info, NULL)
1087 #endif
1088
1089 void msvcrt_init_exception(void *base)
1090 {
1091 #ifdef __x86_64__
1092 init_type_info_rtti(base);
1093 init_exception_rtti(base);
1094 #if _MSVCR_VER >= 80
1095 init_exception_old_rtti(base);
1096 init_bad_alloc_rtti(base);
1097 #endif
1098 init_bad_typeid_rtti(base);
1099 init_bad_cast_rtti(base);
1100 init___non_rtti_object_rtti(base);
1101 #if _MSVCR_VER >= 100
1102 init_scheduler_resource_allocation_error_rtti(base);
1103 init_improper_lock_rtti(base);
1104 init_invalid_scheduler_policy_key_rtti(base);
1105 init_invalid_scheduler_policy_value_rtti(base);
1106 init_invalid_scheduler_policy_thread_specification_rtti(base);
1107 init_improper_scheduler_attach_rtti(base);
1108 init_improper_scheduler_detach_rtti(base);
1109 #endif
1110
1111 init_exception_cxx(base);
1112 init_bad_typeid_cxx(base);
1113 init_bad_cast_cxx(base);
1114 init___non_rtti_object_cxx(base);
1115 #if _MSVCR_VER >= 80
1116 init_bad_alloc_cxx(base);
1117 #endif
1118 #if _MSVCR_VER >= 100
1119 init_scheduler_resource_allocation_error_cxx(base);
1120 init_improper_lock_cxx(base);
1121 init_invalid_scheduler_policy_key_cxx(base);
1122 init_invalid_scheduler_policy_value_cxx(base);
1123 init_invalid_scheduler_policy_thread_specification_cxx(base);
1124 init_improper_scheduler_attach_cxx(base);
1125 init_improper_scheduler_detach_cxx(base);
1126 #endif
1127 #endif
1128 }
1129
1130 #if _MSVCR_VER >= 80
1131 void throw_exception(exception_type et, HRESULT hr, const char *str)
1132 {
1133 switch(et) {
1134 case EXCEPTION_BAD_ALLOC: {
1135 bad_alloc e;
1136 bad_alloc_ctor(&e, &str);
1137 _CxxThrowException(&e, &bad_alloc_exception_type);
1138 }
1139 #if _MSVCR_VER >= 100
1140 case EXCEPTION_SCHEDULER_RESOURCE_ALLOCATION_ERROR: {
1141 scheduler_resource_allocation_error e;
1142 scheduler_resource_allocation_error_ctor_name(&e, str, hr);
1143 _CxxThrowException(&e.e, &scheduler_resource_allocation_error_exception_type);
1144 }
1145 case EXCEPTION_IMPROPER_LOCK: {
1146 improper_lock e;
1147 improper_lock_ctor_str(&e, str);
1148 _CxxThrowException(&e, &improper_lock_exception_type);
1149 }
1150 case EXCEPTION_INVALID_SCHEDULER_POLICY_KEY: {
1151 invalid_scheduler_policy_key e;
1152 invalid_scheduler_policy_key_ctor_str(&e, str);
1153 _CxxThrowException(&e, &invalid_scheduler_policy_key_exception_type);
1154 }
1155 case EXCEPTION_INVALID_SCHEDULER_POLICY_VALUE: {
1156 invalid_scheduler_policy_value e;
1157 invalid_scheduler_policy_value_ctor_str(&e, str);
1158 _CxxThrowException(&e, &invalid_scheduler_policy_value_exception_type);
1159 }
1160 case EXCEPTION_INVALID_SCHEDULER_POLICY_THREAD_SPECIFICATION: {
1161 invalid_scheduler_policy_thread_specification e;
1162 invalid_scheduler_policy_thread_specification_ctor_str(&e, str);
1163 _CxxThrowException(&e, &invalid_scheduler_policy_thread_specification_exception_type);
1164 }
1165 case EXCEPTION_IMPROPER_SCHEDULER_ATTACH: {
1166 improper_scheduler_attach e;
1167 improper_scheduler_attach_ctor_str(&e, str);
1168 _CxxThrowException(&e, &improper_scheduler_attach_exception_type);
1169 }
1170 case EXCEPTION_IMPROPER_SCHEDULER_DETACH: {
1171 improper_scheduler_detach e;
1172 improper_scheduler_detach_ctor_str(&e, str);
1173 _CxxThrowException(&e, &improper_scheduler_detach_exception_type);
1174 }
1175 #endif
1176 }
1177 }
1178 #endif
1179
1180 /******************************************************************
1181 * ?set_terminate@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
1182 *
1183 * Install a handler to be called when terminate() is called.
1184 *
1185 * PARAMS
1186 * func [I] Handler function to install
1187 *
1188 * RETURNS
1189 * The previously installed handler function, if any.
1190 */
1191 terminate_function CDECL set_terminate(terminate_function func)
1192 {
1193 thread_data_t *data = msvcrt_get_thread_data();
1194 terminate_function previous = data->terminate_handler;
1195 TRACE("(%p) returning %p\n",func,previous);
1196 data->terminate_handler = func;
1197 return previous;
1198 }
1199
1200 /******************************************************************
1201 * _get_terminate (MSVCRT.@)
1202 */
1203 terminate_function CDECL _get_terminate(void)
1204 {
1205 thread_data_t *data = msvcrt_get_thread_data();
1206 TRACE("returning %p\n", data->terminate_handler);
1207 return data->terminate_handler;
1208 }
1209
1210 /******************************************************************
1211 * ?set_unexpected@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
1212 *
1213 * Install a handler to be called when unexpected() is called.
1214 *
1215 * PARAMS
1216 * func [I] Handler function to install
1217 *
1218 * RETURNS
1219 * The previously installed handler function, if any.
1220 */
1221 unexpected_function CDECL set_unexpected(unexpected_function func)
1222 {
1223 thread_data_t *data = msvcrt_get_thread_data();
1224 unexpected_function previous = data->unexpected_handler;
1225 TRACE("(%p) returning %p\n",func,previous);
1226 data->unexpected_handler = func;
1227 return previous;
1228 }
1229
1230 /******************************************************************
1231 * _get_unexpected (MSVCRT.@)
1232 */
1233 unexpected_function CDECL _get_unexpected(void)
1234 {
1235 thread_data_t *data = msvcrt_get_thread_data();
1236 TRACE("returning %p\n", data->unexpected_handler);
1237 return data->unexpected_handler;
1238 }
1239
1240 /******************************************************************
1241 * ?_set_se_translator@@YAP6AXIPAU_EXCEPTION_POINTERS@@@ZP6AXI0@Z@Z (MSVCRT.@)
1242 */
1243 _se_translator_function CDECL _set_se_translator(_se_translator_function func)
1244 {
1245 thread_data_t *data = msvcrt_get_thread_data();
1246 _se_translator_function previous = data->se_translator;
1247 TRACE("(%p) returning %p\n",func,previous);
1248 data->se_translator = func;
1249 return previous;
1250 }
1251
1252 /******************************************************************
1253 * ?terminate@@YAXXZ (MSVCRT.@)
1254 *
1255 * Default handler for an unhandled exception.
1256 *
1257 * PARAMS
1258 * None.
1259 *
1260 * RETURNS
1261 * This function does not return. Either control resumes from any
1262 * handler installed by calling set_terminate(), or (by default) abort()
1263 * is called.
1264 */
1265 void CDECL terminate(void)
1266 {
1267 thread_data_t *data = msvcrt_get_thread_data();
1268 if (data->terminate_handler) data->terminate_handler();
1269 abort();
1270 }
1271
1272 /******************************************************************
1273 * ?unexpected@@YAXXZ (MSVCRT.@)
1274 */
1275 void CDECL unexpected(void)
1276 {
1277 thread_data_t *data = msvcrt_get_thread_data();
1278 if (data->unexpected_handler) data->unexpected_handler();
1279 terminate();
1280 }
1281
1282
1283 /******************************************************************
1284 * __RTtypeid (MSVCRT.@)
1285 *
1286 * Retrieve the Run Time Type Information (RTTI) for a C++ object.
1287 *
1288 * PARAMS
1289 * cppobj [I] C++ object to get type information for.
1290 *
1291 * RETURNS
1292 * Success: A type_info object describing cppobj.
1293 * Failure: If the object to be cast has no RTTI, a __non_rtti_object
1294 * exception is thrown. If cppobj is NULL, a bad_typeid exception
1295 * is thrown. In either case, this function does not return.
1296 *
1297 * NOTES
1298 * This function is usually called by compiler generated code as a result
1299 * of using one of the C++ dynamic cast statements.
1300 */
1301 #ifndef __x86_64__
1302 const type_info* CDECL __RTtypeid(void *cppobj)
1303 {
1304 const type_info *ret;
1305
1306 if (!cppobj)
1307 {
1308 bad_typeid e;
1309 bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
1310 _CxxThrowException( &e, &bad_typeid_exception_type );
1311 return NULL;
1312 }
1313
1314 __TRY
1315 {
1316 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1317 ret = obj_locator->type_descriptor;
1318 }
1319 __EXCEPT_PAGE_FAULT
1320 {
1321 __non_rtti_object e;
1322 __non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
1323 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1324 return NULL;
1325 }
1326 __ENDTRY
1327 return ret;
1328 }
1329
1330 #else
1331
1332 const type_info* CDECL __RTtypeid(void *cppobj)
1333 {
1334 const type_info *ret;
1335
1336 if (!cppobj)
1337 {
1338 bad_typeid e;
1339 bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
1340 _CxxThrowException( &e, &bad_typeid_exception_type );
1341 return NULL;
1342 }
1343
1344 __TRY
1345 {
1346 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1347 char *base;
1348
1349 if(obj_locator->signature == 0)
1350 base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
1351 else
1352 base = (char*)obj_locator - obj_locator->object_locator;
1353
1354 ret = (type_info*)(base + obj_locator->type_descriptor);
1355 }
1356 __EXCEPT_PAGE_FAULT
1357 {
1358 __non_rtti_object e;
1359 __non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
1360 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1361 return NULL;
1362 }
1363 __ENDTRY
1364 return ret;
1365 }
1366 #endif
1367
1368 /******************************************************************
1369 * __RTDynamicCast (MSVCRT.@)
1370 *
1371 * Dynamically cast a C++ object to one of its base classes.
1372 *
1373 * PARAMS
1374 * cppobj [I] Any C++ object to cast
1375 * unknown [I] Reserved, set to 0
1376 * src [I] type_info object describing cppobj
1377 * dst [I] type_info object describing the base class to cast to
1378 * do_throw [I] TRUE = throw an exception if the cast fails, FALSE = don't
1379 *
1380 * RETURNS
1381 * Success: The address of cppobj, cast to the object described by dst.
1382 * Failure: NULL, If the object to be cast has no RTTI, or dst is not a
1383 * valid cast for cppobj. If do_throw is TRUE, a bad_cast exception
1384 * is thrown and this function does not return.
1385 *
1386 * NOTES
1387 * This function is usually called by compiler generated code as a result
1388 * of using one of the C++ dynamic cast statements.
1389 */
1390 #ifndef __x86_64__
1391 void* CDECL __RTDynamicCast(void *cppobj, int unknown,
1392 type_info *src, type_info *dst,
1393 int do_throw)
1394 {
1395 void *ret;
1396
1397 if (!cppobj) return NULL;
1398
1399 TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
1400 cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
1401
1402 /* To cast an object at runtime:
1403 * 1.Find out the true type of the object from the typeinfo at vtable[-1]
1404 * 2.Search for the destination type in the class hierarchy
1405 * 3.If destination type is found, return base object address + dest offset
1406 * Otherwise, fail the cast
1407 *
1408 * FIXME: the unknown parameter doesn't seem to be used for anything
1409 */
1410 __TRY
1411 {
1412 int i;
1413 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1414 const rtti_object_hierarchy *obj_bases = obj_locator->type_hierarchy;
1415 const rtti_base_descriptor * const* base_desc = obj_bases->base_classes->bases;
1416
1417 if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
1418
1419 ret = NULL;
1420 for (i = 0; i < obj_bases->array_len; i++)
1421 {
1422 const type_info *typ = base_desc[i]->type_descriptor;
1423
1424 if (!strcmp(typ->mangled, dst->mangled))
1425 {
1426 /* compute the correct this pointer for that base class */
1427 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
1428 ret = get_this_pointer( &base_desc[i]->offsets, this_ptr );
1429 break;
1430 }
1431 }
1432 /* VC++ sets do_throw to 1 when the result of a dynamic_cast is assigned
1433 * to a reference, since references cannot be NULL.
1434 */
1435 if (!ret && do_throw)
1436 {
1437 const char *msg = "Bad dynamic_cast!";
1438 bad_cast e;
1439 bad_cast_ctor( &e, &msg );
1440 _CxxThrowException( &e, &bad_cast_exception_type );
1441 }
1442 }
1443 __EXCEPT_PAGE_FAULT
1444 {
1445 __non_rtti_object e;
1446 __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1447 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1448 return NULL;
1449 }
1450 __ENDTRY
1451 return ret;
1452 }
1453
1454 #else
1455
1456 void* CDECL __RTDynamicCast(void *cppobj, int unknown,
1457 type_info *src, type_info *dst,
1458 int do_throw)
1459 {
1460 void *ret;
1461
1462 if (!cppobj) return NULL;
1463
1464 TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
1465 cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
1466
1467 __TRY
1468 {
1469 int i;
1470 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1471 const rtti_object_hierarchy *obj_bases;
1472 const rtti_base_array *base_array;
1473 char *base;
1474
1475 if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
1476
1477 if(obj_locator->signature == 0)
1478 base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
1479 else
1480 base = (char*)obj_locator - obj_locator->object_locator;
1481
1482 obj_bases = (const rtti_object_hierarchy*)(base + obj_locator->type_hierarchy);
1483 base_array = (const rtti_base_array*)(base + obj_bases->base_classes);
1484
1485 ret = NULL;
1486 for (i = 0; i < obj_bases->array_len; i++)
1487 {
1488 const rtti_base_descriptor *base_desc = (const rtti_base_descriptor*)(base + base_array->bases[i]);
1489 const type_info *typ = (const type_info*)(base + base_desc->type_descriptor);
1490
1491 if (!strcmp(typ->mangled, dst->mangled))
1492 {
1493 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
1494 ret = get_this_pointer( &base_desc->offsets, this_ptr );
1495 break;
1496 }
1497 }
1498 if (!ret && do_throw)
1499 {
1500 const char *msg = "Bad dynamic_cast!";
1501 bad_cast e;
1502 bad_cast_ctor( &e, &msg );
1503 _CxxThrowException( &e, &bad_cast_exception_type );
1504 }
1505 }
1506 __EXCEPT_PAGE_FAULT
1507 {
1508 __non_rtti_object e;
1509 __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1510 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1511 return NULL;
1512 }
1513 __ENDTRY
1514 return ret;
1515 }
1516 #endif
1517
1518
1519 /******************************************************************
1520 * __RTCastToVoid (MSVCRT.@)
1521 *
1522 * Dynamically cast a C++ object to a void*.
1523 *
1524 * PARAMS
1525 * cppobj [I] The C++ object to cast
1526 *
1527 * RETURNS
1528 * Success: The base address of the object as a void*.
1529 * Failure: NULL, if cppobj is NULL or has no RTTI.
1530 *
1531 * NOTES
1532 * This function is usually called by compiler generated code as a result
1533 * of using one of the C++ dynamic cast statements.
1534 */
1535 void* CDECL __RTCastToVoid(void *cppobj)
1536 {
1537 void *ret;
1538
1539 if (!cppobj) return NULL;
1540
1541 __TRY
1542 {
1543 const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1544 ret = (char *)cppobj - obj_locator->base_class_offset;
1545 }
1546 __EXCEPT_PAGE_FAULT
1547 {
1548 __non_rtti_object e;
1549 __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1550 _CxxThrowException( &e, &__non_rtti_object_exception_type );
1551 return NULL;
1552 }
1553 __ENDTRY
1554 return ret;
1555 }
1556
1557
1558 /*********************************************************************
1559 * _CxxThrowException (MSVCRT.@)
1560 */
1561 #ifndef __x86_64__
1562 void WINAPI _CxxThrowException( exception *object, const cxx_exception_type *type )
1563 {
1564 ULONG_PTR args[3];
1565
1566 args[0] = CXX_FRAME_MAGIC_VC6;
1567 args[1] = (ULONG_PTR)object;
1568 args[2] = (ULONG_PTR)type;
1569 RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 3, args );
1570 }
1571 #else
1572 void WINAPI _CxxThrowException( exception *object, const cxx_exception_type *type )
1573 {
1574 ULONG_PTR args[4];
1575
1576 args[0] = CXX_FRAME_MAGIC_VC6;
1577 args[1] = (ULONG_PTR)object;
1578 args[2] = (ULONG_PTR)type;
1579 RtlPcToFileHeader( (void*)type, (void**)&args[3]);
1580 RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 4, args );
1581 }
1582 #endif
1583
1584 #if _MSVCR_VER >= 80
1585
1586 /*********************************************************************
1587 * ?_is_exception_typeof@@YAHABVtype_info@@PAU_EXCEPTION_POINTERS@@@Z
1588 * ?_is_exception_typeof@@YAHAEBVtype_info@@PEAU_EXCEPTION_POINTERS@@@Z
1589 */
1590 #ifndef __x86_64__
1591 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1592 {
1593 int ret = -1;
1594
1595 TRACE("(%p %p)\n", ti, ep);
1596
1597 __TRY
1598 {
1599 EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1600
1601 if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==3 &&
1602 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1603 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1604 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1605 {
1606 const cxx_type_info_table *tit = ((cxx_exception_type*)rec->ExceptionInformation[2])->type_info_table;
1607 int i;
1608
1609 for (i=0; i<tit->count; i++) {
1610 if (ti==tit->info[i]->type_info || !strcmp(ti->mangled, tit->info[i]->type_info->mangled))
1611 {
1612 ret = 1;
1613 break;
1614 }
1615 }
1616
1617 if (i == tit->count)
1618 ret = 0;
1619 }
1620 }
1621 __EXCEPT_PAGE_FAULT
1622 __ENDTRY
1623
1624 if(ret == -1)
1625 terminate();
1626 return ret;
1627 }
1628 #else
1629 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1630 {
1631 int ret = -1;
1632
1633 TRACE("(%p %p)\n", ti, ep);
1634
1635 __TRY
1636 {
1637 EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1638
1639 if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==4 &&
1640 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1641 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1642 rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1643 {
1644 const cxx_exception_type *et = (cxx_exception_type*)rec->ExceptionInformation[2];
1645 const cxx_type_info_table *tit = (const cxx_type_info_table*)(rec->ExceptionInformation[3]+et->type_info_table);
1646 int i;
1647
1648 for (i=0; i<tit->count; i++) {
1649 const cxx_type_info *cti = (const cxx_type_info*)(rec->ExceptionInformation[3]+tit->info[i]);
1650 const type_info *except_ti = (const type_info*)(rec->ExceptionInformation[3]+cti->type_info);
1651 if (ti==except_ti || !strcmp(ti->mangled, except_ti->mangled))
1652 {
1653 ret = 1;
1654 break;
1655 }
1656 }
1657
1658 if (i == tit->count)
1659 ret = 0;
1660 }
1661 }
1662 __EXCEPT_PAGE_FAULT
1663 __ENDTRY
1664
1665 if(ret == -1)
1666 terminate();
1667 return ret;
1668 }
1669 #endif
1670
1671 /*********************************************************************
1672 * __clean_type_info_names_internal (MSVCR80.@)
1673 */
1674 void CDECL __clean_type_info_names_internal(void *p)
1675 {
1676 FIXME("(%p) stub\n", p);
1677 }
1678
1679 /*********************************************************************
1680 * ?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z (MSVCR100.@)
1681 */
1682 DEFINE_THISCALL_WRAPPER(type_info_name_internal_method,8)
1683 const char * __thiscall type_info_name_internal_method(type_info * _this, struct __type_info_node *node)
1684 {
1685 static int once;
1686 if (node && !once++) FIXME("type_info_node parameter ignored\n");
1687
1688 return type_info_name(_this);
1689 }
1690
1691 #endif /* _MSVCR_VER >= 80 */
1692
1693 /* std::exception_ptr class helpers */
1694 typedef struct
1695 {
1696 EXCEPTION_RECORD *rec;
1697 int *ref; /* not binary compatible with native msvcr100 */
1698 } exception_ptr;
1699
1700 #if _MSVCR_VER >= 100
1701
1702 /*********************************************************************
1703 * ?__ExceptionPtrCreate@@YAXPAX@Z
1704 * ?__ExceptionPtrCreate@@YAXPEAX@Z
1705 */
1706 void __cdecl __ExceptionPtrCreate(exception_ptr *ep)
1707 {
1708 TRACE("(%p)\n", ep);
1709
1710 ep->rec = NULL;
1711 ep->ref = NULL;
1712 }
1713
1714 #ifdef __ASM_USE_THISCALL_WRAPPER
1715 extern void call_dtor(const cxx_exception_type *type, void *func, void *object);
1716
1717 __ASM_GLOBAL_FUNC( call_dtor,
1718 "movl 12(%esp),%ecx\n\t"
1719 "call *8(%esp)\n\t"
1720 "ret" );
1721 #elif __x86_64__
1722 static inline void call_dtor(const cxx_exception_type *type, unsigned int dtor, void *object)
1723 {
1724 char *base = RtlPcToFileHeader((void*)type, (void**)&base);
1725 void (__cdecl *func)(void*) = (void*)(base + dtor);
1726 func(object);
1727 }
1728 #else
1729 #define call_dtor(type, func, object) ((void (__thiscall*)(void*))(func))(object)
1730 #endif
1731
1732 /*********************************************************************
1733 * ?__ExceptionPtrDestroy@@YAXPAX@Z
1734 * ?__ExceptionPtrDestroy@@YAXPEAX@Z
1735 */
1736 void __cdecl __ExceptionPtrDestroy(exception_ptr *ep)
1737 {
1738 TRACE("(%p)\n", ep);
1739
1740 if (!ep->rec)
1741 return;
1742
1743 if (!InterlockedDecrement(ep->ref))
1744 {
1745 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1746 {
1747 const cxx_exception_type *type = (void*)ep->rec->ExceptionInformation[2];
1748 void *obj = (void*)ep->rec->ExceptionInformation[1];
1749
1750 if (type && type->destructor) call_dtor(type, type->destructor, obj);
1751 HeapFree(GetProcessHeap(), 0, obj);
1752 }
1753
1754 HeapFree(GetProcessHeap(), 0, ep->rec);
1755 HeapFree(GetProcessHeap(), 0, ep->ref);
1756 }
1757 }
1758
1759 /*********************************************************************
1760 * ?__ExceptionPtrCopy@@YAXPAXPBX@Z
1761 * ?__ExceptionPtrCopy@@YAXPEAXPEBX@Z
1762 */
1763 void __cdecl __ExceptionPtrCopy(exception_ptr *ep, const exception_ptr *copy)
1764 {
1765 TRACE("(%p %p)\n", ep, copy);
1766
1767 /* don't destroy object stored in ep */
1768 *ep = *copy;
1769 if (ep->ref)
1770 InterlockedIncrement(copy->ref);
1771 }
1772
1773 /*********************************************************************
1774 * ?__ExceptionPtrAssign@@YAXPAXPBX@Z
1775 * ?__ExceptionPtrAssign@@YAXPEAXPEBX@Z
1776 */
1777 void __cdecl __ExceptionPtrAssign(exception_ptr *ep, const exception_ptr *assign)
1778 {
1779 TRACE("(%p %p)\n", ep, assign);
1780
1781 /* don't destroy object stored in ep */
1782 if (ep->ref)
1783 InterlockedDecrement(ep->ref);
1784
1785 *ep = *assign;
1786 if (ep->ref)
1787 InterlockedIncrement(ep->ref);
1788 }
1789
1790 #endif /* _MSVCR_VER >= 100 */
1791
1792 /*********************************************************************
1793 * ?__ExceptionPtrRethrow@@YAXPBX@Z
1794 * ?__ExceptionPtrRethrow@@YAXPEBX@Z
1795 */
1796 void __cdecl __ExceptionPtrRethrow(const exception_ptr *ep)
1797 {
1798 TRACE("(%p)\n", ep);
1799
1800 if (!ep->rec)
1801 {
1802 static const char *exception_msg = "bad exception";
1803 exception e;
1804
1805 exception_ctor(&e, &exception_msg);
1806 _CxxThrowException(&e, &exception_exception_type);
1807 return;
1808 }
1809
1810 RaiseException(ep->rec->ExceptionCode, ep->rec->ExceptionFlags & (~EH_UNWINDING),
1811 ep->rec->NumberParameters, ep->rec->ExceptionInformation);
1812 }
1813
1814 #if _MSVCR_VER >= 100
1815
1816 #ifdef __i386__
1817 extern void call_copy_ctor( void *func, void *this, void *src, int has_vbase );
1818 #else
1819 static inline void call_copy_ctor( void *func, void *this, void *src, int has_vbase )
1820 {
1821 TRACE( "calling copy ctor %p object %p src %p\n", func, this, src );
1822 if (has_vbase)
1823 ((void (__cdecl*)(void*, void*, BOOL))func)(this, src, 1);
1824 else
1825 ((void (__cdecl*)(void*, void*))func)(this, src);
1826 }
1827 #endif
1828
1829 /*********************************************************************
1830 * ?__ExceptionPtrCurrentException@@YAXPAX@Z
1831 * ?__ExceptionPtrCurrentException@@YAXPEAX@Z
1832 */
1833 #ifndef __x86_64__
1834 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1835 {
1836 EXCEPTION_RECORD *rec = msvcrt_get_thread_data()->exc_record;
1837
1838 TRACE("(%p)\n", ep);
1839
1840 if (!rec)
1841 {
1842 ep->rec = NULL;
1843 ep->ref = NULL;
1844 return;
1845 }
1846
1847 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1848 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1849
1850 *ep->rec = *rec;
1851 *ep->ref = 1;
1852
1853 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1854 {
1855 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1856 const cxx_type_info *ti;
1857 void **data, *obj;
1858
1859 ti = et->type_info_table->info[0];
1860 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1861
1862 obj = (void*)ep->rec->ExceptionInformation[1];
1863 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1864 {
1865 memcpy(data, obj, ti->size);
1866 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1867 }
1868 else if (ti->copy_ctor)
1869 {
1870 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1871 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1872 }
1873 else
1874 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1875 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1876 }
1877 return;
1878 }
1879 #else
1880 void __cdecl __ExceptionPtrCurrentException(exception_ptr *ep)
1881 {
1882 EXCEPTION_RECORD *rec = msvcrt_get_thread_data()->exc_record;
1883
1884 TRACE("(%p)\n", ep);
1885
1886 if (!rec)
1887 {
1888 ep->rec = NULL;
1889 ep->ref = NULL;
1890 return;
1891 }
1892
1893 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1894 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1895
1896 *ep->rec = *rec;
1897 *ep->ref = 1;
1898
1899 if (ep->rec->ExceptionCode == CXX_EXCEPTION)
1900 {
1901 const cxx_exception_type *et = (void*)ep->rec->ExceptionInformation[2];
1902 const cxx_type_info *ti;
1903 void **data, *obj;
1904 char *base = RtlPcToFileHeader((void*)et, (void**)&base);
1905
1906 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + et->type_info_table))->info[0]);
1907 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1908
1909 obj = (void*)ep->rec->ExceptionInformation[1];
1910 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1911 {
1912 memcpy(data, obj, ti->size);
1913 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1914 }
1915 else if (ti->copy_ctor)
1916 {
1917 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, obj),
1918 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1919 }
1920 else
1921 memcpy(data, get_this_pointer(&ti->offsets, obj), ti->size);
1922 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1923 }
1924 return;
1925 }
1926 #endif
1927
1928 #endif /* _MSVCR_VER >= 100 */
1929
1930 #if _MSVCR_VER >= 110
1931 /*********************************************************************
1932 * ?__ExceptionPtrToBool@@YA_NPBX@Z
1933 * ?__ExceptionPtrToBool@@YA_NPEBX@Z
1934 */
1935 bool __cdecl __ExceptionPtrToBool(exception_ptr *ep)
1936 {
1937 return !!ep->rec;
1938 }
1939 #endif
1940
1941 #if _MSVCR_VER >= 100
1942
1943 /*********************************************************************
1944 * ?__ExceptionPtrCopyException@@YAXPAXPBX1@Z
1945 * ?__ExceptionPtrCopyException@@YAXPEAXPEBX1@Z
1946 */
1947 #ifndef __x86_64__
1948 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1949 exception *object, const cxx_exception_type *type)
1950 {
1951 const cxx_type_info *ti;
1952 void **data;
1953
1954 __ExceptionPtrDestroy(ep);
1955
1956 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1957 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1958 *ep->ref = 1;
1959
1960 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
1961 ep->rec->ExceptionCode = CXX_EXCEPTION;
1962 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
1963 ep->rec->NumberParameters = 3;
1964 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
1965 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
1966
1967 ti = type->type_info_table->info[0];
1968 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
1969 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
1970 {
1971 memcpy(data, object, ti->size);
1972 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
1973 }
1974 else if (ti->copy_ctor)
1975 {
1976 call_copy_ctor(ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
1977 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
1978 }
1979 else
1980 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
1981 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
1982 }
1983 #else
1984 void __cdecl __ExceptionPtrCopyException(exception_ptr *ep,
1985 exception *object, const cxx_exception_type *type)
1986 {
1987 const cxx_type_info *ti;
1988 void **data;
1989 char *base;
1990
1991 RtlPcToFileHeader((void*)type, (void**)&base);
1992 __ExceptionPtrDestroy(ep);
1993
1994 ep->rec = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCEPTION_RECORD));
1995 ep->ref = HeapAlloc(GetProcessHeap(), 0, sizeof(int));
1996 *ep->ref = 1;
1997
1998 memset(ep->rec, 0, sizeof(EXCEPTION_RECORD));
1999 ep->rec->ExceptionCode = CXX_EXCEPTION;
2000 ep->rec->ExceptionFlags = EH_NONCONTINUABLE;
2001 ep->rec->NumberParameters = 4;
2002 ep->rec->ExceptionInformation[0] = CXX_FRAME_MAGIC_VC6;
2003 ep->rec->ExceptionInformation[2] = (ULONG_PTR)type;
2004 ep->rec->ExceptionInformation[3] = (ULONG_PTR)base;
2005
2006 ti = (const cxx_type_info*)(base + ((const cxx_type_info_table*)(base + type->type_info_table))->info[0]);
2007 data = HeapAlloc(GetProcessHeap(), 0, ti->size);
2008 if (ti->flags & CLASS_IS_SIMPLE_TYPE)
2009 {
2010 memcpy(data, object, ti->size);
2011 if (ti->size == sizeof(void *)) *data = get_this_pointer(&ti->offsets, *data);
2012 }
2013 else if (ti->copy_ctor)
2014 {
2015 call_copy_ctor(base + ti->copy_ctor, data, get_this_pointer(&ti->offsets, object),
2016 ti->flags & CLASS_HAS_VIRTUAL_BASE_CLASS);
2017 }
2018 else
2019 memcpy(data, get_this_pointer(&ti->offsets, object), ti->size);
2020 ep->rec->ExceptionInformation[1] = (ULONG_PTR)data;
2021 }
2022 #endif
2023
2024 bool __cdecl __ExceptionPtrCompare(const exception_ptr *ep1, const exception_ptr *ep2)
2025 {
2026 return ep1->rec == ep2->rec;
2027 }
2028
2029 #endif /* _MSVCR_VER >= 100 */
2030
2031 #if _MSVCR_VER >= 80
2032 void* __cdecl __AdjustPointer(void *obj, const this_ptr_offsets *off)
2033 {
2034 return get_this_pointer(off, obj);
2035 }
2036 #endif
2037
2038 #if _MSVCR_VER >= 140
2039
2040 typedef struct
2041 {
2042 char *name;
2043 char mangled[1];
2044 } type_info140;
2045
2046 typedef struct
2047 {
2048 SLIST_ENTRY entry;
2049 char name[1];
2050 } type_info_entry;
2051
2052 static void* CDECL type_info_entry_malloc(size_t size)
2053 {
2054 type_info_entry *ret = malloc(FIELD_OFFSET(type_info_entry, name) + size);
2055 return ret->name;
2056 }
2057
2058 static void CDECL type_info_entry_free(void *ptr)
2059 {
2060 ptr = (char*)ptr - FIELD_OFFSET(type_info_entry, name);
2061 free(ptr);
2062 }
2063
2064 /******************************************************************
2065 * __std_type_info_compare (UCRTBASE.@)
2066 */
2067 int CDECL __std_type_info_compare(const type_info140 *l, const type_info140 *r)
2068 {
2069 int ret;
2070
2071 if (l == r) ret = 0;
2072 else ret = strcmp(l->mangled + 1, r->mangled + 1);
2073 TRACE("(%p %p) returning %d\n", l, r, ret);
2074 return ret;
2075 }
2076
2077 /******************************************************************
2078 * __std_type_info_name (UCRTBASE.@)
2079 */
2080 const char* CDECL __std_type_info_name(type_info140 *ti, SLIST_HEADER *header)
2081 {
2082 if (!ti->name)
2083 {
2084 char* name = __unDName(0, ti->mangled + 1, 0,
2085 type_info_entry_malloc, type_info_entry_free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
2086 if (name)
2087 {
2088 unsigned int len = strlen(name);
2089
2090 while (len && name[--len] == ' ')
2091 name[len] = '\0';
2092
2093 if (InterlockedCompareExchangePointer((void**)&ti->name, name, NULL))
2094 {
2095 type_info_entry_free(name);
2096 }
2097 else
2098 {
2099 type_info_entry *entry = (type_info_entry*)(name-FIELD_OFFSET(type_info_entry, name));
2100 InterlockedPushEntrySList(header, &entry->entry);
2101 }
2102 }
2103 }
2104 TRACE("(%p) returning %s\n", ti, ti->name);
2105 return ti->name;
2106 }
2107
2108 /******************************************************************
2109 * __std_type_info_destroy_list (UCRTBASE.@)
2110 */
2111 void CDECL __std_type_info_destroy_list(SLIST_HEADER *header)
2112 {
2113 SLIST_ENTRY *cur, *next;
2114
2115 TRACE("(%p)\n", header);
2116
2117 for(cur = InterlockedFlushSList(header); cur; cur = next)
2118 {
2119 next = cur->Next;
2120 free(cur);
2121 }
2122 }
2123
2124 /******************************************************************
2125 * __std_type_info_hash (UCRTBASE.@)
2126 */
2127 size_t CDECL __std_type_info_hash(const type_info140 *ti)
2128 {
2129 size_t hash, fnv_prime;
2130 const char *p;
2131
2132 #ifdef _WIN64
2133 hash = 0xcbf29ce484222325;
2134 fnv_prime = 0x100000001b3;
2135 #else
2136 hash = 0x811c9dc5;
2137 fnv_prime = 0x1000193;
2138 #endif
2139
2140 TRACE("(%p)->%s\n", ti, ti->mangled);
2141
2142 for(p = ti->mangled+1; *p; p++) {
2143 hash ^= *p;
2144 hash *= fnv_prime;
2145 }
2146
2147 #ifdef _WIN64
2148 hash ^= hash >> 32;
2149 #endif
2150
2151 return hash;
2152 }
2153
2154 #endif /* _MSVCR_VER >= 140 */
2155
2156 #if _MSVCR_VER >= 100
2157
2158 enum ConcRT_EventType
2159 {
2160 CONCRT_EVENT_GENERIC,
2161 CONCRT_EVENT_START,
2162 CONCRT_EVENT_END,
2163 CONCRT_EVENT_BLOCK,
2164 CONCRT_EVENT_UNBLOCK,
2165 CONCRT_EVENT_YIELD,
2166 CONCRT_EVENT_ATTACH,
2167 CONCRT_EVENT_DETACH
2168 };
2169
2170 /* ?_Trace_ppl_function@Concurrency@@YAXABU_GUID@@EW4ConcRT_EventType@1@@Z */
2171 /* ?_Trace_ppl_function@Concurrency@@YAXAEBU_GUID@@EW4ConcRT_EventType@1@@Z */
2172 void __cdecl Concurrency__Trace_ppl_function(const GUID *guid, unsigned char level, enum ConcRT_EventType type)
2173 {
2174 FIXME("(%s %u %i) stub\n", debugstr_guid(guid), level, type);
2175 }
2176
2177 #endif /* _MSVCR_VER >= 100 */
Windows API implementation