dlls/msvcrt/cpp.c

   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 "winbase.h"
  28 #include "winver.h"
  29 #include "imagehlp.h"
  30 #include "wine/exception.h"
  31 #include "wine/debug.h"
  32 #include "msvcrt.h"
  33 #include "mtdll.h"
  34 #include "cxx.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  37
  38 CREATE_TYPE_INFO_VTABLE
  39 CREATE_EXCEPTION_OBJECT(exception)
  40
  41 struct __type_info_node
  42 {
  43     void *memPtr;
  44     struct __type_info_node* next;
  45 };
  46
  47 typedef exception bad_cast;
  48 typedef exception bad_typeid;
  49 typedef exception __non_rtti_object;
  50
  51 extern const vtable_ptr bad_typeid_vtable;
  52 extern const vtable_ptr bad_cast_vtable;
  53 extern const vtable_ptr __non_rtti_object_vtable;
  54 extern const vtable_ptr type_info_vtable;
  55
  56 /* get the vtable pointer for a C++ object */
  57 static inline const vtable_ptr *get_vtable( void *obj )
  58 {
  59     return *(const vtable_ptr **)obj;
  60 }
  61
  62 static inline const rtti_object_locator *get_obj_locator( void *cppobj )
  63 {
  64     const vtable_ptr *vtable = get_vtable( cppobj );
  65     return (const rtti_object_locator *)vtable[-1];
  66 }
  67
  68 #ifndef __x86_64__
  69 static void dump_obj_locator( const rtti_object_locator *ptr )
  70 {
  71     int i;
  72     const rtti_object_hierarchy *h = ptr->type_hierarchy;
  73
  74     TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
  75            ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
  76            ptr->type_descriptor, dbgstr_type_info(ptr->type_descriptor), ptr->type_hierarchy );
  77     TRACE( "  hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
  78            h->signature, h->attributes, h->array_len, h->base_classes );
  79     for (i = 0; i < h->array_len; i++)
  80     {
  81         TRACE( "    base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
  82                h->base_classes->bases[i],
  83                h->base_classes->bases[i]->num_base_classes,
  84                h->base_classes->bases[i]->offsets.this_offset,
  85                h->base_classes->bases[i]->offsets.vbase_descr,
  86                h->base_classes->bases[i]->offsets.vbase_offset,
  87                h->base_classes->bases[i]->attributes,
  88                h->base_classes->bases[i]->type_descriptor,
  89                dbgstr_type_info(h->base_classes->bases[i]->type_descriptor) );
  90     }
  91 }
  92
  93 #else
  94
  95 static void dump_obj_locator( const rtti_object_locator *ptr )
  96 {
  97     int i;
  98     char *base = ptr->signature == 0 ? RtlPcToFileHeader((void*)ptr, (void**)&base) : (char*)ptr - ptr->object_locator;
  99     const rtti_object_hierarchy *h = (const rtti_object_hierarchy*)(base + ptr->type_hierarchy);
 100     const type_info *type_descriptor = (const type_info*)(base + ptr->type_descriptor);
 101
 102     TRACE( "%p: sig=%08x base_offset=%08x flags=%08x type=%p %s hierarchy=%p\n",
 103             ptr, ptr->signature, ptr->base_class_offset, ptr->flags,
 104             type_descriptor, dbgstr_type_info(type_descriptor), h );
 105     TRACE( "  hierarchy: sig=%08x attr=%08x len=%d base classes=%p\n",
 106             h->signature, h->attributes, h->array_len, base + h->base_classes );
 107     for (i = 0; i < h->array_len; i++)
 108     {
 109         const rtti_base_descriptor *bases = (rtti_base_descriptor*)(base +
 110                 ((const rtti_base_array*)(base + h->base_classes))->bases[i]);
 111
 112         TRACE( "    base class %p: num %d off %d,%d,%d attr %08x type %p %s\n",
 113                 bases,
 114                 bases->num_base_classes,
 115                 bases->offsets.this_offset,
 116                 bases->offsets.vbase_descr,
 117                 bases->offsets.vbase_offset,
 118                 bases->attributes,
 119                 base + bases->type_descriptor,
 120                 dbgstr_type_info((const type_info*)(base + bases->type_descriptor)) );
 121     }
 122 }
 123 #endif
 124
 125 /******************************************************************
 126  *              ??0exception@@QAE@ABQBD@Z (MSVCRT.@)
 127  */
 128 DEFINE_THISCALL_WRAPPER(exception_ctor,8)
 129 exception * __thiscall exception_ctor(exception * _this, const char ** name)
 130 {
 131   TRACE("(%p,%s)\n", _this, *name);
 132   return __exception_ctor(_this, *name, &exception_vtable);
 133 }
 134
 135 /******************************************************************
 136  *              ??0exception@@QAE@ABQBDH@Z (MSVCRT.@)
 137  */
 138 DEFINE_THISCALL_WRAPPER(exception_ctor_noalloc,12)
 139 exception * __thiscall exception_ctor_noalloc(exception * _this, char ** name, int noalloc)
 140 {
 141   TRACE("(%p,%s)\n", _this, *name);
 142   _this->vtable = &exception_vtable;
 143   _this->name = *name;
 144   _this->do_free = FALSE;
 145   return _this;
 146 }
 147
 148 /******************************************************************
 149  *              ??0exception@@QAE@XZ (MSVCRT.@)
 150  */
 151 DEFINE_THISCALL_WRAPPER(exception_default_ctor,4)
 152 exception * __thiscall exception_default_ctor(exception * _this)
 153 {
 154   TRACE("(%p)\n", _this);
 155   return __exception_ctor(_this, NULL, &exception_vtable);
 156 }
 157
 158 /******************************************************************
 159  *              ??4exception@@QAEAAV0@ABV0@@Z (MSVCRT.@)
 160  */
 161 DEFINE_THISCALL_WRAPPER(exception_opequals,8)
 162 exception * __thiscall exception_opequals(exception * _this, const exception * rhs)
 163 {
 164   TRACE("(%p %p)\n", _this, rhs);
 165   if (_this != rhs)
 166   {
 167       exception_dtor(_this);
 168       exception_copy_ctor(_this, rhs);
 169   }
 170   TRACE("name = %s\n", _this->name);
 171   return _this;
 172 }
 173
 174 /******************************************************************
 175  *              ??_Gexception@@UAEPAXI@Z (MSVCRT.@)
 176  */
 177 DEFINE_THISCALL_WRAPPER(exception_scalar_dtor,8)
 178 void * __thiscall exception_scalar_dtor(exception * _this, unsigned int flags)
 179 {
 180     TRACE("(%p %x)\n", _this, flags);
 181     exception_dtor(_this);
 182     if (flags & 1) operator_delete(_this);
 183     return _this;
 184 }
 185
 186 /******************************************************************
 187  *              ??0bad_typeid@@QAE@ABV0@@Z (MSVCRT.@)
 188  */
 189 DEFINE_THISCALL_WRAPPER(bad_typeid_copy_ctor,8)
 190 bad_typeid * __thiscall bad_typeid_copy_ctor(bad_typeid * _this, const bad_typeid * rhs)
 191 {
 192   TRACE("(%p %p)\n", _this, rhs);
 193   return __exception_copy_ctor(_this, rhs, &bad_typeid_vtable);
 194 }
 195
 196 /******************************************************************
 197  *              ??0bad_typeid@@QAE@PBD@Z (MSVCRT.@)
 198  */
 199 DEFINE_THISCALL_WRAPPER(bad_typeid_ctor,8)
 200 bad_typeid * __thiscall bad_typeid_ctor(bad_typeid * _this, const char * name)
 201 {
 202   TRACE("(%p %s)\n", _this, name);
 203   return __exception_ctor(_this, name, &bad_typeid_vtable);
 204 }
 205
 206 /******************************************************************
 207  *              ??_Fbad_typeid@@QAEXXZ (MSVCRT.@)
 208  */
 209 DEFINE_THISCALL_WRAPPER(bad_typeid_default_ctor,4)
 210 bad_typeid * __thiscall bad_typeid_default_ctor(bad_typeid * _this)
 211 {
 212   return bad_typeid_ctor( _this, "bad typeid" );
 213 }
 214
 215 /******************************************************************
 216  *              ??1bad_typeid@@UAE@XZ (MSVCRT.@)
 217  */
 218 DEFINE_THISCALL_WRAPPER(bad_typeid_dtor,4)
 219 void __thiscall bad_typeid_dtor(bad_typeid * _this)
 220 {
 221   TRACE("(%p)\n", _this);
 222   exception_dtor(_this);
 223 }
 224
 225 /******************************************************************
 226  *              ??4bad_typeid@@QAEAAV0@ABV0@@Z (MSVCRT.@)
 227  */
 228 DEFINE_THISCALL_WRAPPER(bad_typeid_opequals,8)
 229 bad_typeid * __thiscall bad_typeid_opequals(bad_typeid * _this, const bad_typeid * rhs)
 230 {
 231   TRACE("(%p %p)\n", _this, rhs);
 232   exception_opequals(_this, rhs);
 233   return _this;
 234 }
 235
 236 /******************************************************************
 237  *              ??_Ebad_typeid@@UAEPAXI@Z (MSVCRT.@)
 238  */
 239 DEFINE_THISCALL_WRAPPER(bad_typeid_vector_dtor,8)
 240 void * __thiscall bad_typeid_vector_dtor(bad_typeid * _this, unsigned int flags)
 241 {
 242     TRACE("(%p %x)\n", _this, flags);
 243     if (flags & 2)
 244     {
 245         /* we have an array, with the number of elements stored before the first object */
 246         INT_PTR i, *ptr = (INT_PTR *)_this - 1;
 247
 248         for (i = *ptr - 1; i >= 0; i--) bad_typeid_dtor(_this + i);
 249         operator_delete(ptr);
 250     }
 251     else
 252     {
 253         bad_typeid_dtor(_this);
 254         if (flags & 1) operator_delete(_this);
 255     }
 256     return _this;
 257 }
 258
 259 /******************************************************************
 260  *              ??_Gbad_typeid@@UAEPAXI@Z (MSVCRT.@)
 261  */
 262 DEFINE_THISCALL_WRAPPER(bad_typeid_scalar_dtor,8)
 263 void * __thiscall bad_typeid_scalar_dtor(bad_typeid * _this, unsigned int flags)
 264 {
 265     TRACE("(%p %x)\n", _this, flags);
 266     bad_typeid_dtor(_this);
 267     if (flags & 1) operator_delete(_this);
 268     return _this;
 269 }
 270
 271 /******************************************************************
 272  *              ??0__non_rtti_object@@QAE@ABV0@@Z (MSVCRT.@)
 273  */
 274 DEFINE_THISCALL_WRAPPER(__non_rtti_object_copy_ctor,8)
 275 __non_rtti_object * __thiscall __non_rtti_object_copy_ctor(__non_rtti_object * _this,
 276                                                                  const __non_rtti_object * rhs)
 277 {
 278     TRACE("(%p %p)\n", _this, rhs);
 279     return __exception_copy_ctor(_this, rhs, &__non_rtti_object_vtable);
 280 }
 281
 282 /******************************************************************
 283  *              ??0__non_rtti_object@@QAE@PBD@Z (MSVCRT.@)
 284  */
 285 DEFINE_THISCALL_WRAPPER(__non_rtti_object_ctor,8)
 286 __non_rtti_object * __thiscall __non_rtti_object_ctor(__non_rtti_object * _this,
 287                                                             const char * name)
 288 {
 289   TRACE("(%p %s)\n", _this, name);
 290   return __exception_ctor(_this, name, &__non_rtti_object_vtable);
 291 }
 292
 293 /******************************************************************
 294  *              ??1__non_rtti_object@@UAE@XZ (MSVCRT.@)
 295  */
 296 DEFINE_THISCALL_WRAPPER(__non_rtti_object_dtor,4)
 297 void __thiscall __non_rtti_object_dtor(__non_rtti_object * _this)
 298 {
 299   TRACE("(%p)\n", _this);
 300   bad_typeid_dtor(_this);
 301 }
 302
 303 /******************************************************************
 304  *              ??4__non_rtti_object@@QAEAAV0@ABV0@@Z (MSVCRT.@)
 305  */
 306 DEFINE_THISCALL_WRAPPER(__non_rtti_object_opequals,8)
 307 __non_rtti_object * __thiscall __non_rtti_object_opequals(__non_rtti_object * _this,
 308                                                                 const __non_rtti_object *rhs)
 309 {
 310   TRACE("(%p %p)\n", _this, rhs);
 311   bad_typeid_opequals(_this, rhs);
 312   return _this;
 313 }
 314
 315 /******************************************************************
 316  *              ??_E__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
 317  */
 318 DEFINE_THISCALL_WRAPPER(__non_rtti_object_vector_dtor,8)
 319 void * __thiscall __non_rtti_object_vector_dtor(__non_rtti_object * _this, unsigned int flags)
 320 {
 321     TRACE("(%p %x)\n", _this, flags);
 322     if (flags & 2)
 323     {
 324         /* we have an array, with the number of elements stored before the first object */
 325         INT_PTR i, *ptr = (INT_PTR *)_this - 1;
 326
 327         for (i = *ptr - 1; i >= 0; i--) __non_rtti_object_dtor(_this + i);
 328         operator_delete(ptr);
 329     }
 330     else
 331     {
 332         __non_rtti_object_dtor(_this);
 333         if (flags & 1) operator_delete(_this);
 334     }
 335     return _this;
 336 }
 337
 338 /******************************************************************
 339  *              ??_G__non_rtti_object@@UAEPAXI@Z (MSVCRT.@)
 340  */
 341 DEFINE_THISCALL_WRAPPER(__non_rtti_object_scalar_dtor,8)
 342 void * __thiscall __non_rtti_object_scalar_dtor(__non_rtti_object * _this, unsigned int flags)
 343 {
 344   TRACE("(%p %x)\n", _this, flags);
 345   __non_rtti_object_dtor(_this);
 346   if (flags & 1) operator_delete(_this);
 347   return _this;
 348 }
 349
 350 /******************************************************************
 351  *              ??0bad_cast@@AAE@PBQBD@Z (MSVCRT.@)
 352  *              ??0bad_cast@@QAE@ABQBD@Z (MSVCRT.@)
 353  */
 354 DEFINE_THISCALL_WRAPPER(bad_cast_ctor,8)
 355 bad_cast * __thiscall bad_cast_ctor(bad_cast * _this, const char ** name)
 356 {
 357   TRACE("(%p %s)\n", _this, *name);
 358   return __exception_ctor(_this, *name, &bad_cast_vtable);
 359 }
 360
 361 /******************************************************************
 362  *              ??0bad_cast@@QAE@ABV0@@Z (MSVCRT.@)
 363  */
 364 DEFINE_THISCALL_WRAPPER(bad_cast_copy_ctor,8)
 365 bad_cast * __thiscall bad_cast_copy_ctor(bad_cast * _this, const bad_cast * rhs)
 366 {
 367   TRACE("(%p %p)\n", _this, rhs);
 368   return __exception_copy_ctor(_this, rhs, &bad_cast_vtable);
 369 }
 370
 371 /******************************************************************
 372  *              ??0bad_cast@@QAE@PBD@Z (MSVCRT.@)
 373  */
 374 DEFINE_THISCALL_WRAPPER(bad_cast_ctor_charptr,8)
 375 bad_cast * __thiscall bad_cast_ctor_charptr(bad_cast * _this, const char * name)
 376 {
 377   TRACE("(%p %s)\n", _this, name);
 378   return __exception_ctor(_this, name, &bad_cast_vtable);
 379 }
 380
 381 /******************************************************************
 382  *              ??_Fbad_cast@@QAEXXZ (MSVCRT.@)
 383  */
 384 DEFINE_THISCALL_WRAPPER(bad_cast_default_ctor,4)
 385 bad_cast * __thiscall bad_cast_default_ctor(bad_cast * _this)
 386 {
 387   return bad_cast_ctor_charptr( _this, "bad cast" );
 388 }
 389
 390 /******************************************************************
 391  *              ??1bad_cast@@UAE@XZ (MSVCRT.@)
 392  */
 393 DEFINE_THISCALL_WRAPPER(bad_cast_dtor,4)
 394 void __thiscall bad_cast_dtor(bad_cast * _this)
 395 {
 396   TRACE("(%p)\n", _this);
 397   exception_dtor(_this);
 398 }
 399
 400 /******************************************************************
 401  *              ??4bad_cast@@QAEAAV0@ABV0@@Z (MSVCRT.@)
 402  */
 403 DEFINE_THISCALL_WRAPPER(bad_cast_opequals,8)
 404 bad_cast * __thiscall bad_cast_opequals(bad_cast * _this, const bad_cast * rhs)
 405 {
 406   TRACE("(%p %p)\n", _this, rhs);
 407   exception_opequals(_this, rhs);
 408   return _this;
 409 }
 410
 411 /******************************************************************
 412  *              ??_Ebad_cast@@UAEPAXI@Z (MSVCRT.@)
 413  */
 414 DEFINE_THISCALL_WRAPPER(bad_cast_vector_dtor,8)
 415 void * __thiscall bad_cast_vector_dtor(bad_cast * _this, unsigned int flags)
 416 {
 417     TRACE("(%p %x)\n", _this, flags);
 418     if (flags & 2)
 419     {
 420         /* we have an array, with the number of elements stored before the first object */
 421         INT_PTR i, *ptr = (INT_PTR *)_this - 1;
 422
 423         for (i = *ptr - 1; i >= 0; i--) bad_cast_dtor(_this + i);
 424         operator_delete(ptr);
 425     }
 426     else
 427     {
 428         bad_cast_dtor(_this);
 429         if (flags & 1) operator_delete(_this);
 430     }
 431     return _this;
 432 }
 433
 434 /******************************************************************
 435  *              ??_Gbad_cast@@UAEPAXI@Z (MSVCRT.@)
 436  */
 437 DEFINE_THISCALL_WRAPPER(bad_cast_scalar_dtor,8)
 438 void * __thiscall bad_cast_scalar_dtor(bad_cast * _this, unsigned int flags)
 439 {
 440   TRACE("(%p %x)\n", _this, flags);
 441   bad_cast_dtor(_this);
 442   if (flags & 1) operator_delete(_this);
 443   return _this;
 444 }
 445
 446 /******************************************************************
 447  *              ??8type_info@@QBEHABV0@@Z (MSVCRT.@)
 448  */
 449 DEFINE_THISCALL_WRAPPER(type_info_opequals_equals,8)
 450 int __thiscall type_info_opequals_equals(type_info * _this, const type_info * rhs)
 451 {
 452     int ret = !strcmp(_this->mangled + 1, rhs->mangled + 1);
 453     TRACE("(%p %p) returning %d\n", _this, rhs, ret);
 454     return ret;
 455 }
 456
 457 /******************************************************************
 458  *              ??9type_info@@QBEHABV0@@Z (MSVCRT.@)
 459  */
 460 DEFINE_THISCALL_WRAPPER(type_info_opnot_equals,8)
 461 int __thiscall type_info_opnot_equals(type_info * _this, const type_info * rhs)
 462 {
 463     int ret = !!strcmp(_this->mangled + 1, rhs->mangled + 1);
 464     TRACE("(%p %p) returning %d\n", _this, rhs, ret);
 465     return ret;
 466 }
 467
 468 /******************************************************************
 469  *              ?before@type_info@@QBEHABV1@@Z (MSVCRT.@)
 470  */
 471 DEFINE_THISCALL_WRAPPER(type_info_before,8)
 472 int __thiscall type_info_before(type_info * _this, const type_info * rhs)
 473 {
 474     int ret = strcmp(_this->mangled + 1, rhs->mangled + 1) < 0;
 475     TRACE("(%p %p) returning %d\n", _this, rhs, ret);
 476     return ret;
 477 }
 478
 479 /******************************************************************
 480  *              ??1type_info@@UAE@XZ (MSVCRT.@)
 481  */
 482 DEFINE_THISCALL_WRAPPER(type_info_dtor,4)
 483 void __thiscall type_info_dtor(type_info * _this)
 484 {
 485   TRACE("(%p)\n", _this);
 486   free(_this->name);
 487 }
 488
 489 /******************************************************************
 490  *              ?name@type_info@@QBEPBDXZ (MSVCRT.@)
 491  */
 492 DEFINE_THISCALL_WRAPPER(type_info_name,4)
 493 const char * __thiscall type_info_name(type_info * _this)
 494 {
 495   if (!_this->name)
 496   {
 497     /* Create and set the demangled name */
 498     /* Note: mangled name in type_info struct always starts with a '.', while
 499      * it isn't valid for mangled name.
 500      * Is this '.' really part of the mangled name, or has it some other meaning ?
 501      */
 502     char* name = __unDName(0, _this->mangled + 1, 0,
 503                            malloc, free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
 504     if (name)
 505     {
 506       unsigned int len = strlen(name);
 507
 508       /* It seems _unDName may leave blanks at the end of the demangled name */
 509       while (len && name[--len] == ' ')
 510         name[len] = '\0';
 511
 512       if (InterlockedCompareExchangePointer((void**)&_this->name, name, NULL))
 513       {
 514         /* Another thread set this member since we checked above - use it */
 515         free(name);
 516       }
 517     }
 518   }
 519   TRACE("(%p) returning %s\n", _this, _this->name);
 520   return _this->name;
 521 }
 522
 523 /******************************************************************
 524  *              ?raw_name@type_info@@QBEPBDXZ (MSVCRT.@)
 525  */
 526 DEFINE_THISCALL_WRAPPER(type_info_raw_name,4)
 527 const char * __thiscall type_info_raw_name(type_info * _this)
 528 {
 529   TRACE("(%p) returning %s\n", _this, _this->mangled);
 530   return _this->mangled;
 531 }
 532
 533 #if _MSVCR_VER >= 80
 534
 535 typedef exception bad_alloc;
 536 extern const vtable_ptr bad_alloc_vtable;
 537
 538 /* bad_alloc class implementation */
 539 DEFINE_THISCALL_WRAPPER(bad_alloc_copy_ctor,8)
 540 bad_alloc * __thiscall bad_alloc_copy_ctor(bad_alloc * _this, const bad_alloc * rhs)
 541 {
 542     TRACE("(%p %p)\n", _this, rhs);
 543     return __exception_copy_ctor(_this, rhs, &bad_alloc_vtable);
 544 }
 545
 546 DEFINE_THISCALL_WRAPPER(bad_alloc_dtor,4)
 547 void __thiscall bad_alloc_dtor(bad_alloc * _this)
 548 {
 549     TRACE("(%p)\n", _this);
 550     exception_dtor(_this);
 551 }
 552
 553 #endif /* _MSVCR_VER >= 80 */
 554
 555 __ASM_BLOCK_BEGIN(vtables)
 556
 557 #if _MSVCR_VER >= 80
 558 __ASM_VTABLE(exception_old,
 559         VTABLE_ADD_FUNC(exception_vector_dtor)
 560         VTABLE_ADD_FUNC(exception_what));
 561 __ASM_VTABLE(bad_alloc,
 562         VTABLE_ADD_FUNC(exception_vector_dtor)
 563         VTABLE_ADD_FUNC(exception_what));
 564 #endif
 565 __ASM_VTABLE(bad_typeid,
 566         VTABLE_ADD_FUNC(bad_typeid_vector_dtor)
 567         VTABLE_ADD_FUNC(exception_what));
 568 __ASM_VTABLE(bad_cast,
 569         VTABLE_ADD_FUNC(bad_cast_vector_dtor)
 570         VTABLE_ADD_FUNC(exception_what));
 571 __ASM_VTABLE(__non_rtti_object,
 572         VTABLE_ADD_FUNC(__non_rtti_object_vector_dtor)
 573         VTABLE_ADD_FUNC(exception_what));
 574
 575 __ASM_BLOCK_END
 576
 577 #if _MSVCR_VER >= 80
 578 DEFINE_RTTI_DATA0( exception_old, 0, ".?AVexception@@" )
 579 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@std@@" )
 580 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@std@@" )
 581 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@std@@" )
 582 DEFINE_RTTI_DATA1( bad_alloc, 0, &exception_rtti_base_descriptor, ".?AVbad_alloc@std@@" )
 583 #else
 584 DEFINE_RTTI_DATA1( bad_typeid, 0, &exception_rtti_base_descriptor, ".?AVbad_typeid@@" )
 585 DEFINE_RTTI_DATA1( bad_cast, 0, &exception_rtti_base_descriptor, ".?AVbad_cast@@" )
 586 DEFINE_RTTI_DATA2( __non_rtti_object, 0, &bad_typeid_rtti_base_descriptor, &exception_rtti_base_descriptor, ".?AV__non_rtti_object@@" )
 587 #endif
 588
 589 #if _MSVCR_VER >= 100
 590 DEFINE_CXX_EXCEPTION0( exception, exception_dtor )
 591 #endif
 592 DEFINE_CXX_DATA1( bad_typeid, &exception_cxx_type_info, bad_typeid_dtor )
 593 DEFINE_CXX_DATA1( bad_cast, &exception_cxx_type_info, bad_cast_dtor )
 594 DEFINE_CXX_DATA2( __non_rtti_object, &bad_typeid_cxx_type_info,
 595         &exception_cxx_type_info, __non_rtti_object_dtor )
 596 #if _MSVCR_VER >= 80
 597 DEFINE_CXX_DATA1( bad_alloc, &exception_cxx_type_info, bad_alloc_dtor )
 598 #endif
 599
 600 void msvcrt_init_exception(void *base)
 601 {
 602 #ifdef __x86_64__
 603     init_type_info_rtti(base);
 604     init_exception_rtti(base);
 605 #if _MSVCR_VER >= 80
 606     init_exception_old_rtti(base);
 607     init_bad_alloc_rtti(base);
 608 #endif
 609     init_bad_typeid_rtti(base);
 610     init_bad_cast_rtti(base);
 611     init___non_rtti_object_rtti(base);
 612
 613 #if _MSVCR_VER >= 100
 614     init_exception_cxx(base);
 615 #else
 616     init_exception_cxx_type_info(base);
 617 #endif
 618     init_bad_typeid_cxx(base);
 619     init_bad_cast_cxx(base);
 620     init___non_rtti_object_cxx(base);
 621 #if _MSVCR_VER >= 80
 622     init_bad_alloc_cxx(base);
 623 #endif
 624 #endif
 625 }
 626
 627 #if _MSVCR_VER >= 80
 628 void throw_bad_alloc(void)
 629 {
 630     bad_alloc e;
 631     __exception_ctor(&e, "bad allocation", &bad_alloc_vtable);
 632     _CxxThrowException(&e, &bad_alloc_exception_type);
 633 }
 634 #endif
 635
 636 #if _MSVCR_VER >= 100
 637 void throw_exception(const char* msg)
 638 {
 639     exception e;
 640     __exception_ctor(&e, msg, &exception_vtable);
 641     _CxxThrowException(&e, &exception_exception_type);
 642 }
 643 #endif
 644
 645 /******************************************************************
 646  *              ?set_terminate@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
 647  *
 648  * Install a handler to be called when terminate() is called.
 649  *
 650  * PARAMS
 651  *  func [I] Handler function to install
 652  *
 653  * RETURNS
 654  *  The previously installed handler function, if any.
 655  */
 656 terminate_function CDECL set_terminate(terminate_function func)
 657 {
 658     thread_data_t *data = msvcrt_get_thread_data();
 659     terminate_function previous = data->terminate_handler;
 660     TRACE("(%p) returning %p\n",func,previous);
 661     data->terminate_handler = func;
 662     return previous;
 663 }
 664
 665 /******************************************************************
 666  *              _get_terminate (MSVCRT.@)
 667  */
 668 terminate_function CDECL _get_terminate(void)
 669 {
 670     thread_data_t *data = msvcrt_get_thread_data();
 671     TRACE("returning %p\n", data->terminate_handler);
 672     return data->terminate_handler;
 673 }
 674
 675 /******************************************************************
 676  *              ?set_unexpected@@YAP6AXXZP6AXXZ@Z (MSVCRT.@)
 677  *
 678  * Install a handler to be called when unexpected() is called.
 679  *
 680  * PARAMS
 681  *  func [I] Handler function to install
 682  *
 683  * RETURNS
 684  *  The previously installed handler function, if any.
 685  */
 686 unexpected_function CDECL set_unexpected(unexpected_function func)
 687 {
 688     thread_data_t *data = msvcrt_get_thread_data();
 689     unexpected_function previous = data->unexpected_handler;
 690     TRACE("(%p) returning %p\n",func,previous);
 691     data->unexpected_handler = func;
 692     return previous;
 693 }
 694
 695 /******************************************************************
 696  *              _get_unexpected (MSVCRT.@)
 697  */
 698 unexpected_function CDECL _get_unexpected(void)
 699 {
 700     thread_data_t *data = msvcrt_get_thread_data();
 701     TRACE("returning %p\n", data->unexpected_handler);
 702     return data->unexpected_handler;
 703 }
 704
 705 /******************************************************************
 706  *              ?_set_se_translator@@YAP6AXIPAU_EXCEPTION_POINTERS@@@ZP6AXI0@Z@Z  (MSVCRT.@)
 707  */
 708 _se_translator_function CDECL _set_se_translator(_se_translator_function func)
 709 {
 710     thread_data_t *data = msvcrt_get_thread_data();
 711     _se_translator_function previous = data->se_translator;
 712     TRACE("(%p) returning %p\n",func,previous);
 713     data->se_translator = func;
 714     return previous;
 715 }
 716
 717 /******************************************************************
 718  *              ?terminate@@YAXXZ (MSVCRT.@)
 719  *
 720  * Default handler for an unhandled exception.
 721  *
 722  * PARAMS
 723  *  None.
 724  *
 725  * RETURNS
 726  *  This function does not return. Either control resumes from any
 727  *  handler installed by calling set_terminate(), or (by default) abort()
 728  *  is called.
 729  */
 730 void CDECL terminate(void)
 731 {
 732     thread_data_t *data = msvcrt_get_thread_data();
 733     if (data->terminate_handler) data->terminate_handler();
 734     abort();
 735 }
 736
 737 /******************************************************************
 738  *              ?unexpected@@YAXXZ (MSVCRT.@)
 739  */
 740 void CDECL unexpected(void)
 741 {
 742     thread_data_t *data = msvcrt_get_thread_data();
 743     if (data->unexpected_handler) data->unexpected_handler();
 744     terminate();
 745 }
 746
 747
 748 /******************************************************************
 749  *              __RTtypeid (MSVCRT.@)
 750  *
 751  * Retrieve the Run Time Type Information (RTTI) for a C++ object.
 752  *
 753  * PARAMS
 754  *  cppobj [I] C++ object to get type information for.
 755  *
 756  * RETURNS
 757  *  Success: A type_info object describing cppobj.
 758  *  Failure: If the object to be cast has no RTTI, a __non_rtti_object
 759  *           exception is thrown. If cppobj is NULL, a bad_typeid exception
 760  *           is thrown. In either case, this function does not return.
 761  *
 762  * NOTES
 763  *  This function is usually called by compiler generated code as a result
 764  *  of using one of the C++ dynamic cast statements.
 765  */
 766 #ifndef __x86_64__
 767 const type_info* CDECL __RTtypeid(void *cppobj)
 768 {
 769     const type_info *ret;
 770
 771     if (!cppobj)
 772     {
 773         bad_typeid e;
 774         bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
 775         _CxxThrowException( &e, &bad_typeid_exception_type );
 776     }
 777
 778     __TRY
 779     {
 780         const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
 781         ret = obj_locator->type_descriptor;
 782     }
 783     __EXCEPT_PAGE_FAULT
 784     {
 785         __non_rtti_object e;
 786         __non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
 787         _CxxThrowException( &e, &__non_rtti_object_exception_type );
 788     }
 789     __ENDTRY
 790     return ret;
 791 }
 792
 793 #else
 794
 795 const type_info* CDECL __RTtypeid(void *cppobj)
 796 {
 797     const type_info *ret;
 798
 799     if (!cppobj)
 800     {
 801         bad_typeid e;
 802         bad_typeid_ctor( &e, "Attempted a typeid of NULL pointer!" );
 803         _CxxThrowException( &e, &bad_typeid_exception_type );
 804     }
 805
 806     __TRY
 807     {
 808         const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
 809         char *base;
 810
 811         if(obj_locator->signature == 0)
 812             base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
 813         else
 814             base = (char*)obj_locator - obj_locator->object_locator;
 815
 816         ret = (type_info*)(base + obj_locator->type_descriptor);
 817     }
 818     __EXCEPT_PAGE_FAULT
 819     {
 820         __non_rtti_object e;
 821         __non_rtti_object_ctor( &e, "Bad read pointer - no RTTI data!" );
 822         _CxxThrowException( &e, &__non_rtti_object_exception_type );
 823     }
 824     __ENDTRY
 825     return ret;
 826 }
 827 #endif
 828
 829 /******************************************************************
 830  *              __RTDynamicCast (MSVCRT.@)
 831  *
 832  * Dynamically cast a C++ object to one of its base classes.
 833  *
 834  * PARAMS
 835  *  cppobj   [I] Any C++ object to cast
 836  *  unknown  [I] Reserved, set to 0
 837  *  src      [I] type_info object describing cppobj
 838  *  dst      [I] type_info object describing the base class to cast to
 839  *  do_throw [I] TRUE = throw an exception if the cast fails, FALSE = don't
 840  *
 841  * RETURNS
 842  *  Success: The address of cppobj, cast to the object described by dst.
 843  *  Failure: NULL, If the object to be cast has no RTTI, or dst is not a
 844  *           valid cast for cppobj. If do_throw is TRUE, a bad_cast exception
 845  *           is thrown and this function does not return.
 846  *
 847  * NOTES
 848  *  This function is usually called by compiler generated code as a result
 849  *  of using one of the C++ dynamic cast statements.
 850  */
 851 #ifndef __x86_64__
 852 void* CDECL __RTDynamicCast(void *cppobj, int unknown,
 853                                    type_info *src, type_info *dst,
 854                                    int do_throw)
 855 {
 856     void *ret;
 857
 858     if (!cppobj) return NULL;
 859
 860     TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
 861           cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
 862
 863     /* To cast an object at runtime:
 864      * 1.Find out the true type of the object from the typeinfo at vtable[-1]
 865      * 2.Search for the destination type in the class hierarchy
 866      * 3.If destination type is found, return base object address + dest offset
 867      *   Otherwise, fail the cast
 868      *
 869      * FIXME: the unknown parameter doesn't seem to be used for anything
 870      */
 871     __TRY
 872     {
 873         int i;
 874         const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
 875         const rtti_object_hierarchy *obj_bases = obj_locator->type_hierarchy;
 876         const rtti_base_descriptor * const* base_desc = obj_bases->base_classes->bases;
 877
 878         if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
 879
 880         ret = NULL;
 881         for (i = 0; i < obj_bases->array_len; i++)
 882         {
 883             const type_info *typ = base_desc[i]->type_descriptor;
 884
 885             if (!strcmp(typ->mangled, dst->mangled))
 886             {
 887                 /* compute the correct this pointer for that base class */
 888                 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
 889                 ret = get_this_pointer( &base_desc[i]->offsets, this_ptr );
 890                 break;
 891             }
 892         }
 893         /* VC++ sets do_throw to 1 when the result of a dynamic_cast is assigned
 894          * to a reference, since references cannot be NULL.
 895          */
 896         if (!ret && do_throw)
 897         {
 898             const char *msg = "Bad dynamic_cast!";
 899             bad_cast e;
 900             bad_cast_ctor( &e, &msg );
 901             _CxxThrowException( &e, &bad_cast_exception_type );
 902         }
 903     }
 904     __EXCEPT_PAGE_FAULT
 905     {
 906         __non_rtti_object e;
 907         __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
 908         _CxxThrowException( &e, &__non_rtti_object_exception_type );
 909     }
 910     __ENDTRY
 911     return ret;
 912 }
 913
 914 #else
 915
 916 void* CDECL __RTDynamicCast(void *cppobj, int unknown,
 917         type_info *src, type_info *dst,
 918         int do_throw)
 919 {
 920     void *ret;
 921
 922     if (!cppobj) return NULL;
 923
 924     TRACE("obj: %p unknown: %d src: %p %s dst: %p %s do_throw: %d)\n",
 925             cppobj, unknown, src, dbgstr_type_info(src), dst, dbgstr_type_info(dst), do_throw);
 926
 927     __TRY
 928     {
 929         int i;
 930         const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
 931         const rtti_object_hierarchy *obj_bases;
 932         const rtti_base_array *base_array;
 933         char *base;
 934
 935         if (TRACE_ON(msvcrt)) dump_obj_locator(obj_locator);
 936
 937         if(obj_locator->signature == 0)
 938             base = RtlPcToFileHeader((void*)obj_locator, (void**)&base);
 939         else
 940             base = (char*)obj_locator - obj_locator->object_locator;
 941
 942         obj_bases = (const rtti_object_hierarchy*)(base + obj_locator->type_hierarchy);
 943         base_array = (const rtti_base_array*)(base + obj_bases->base_classes);
 944
 945         ret = NULL;
 946         for (i = 0; i < obj_bases->array_len; i++)
 947         {
 948             const rtti_base_descriptor *base_desc = (const rtti_base_descriptor*)(base + base_array->bases[i]);
 949             const type_info *typ = (const type_info*)(base + base_desc->type_descriptor);
 950
 951             if (!strcmp(typ->mangled, dst->mangled))
 952             {
 953                 void *this_ptr = (char *)cppobj - obj_locator->base_class_offset;
 954                 ret = get_this_pointer( &base_desc->offsets, this_ptr );
 955                 break;
 956             }
 957         }
 958         if (!ret && do_throw)
 959         {
 960             const char *msg = "Bad dynamic_cast!";
 961             bad_cast e;
 962             bad_cast_ctor( &e, &msg );
 963             _CxxThrowException( &e, &bad_cast_exception_type );
 964         }
 965     }
 966     __EXCEPT_PAGE_FAULT
 967     {
 968         __non_rtti_object e;
 969         __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
 970         _CxxThrowException( &e, &__non_rtti_object_exception_type );
 971     }
 972     __ENDTRY
 973     return ret;
 974 }
 975 #endif
 976
 977
 978 /******************************************************************
 979  *              __RTCastToVoid (MSVCRT.@)
 980  *
 981  * Dynamically cast a C++ object to a void*.
 982  *
 983  * PARAMS
 984  *  cppobj [I] The C++ object to cast
 985  *
 986  * RETURNS
 987  *  Success: The base address of the object as a void*.
 988  *  Failure: NULL, if cppobj is NULL or has no RTTI.
 989  *
 990  * NOTES
 991  *  This function is usually called by compiler generated code as a result
 992  *  of using one of the C++ dynamic cast statements.
 993  */
 994 void* CDECL __RTCastToVoid(void *cppobj)
 995 {
 996     void *ret;
 997
 998     if (!cppobj) return NULL;
 999
1000     __TRY
1001     {
1002         const rtti_object_locator *obj_locator = get_obj_locator( cppobj );
1003         ret = (char *)cppobj - obj_locator->base_class_offset;
1004     }
1005     __EXCEPT_PAGE_FAULT
1006     {
1007         __non_rtti_object e;
1008         __non_rtti_object_ctor( &e, "Access violation - no RTTI data!" );
1009         _CxxThrowException( &e, &__non_rtti_object_exception_type );
1010     }
1011     __ENDTRY
1012     return ret;
1013 }
1014
1015
1016 /*********************************************************************
1017  *              _CxxThrowException (MSVCRT.@)
1018  */
1019 #ifndef __x86_64__
1020 void WINAPI _CxxThrowException( void *object, const cxx_exception_type *type )
1021 {
1022     ULONG_PTR args[3];
1023
1024     args[0] = CXX_FRAME_MAGIC_VC6;
1025     args[1] = (ULONG_PTR)object;
1026     args[2] = (ULONG_PTR)type;
1027     RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 3, args );
1028 }
1029 #else
1030 void WINAPI _CxxThrowException( void *object, const cxx_exception_type *type )
1031 {
1032     ULONG_PTR args[4];
1033
1034     args[0] = CXX_FRAME_MAGIC_VC6;
1035     args[1] = (ULONG_PTR)object;
1036     args[2] = (ULONG_PTR)type;
1037     RtlPcToFileHeader( (void*)type, (void**)&args[3]);
1038     RaiseException( CXX_EXCEPTION, EH_NONCONTINUABLE, 4, args );
1039 }
1040 #endif
1041
1042 #if _MSVCR_VER >= 80
1043
1044 /*********************************************************************
1045  * ?_is_exception_typeof@@YAHABVtype_info@@PAU_EXCEPTION_POINTERS@@@Z
1046  * ?_is_exception_typeof@@YAHAEBVtype_info@@PEAU_EXCEPTION_POINTERS@@@Z
1047  */
1048 #ifndef __x86_64__
1049 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1050 {
1051     int ret = -1;
1052
1053     TRACE("(%p %p)\n", ti, ep);
1054
1055     __TRY
1056     {
1057         EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1058
1059         if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==3 &&
1060                 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1061                  rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1062                  rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1063         {
1064             const cxx_type_info_table *tit = ((cxx_exception_type*)rec->ExceptionInformation[2])->type_info_table;
1065             int i;
1066
1067             for (i=0; i<tit->count; i++) {
1068                 if (ti==tit->info[i]->type_info || !strcmp(ti->mangled, tit->info[i]->type_info->mangled))
1069                 {
1070                     ret = 1;
1071                     break;
1072                 }
1073             }
1074
1075             if (i == tit->count)
1076                 ret = 0;
1077         }
1078     }
1079     __EXCEPT_PAGE_FAULT
1080     __ENDTRY
1081
1082     if(ret == -1)
1083         terminate();
1084     return ret;
1085 }
1086 #else
1087 int __cdecl _is_exception_typeof(const type_info *ti, EXCEPTION_POINTERS *ep)
1088 {
1089     int ret = -1;
1090
1091     TRACE("(%p %p)\n", ti, ep);
1092
1093     __TRY
1094     {
1095         EXCEPTION_RECORD *rec = ep->ExceptionRecord;
1096
1097         if (rec->ExceptionCode==CXX_EXCEPTION && rec->NumberParameters==4 &&
1098                 (rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC6 ||
1099                  rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC7 ||
1100                  rec->ExceptionInformation[0]==CXX_FRAME_MAGIC_VC8))
1101         {
1102             const cxx_exception_type *et = (cxx_exception_type*)rec->ExceptionInformation[2];
1103             const cxx_type_info_table *tit = (const cxx_type_info_table*)(rec->ExceptionInformation[3]+et->type_info_table);
1104             int i;
1105
1106             for (i=0; i<tit->count; i++) {
1107                 const cxx_type_info *cti = (const cxx_type_info*)(rec->ExceptionInformation[3]+tit->info[i]);
1108                 const type_info *except_ti = (const type_info*)(rec->ExceptionInformation[3]+cti->type_info);
1109                 if (ti==except_ti || !strcmp(ti->mangled, except_ti->mangled))
1110                 {
1111                     ret = 1;
1112                     break;
1113                 }
1114             }
1115
1116             if (i == tit->count)
1117                 ret = 0;
1118         }
1119     }
1120     __EXCEPT_PAGE_FAULT
1121     __ENDTRY
1122
1123     if(ret == -1)
1124         terminate();
1125     return ret;
1126 }
1127 #endif
1128
1129 /*********************************************************************
1130  * __clean_type_info_names_internal (MSVCR80.@)
1131  */
1132 void CDECL __clean_type_info_names_internal(void *p)
1133 {
1134     FIXME("(%p) stub\n", p);
1135 }
1136
1137 /*********************************************************************
1138  * ?_name_internal_method@type_info@@QBEPBDPAU__type_info_node@@@Z (MSVCR100.@)
1139  */
1140 DEFINE_THISCALL_WRAPPER(type_info_name_internal_method,8)
1141 const char * __thiscall type_info_name_internal_method(type_info * _this, struct __type_info_node *node)
1142 {
1143     static int once;
1144     if (node && !once++) FIXME("type_info_node parameter ignored\n");
1145
1146     return type_info_name(_this);
1147 }
1148
1149 void* __cdecl __AdjustPointer(void *obj, const this_ptr_offsets *off)
1150 {
1151     return get_this_pointer(off, obj);
1152 }
1153
1154 #endif
1155
1156 #if _MSVCR_VER >= 140
1157
1158 typedef struct
1159 {
1160     char *name;
1161     char mangled[1];
1162 } type_info140;
1163
1164 typedef struct
1165 {
1166     SLIST_ENTRY entry;
1167     char name[1];
1168 } type_info_entry;
1169
1170 static void* CDECL type_info_entry_malloc(size_t size)
1171 {
1172     type_info_entry *ret = malloc(FIELD_OFFSET(type_info_entry, name) + size);
1173     return ret->name;
1174 }
1175
1176 static void CDECL type_info_entry_free(void *ptr)
1177 {
1178     ptr = (char*)ptr - FIELD_OFFSET(type_info_entry, name);
1179     free(ptr);
1180 }
1181
1182 /******************************************************************
1183  *              __std_type_info_compare (UCRTBASE.@)
1184  */
1185 int CDECL __std_type_info_compare(const type_info140 *l, const type_info140 *r)
1186 {
1187     int ret;
1188
1189     if (l == r) ret = 0;
1190     else ret = strcmp(l->mangled + 1, r->mangled + 1);
1191     TRACE("(%p %p) returning %d\n", l, r, ret);
1192     return ret;
1193 }
1194
1195 /******************************************************************
1196  *              __std_type_info_name (UCRTBASE.@)
1197  */
1198 const char* CDECL __std_type_info_name(type_info140 *ti, SLIST_HEADER *header)
1199 {
1200       if (!ti->name)
1201       {
1202           char* name = __unDName(0, ti->mangled + 1, 0,
1203                   type_info_entry_malloc, type_info_entry_free, UNDNAME_NO_ARGUMENTS | UNDNAME_32_BIT_DECODE);
1204           if (name)
1205           {
1206               unsigned int len = strlen(name);
1207
1208               while (len && name[--len] == ' ')
1209                   name[len] = '\0';
1210
1211               if (InterlockedCompareExchangePointer((void**)&ti->name, name, NULL))
1212               {
1213                   type_info_entry_free(name);
1214               }
1215               else
1216               {
1217                   type_info_entry *entry = (type_info_entry*)(name-FIELD_OFFSET(type_info_entry, name));
1218                   InterlockedPushEntrySList(header, &entry->entry);
1219               }
1220           }
1221       }
1222       TRACE("(%p) returning %s\n", ti, ti->name);
1223       return ti->name;
1224 }
1225
1226 /******************************************************************
1227  *              __std_type_info_destroy_list  (UCRTBASE.@)
1228  */
1229 void CDECL __std_type_info_destroy_list(SLIST_HEADER *header)
1230 {
1231     SLIST_ENTRY *cur, *next;
1232
1233     TRACE("(%p)\n", header);
1234
1235     for(cur = InterlockedFlushSList(header); cur; cur = next)
1236     {
1237         next = cur->Next;
1238         free(cur);
1239     }
1240 }
1241
1242 /******************************************************************
1243  *              __std_type_info_hash (UCRTBASE.@)
1244  */
1245 size_t CDECL __std_type_info_hash(const type_info140 *ti)
1246 {
1247     size_t hash, fnv_prime;
1248     const char *p;
1249
1250 #ifdef _WIN64
1251     hash = 0xcbf29ce484222325;
1252     fnv_prime = 0x100000001b3;
1253 #else
1254     hash = 0x811c9dc5;
1255     fnv_prime = 0x1000193;
1256 #endif
1257
1258     TRACE("(%p)->%s\n", ti, ti->mangled);
1259
1260     for(p = ti->mangled+1; *p; p++) {
1261         hash ^= *p;
1262         hash *= fnv_prime;
1263     }
1264
1265 #ifdef _WIN64
1266     hash ^= hash >> 32;
1267 #endif
1268
1269     return hash;
1270 }
1271
1272 #endif /* _MSVCR_VER >= 140 */