dlls/msvcp90/misc.c

   1 /*
   2  * Copyright 2010 Piotr Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22 #include <limits.h>
  23
  24 #include "msvcp90.h"
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winternl.h"
  29 #include "wine/debug.h"
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcp);
  31
  32 struct __Container_proxy;
  33
  34 typedef struct {
  35     struct __Container_proxy *proxy;
  36 } _Container_base12;
  37
  38 typedef struct __Iterator_base12 {
  39     struct __Container_proxy *proxy;
  40     struct __Iterator_base12 *next;
  41 } _Iterator_base12;
  42
  43 typedef struct __Container_proxy {
  44     const _Container_base12 *cont;
  45     _Iterator_base12 *head;
  46 } _Container_proxy;
  47
  48 /* ??0_Mutex@std@@QAE@XZ */
  49 /* ??0_Mutex@std@@QEAA@XZ */
  50 DEFINE_THISCALL_WRAPPER(mutex_ctor, 4)
  51 mutex* __thiscall mutex_ctor(mutex *this)
  52 {
  53     CRITICAL_SECTION *cs = MSVCRT_operator_new(sizeof(*cs));
  54     if(!cs) {
  55         ERR("Out of memory\n");
  56         throw_exception(EXCEPTION_BAD_ALLOC, NULL);
  57     }
  58
  59     InitializeCriticalSection(cs);
  60     cs->DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": _Mutex critical section");
  61     this->mutex = cs;
  62     return this;
  63 }
  64
  65 /* ??1_Mutex@std@@QAE@XZ */
  66 /* ??1_Mutex@std@@QEAA@XZ */
  67 DEFINE_THISCALL_WRAPPER(mutex_dtor, 4)
  68 void __thiscall mutex_dtor(mutex *this)
  69 {
  70     ((CRITICAL_SECTION*)this->mutex)->DebugInfo->Spare[0] = 0;
  71     DeleteCriticalSection(this->mutex);
  72     MSVCRT_operator_delete(this->mutex);
  73 }
  74
  75 /* ?_Lock@_Mutex@std@@QAEXXZ */
  76 /* ?_Lock@_Mutex@std@@QEAAXXZ */
  77 DEFINE_THISCALL_WRAPPER(mutex_lock, 4)
  78 void __thiscall mutex_lock(mutex *this)
  79 {
  80     EnterCriticalSection(this->mutex);
  81 }
  82
  83 /* ?_Unlock@_Mutex@std@@QAEXXZ */
  84 /* ?_Unlock@_Mutex@std@@QEAAXXZ */
  85 DEFINE_THISCALL_WRAPPER(mutex_unlock, 4)
  86 void __thiscall mutex_unlock(mutex *this)
  87 {
  88     LeaveCriticalSection(this->mutex);
  89 }
  90
  91 /* ?_Mutex_Lock@_Mutex@std@@CAXPAV12@@Z */
  92 /* ?_Mutex_Lock@_Mutex@std@@CAXPEAV12@@Z */
  93 void CDECL mutex_mutex_lock(mutex *m)
  94 {
  95     mutex_lock(m);
  96 }
  97
  98 /* ?_Mutex_Unlock@_Mutex@std@@CAXPAV12@@Z */
  99 /* ?_Mutex_Unlock@_Mutex@std@@CAXPEAV12@@Z */
 100 void CDECL mutex_mutex_unlock(mutex *m)
 101 {
 102     mutex_unlock(m);
 103 }
 104
 105 /* ?_Mutex_ctor@_Mutex@std@@CAXPAV12@@Z */
 106 /* ?_Mutex_ctor@_Mutex@std@@CAXPEAV12@@Z */
 107 void CDECL mutex_mutex_ctor(mutex *m)
 108 {
 109     mutex_ctor(m);
 110 }
 111
 112 /* ?_Mutex_dtor@_Mutex@std@@CAXPAV12@@Z */
 113 /* ?_Mutex_dtor@_Mutex@std@@CAXPEAV12@@Z */
 114 void CDECL mutex_mutex_dtor(mutex *m)
 115 {
 116     mutex_dtor(m);
 117 }
 118
 119 static CRITICAL_SECTION lockit_cs[_MAX_LOCK];
 120
 121 #if _MSVCP_VER >= 70
 122 static inline int get_locktype( _Lockit *lockit ) { return lockit->locktype; }
 123 static inline void set_locktype( _Lockit *lockit, int type ) { lockit->locktype = type; }
 124 #else
 125 static inline int get_locktype( _Lockit *lockit ) { return 0; }
 126 static inline void set_locktype( _Lockit *lockit, int type ) { }
 127 #endif
 128
 129 /* ?_Lockit_ctor@_Lockit@std@@SAXH@Z */
 130 void __cdecl _Lockit_init(int locktype) {
 131     InitializeCriticalSection(&lockit_cs[locktype]);
 132     lockit_cs[locktype].DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": _Lockit critical section");
 133 }
 134
 135 /* ?_Lockit_dtor@_Lockit@std@@SAXH@Z */
 136 void __cdecl _Lockit_free(int locktype)
 137 {
 138     lockit_cs[locktype].DebugInfo->Spare[0] = 0;
 139     DeleteCriticalSection(&lockit_cs[locktype]);
 140 }
 141
 142 void init_lockit(void) {
 143     int i;
 144
 145     for(i=0; i<_MAX_LOCK; i++)
 146         _Lockit_init(i);
 147 }
 148
 149 void free_lockit(void) {
 150     int i;
 151
 152     for(i=0; i<_MAX_LOCK; i++)
 153         _Lockit_free(i);
 154 }
 155
 156 /* ?_Lockit_ctor@_Lockit@std@@CAXPAV12@H@Z */
 157 /* ?_Lockit_ctor@_Lockit@std@@CAXPEAV12@H@Z */
 158 void __cdecl _Lockit__Lockit_ctor_locktype(_Lockit *lockit, int locktype)
 159 {
 160     set_locktype( lockit, locktype );
 161     EnterCriticalSection(&lockit_cs[locktype]);
 162 }
 163
 164 /* ?_Lockit_ctor@_Lockit@std@@CAXPAV12@@Z */
 165 /* ?_Lockit_ctor@_Lockit@std@@CAXPEAV12@@Z */
 166 void __cdecl _Lockit__Lockit_ctor(_Lockit *lockit)
 167 {
 168     _Lockit__Lockit_ctor_locktype(lockit, 0);
 169 }
 170
 171 /* ??0_Lockit@std@@QAE@H@Z */
 172 /* ??0_Lockit@std@@QEAA@H@Z */
 173 DEFINE_THISCALL_WRAPPER(_Lockit_ctor_locktype, 8)
 174 _Lockit* __thiscall _Lockit_ctor_locktype(_Lockit *this, int locktype)
 175 {
 176     _Lockit__Lockit_ctor_locktype(this, locktype);
 177     return this;
 178 }
 179
 180 /* ??0_Lockit@std@@QAE@XZ */
 181 /* ??0_Lockit@std@@QEAA@XZ */
 182 DEFINE_THISCALL_WRAPPER(_Lockit_ctor, 4)
 183 _Lockit* __thiscall _Lockit_ctor(_Lockit *this)
 184 {
 185     _Lockit__Lockit_ctor_locktype(this, 0);
 186     return this;
 187 }
 188
 189 /* ?_Lockit_dtor@_Lockit@std@@CAXPAV12@@Z */
 190 /* ?_Lockit_dtor@_Lockit@std@@CAXPEAV12@@Z */
 191 void __cdecl _Lockit__Lockit_dtor(_Lockit *lockit)
 192 {
 193     LeaveCriticalSection(&lockit_cs[get_locktype( lockit )]);
 194 }
 195
 196 /* ??1_Lockit@std@@QAE@XZ */
 197 /* ??1_Lockit@std@@QEAA@XZ */
 198 DEFINE_THISCALL_WRAPPER(_Lockit_dtor, 4)
 199 void __thiscall _Lockit_dtor(_Lockit *this)
 200 {
 201     _Lockit__Lockit_dtor(this);
 202 }
 203
 204 /* wctype */
 205 unsigned short __cdecl wctype(const char *property)
 206 {
 207     static const struct {
 208         const char *name;
 209         unsigned short mask;
 210     } properties[] = {
 211         { "alnum", _DIGIT|_ALPHA },
 212         { "alpha", _ALPHA },
 213         { "cntrl", _CONTROL },
 214         { "digit", _DIGIT },
 215         { "graph", _DIGIT|_PUNCT|_ALPHA },
 216         { "lower", _LOWER },
 217         { "print", _DIGIT|_PUNCT|_BLANK|_ALPHA },
 218         { "punct", _PUNCT },
 219         { "space", _SPACE },
 220         { "upper", _UPPER },
 221         { "xdigit", _HEX }
 222     };
 223     unsigned int i;
 224
 225     for(i=0; i<sizeof(properties)/sizeof(properties[0]); i++)
 226         if(!strcmp(property, properties[i].name))
 227             return properties[i].mask;
 228
 229     return 0;
 230 }
 231
 232 typedef void (__cdecl *MSVCP_new_handler_func)(void);
 233 static MSVCP_new_handler_func MSVCP_new_handler;
 234 static int __cdecl new_handler_wrapper(MSVCP_size_t unused)
 235 {
 236     MSVCP_new_handler();
 237     return 1;
 238 }
 239
 240 /* ?set_new_handler@std@@YAP6AXXZP6AXXZ@Z */
 241 MSVCP_new_handler_func __cdecl set_new_handler(MSVCP_new_handler_func new_handler)
 242 {
 243     MSVCP_new_handler_func old_handler = MSVCP_new_handler;
 244
 245     TRACE("%p\n", new_handler);
 246
 247     MSVCP_new_handler = new_handler;
 248     MSVCRT_set_new_handler(new_handler ? new_handler_wrapper : NULL);
 249     return old_handler;
 250 }
 251
 252 /* ?set_new_handler@std@@YAP6AXXZH@Z */
 253 MSVCP_new_handler_func __cdecl set_new_handler_reset(int unused)
 254 {
 255     return set_new_handler(NULL);
 256 }
 257
 258 /* _Container_base0 is used by apps compiled without iterator checking
 259  * (i.e. with _ITERATOR_DEBUG_LEVEL=0 ).
 260  * It provides empty versions of methods used by visual c++'s stl's
 261  * iterator checking.
 262  * msvcr100 has to provide them in case apps are compiled with /Od
 263  * or the optimizer fails to inline those (empty) calls.
 264  */
 265
 266 /* ?_Orphan_all@_Container_base0@std@@QAEXXZ */
 267 /* ?_Orphan_all@_Container_base0@std@@QEAAXXZ */
 268 DEFINE_THISCALL_WRAPPER(Container_base0_Orphan_all, 4)
 269 void __thiscall Container_base0_Orphan_all(void *this)
 270 {
 271 }
 272
 273 /* ?_Swap_all@_Container_base0@std@@QAEXAAU12@@Z */
 274 /* ?_Swap_all@_Container_base0@std@@QEAAXAEAU12@@Z */
 275 DEFINE_THISCALL_WRAPPER(Container_base0_Swap_all, 8)
 276 void __thiscall Container_base0_Swap_all(void *this, void *that)
 277 {
 278 }
 279
 280 /* ??4_Container_base0@std@@QAEAAU01@ABU01@@Z */
 281 /* ??4_Container_base0@std@@QEAAAEAU01@AEBU01@@Z */
 282 DEFINE_THISCALL_WRAPPER(Container_base0_op_assign, 8)
 283 void* __thiscall Container_base0_op_assign(void *this, const void *that)
 284 {
 285     return this;
 286 }
 287
 288 /* ??0_Container_base12@std@@QAE@ABU01@@Z */
 289 /* ??0_Container_base12@std@@QEAA@AEBU01@@Z */
 290 DEFINE_THISCALL_WRAPPER(_Container_base12_copy_ctor, 8)
 291 _Container_base12* __thiscall _Container_base12_copy_ctor(
 292         _Container_base12 *this, _Container_base12 *that)
 293 {
 294     this->proxy = NULL;
 295     return this;
 296 }
 297
 298 /* ??0_Container_base12@std@@QAE@XZ */
 299 /* ??0_Container_base12@std@@QEAA@XZ */
 300 DEFINE_THISCALL_WRAPPER(_Container_base12_ctor, 4)
 301 _Container_base12* __thiscall _Container_base12_ctor(_Container_base12 *this)
 302 {
 303     this->proxy = NULL;
 304     return this;
 305 }
 306
 307 /* ??1_Container_base12@std@@QAE@XZ */
 308 /* ??1_Container_base12@std@@QEAA@XZ */
 309 DEFINE_THISCALL_WRAPPER(_Container_base12_dtor, 4)
 310 void __thiscall _Container_base12_dtor(_Container_base12 *this)
 311 {
 312 }
 313
 314 /* ??4_Container_base12@std@@QAEAAU01@ABU01@@Z */
 315 /* ??4_Container_base12@std@@QEAAAEAU01@AEBU01@@ */
 316 DEFINE_THISCALL_WRAPPER(_Container_base12_op_assign, 8)
 317 _Container_base12* __thiscall _Container_base12_op_assign(
 318         _Container_base12 *this, const _Container_base12 *that)
 319 {
 320     return this;
 321 }
 322
 323 /* ?_Getpfirst@_Container_base12@std@@QBEPAPAU_Iterator_base12@2@XZ */
 324 /* ?_Getpfirst@_Container_base12@std@@QEBAPEAPEAU_Iterator_base12@2@XZ */
 325 DEFINE_THISCALL_WRAPPER(_Container_base12__Getpfirst, 4)
 326 _Iterator_base12** __thiscall _Container_base12__Getpfirst(_Container_base12 *this)
 327 {
 328     return this->proxy ? &this->proxy->head : NULL;
 329 }
 330
 331 /* ?_Orphan_all@_Container_base12@std@@QAEXXZ */
 332 /* ?_Orphan_all@_Container_base12@std@@QEAAXXZ */
 333 DEFINE_THISCALL_WRAPPER(_Container_base12__Orphan_all, 4)
 334 void __thiscall _Container_base12__Orphan_all(_Container_base12 *this)
 335 {
 336 }
 337
 338 /* ?_Swap_all@_Container_base12@std@@QAEXAAU12@@Z */
 339 /* ?_Swap_all@_Container_base12@std@@QEAAXAEAU12@@Z */
 340 DEFINE_THISCALL_WRAPPER(_Container_base12__Swap_all, 8)
 341 void __thiscall _Container_base12__Swap_all(
 342         _Container_base12 *this, _Container_base12 *that)
 343 {
 344     _Container_proxy *tmp;
 345
 346     tmp = this->proxy;
 347     this->proxy = that->proxy;
 348     that->proxy = tmp;
 349
 350     if(this->proxy)
 351         this->proxy->cont = this;
 352     if(that->proxy)
 353         that->proxy->cont = that;
 354 }
 355
 356 #if _MSVCP_VER >= 110
 357
 358 #define SECSPERDAY 86400
 359 /* 1601 to 1970 is 369 years plus 89 leap days */
 360 #define SECS_1601_TO_1970 ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
 361 #define TICKSPERSEC 10000000
 362 #define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKSPERSEC)
 363 #define NANOSEC_PER_MILLISEC 1000000
 364 #define MILLISEC_PER_SEC 1000
 365 #define NANOSEC_PER_SEC (NANOSEC_PER_MILLISEC * MILLISEC_PER_SEC)
 366
 367 typedef int MSVCRT_long;
 368
 369 /* xtime */
 370 typedef struct {
 371     __time64_t sec;
 372     MSVCRT_long nsec;
 373 } xtime;
 374
 375 /* _Xtime_get_ticks */
 376 LONGLONG __cdecl _Xtime_get_ticks(void)
 377 {
 378     FILETIME ft;
 379
 380     TRACE("\n");
 381
 382     GetSystemTimeAsFileTime(&ft);
 383     return ((LONGLONG)ft.dwHighDateTime<<32) + ft.dwLowDateTime - TICKS_1601_TO_1970;
 384 }
 385
 386 /* _xtime_get */
 387 int __cdecl xtime_get(xtime* t, int unknown)
 388 {
 389     LONGLONG ticks;
 390
 391     TRACE("(%p)\n", t);
 392
 393     if(unknown != 1)
 394         return 0;
 395
 396     ticks = _Xtime_get_ticks();
 397     t->sec = ticks / TICKSPERSEC;
 398     t->nsec = ticks % TICKSPERSEC * 100;
 399     return 1;
 400 }
 401
 402 /* _Xtime_diff_to_millis2 */
 403 MSVCRT_long __cdecl _Xtime_diff_to_millis2(const xtime *t1, const xtime *t2)
 404 {
 405     LONGLONG diff_sec, diff_nsec;
 406
 407     TRACE("(%p, %p)\n", t1, t2);
 408
 409     diff_sec = t1->sec - t2->sec;
 410     diff_nsec = t1->nsec - t2->nsec;
 411
 412     diff_sec += diff_nsec / NANOSEC_PER_SEC;
 413     diff_nsec %= NANOSEC_PER_SEC;
 414     if (diff_nsec < 0) {
 415         diff_sec -= 1;
 416         diff_nsec += NANOSEC_PER_SEC;
 417     }
 418
 419     if (diff_sec<0 || (diff_sec==0 && diff_nsec<0))
 420         return 0;
 421     return diff_sec * MILLISEC_PER_SEC +
 422         (diff_nsec + NANOSEC_PER_MILLISEC - 1) / NANOSEC_PER_MILLISEC;
 423 }
 424
 425 /* _Xtime_diff_to_millis */
 426 MSVCRT_long __cdecl _Xtime_diff_to_millis(const xtime *t)
 427 {
 428     xtime now;
 429
 430     TRACE("%p\n", t);
 431
 432     xtime_get(&now, 1);
 433     return _Xtime_diff_to_millis2(t, &now);
 434 }
 435 #endif
 436
 437 #if _MSVCP_VER >= 90
 438 unsigned int __cdecl _Random_device(void)
 439 {
 440     unsigned int ret;
 441
 442     TRACE("\n");
 443
 444     /* TODO: throw correct exception in case of failure */
 445     if(rand_s(&ret))
 446         throw_exception(EXCEPTION, "random number generator failed\n");
 447     return ret;
 448 }
 449 #endif
 450
 451 #if _MSVCP_VER >= 110
 452 #if defined(__i386__) && !defined(__arm__)
 453
 454 extern void *call_thiscall_func;
 455 __ASM_GLOBAL_FUNC(call_thiscall_func,
 456         "popl %eax\n\t"
 457         "popl %edx\n\t"
 458         "popl %ecx\n\t"
 459         "pushl %eax\n\t"
 460         "jmp *%edx\n\t")
 461
 462 #define call_func1(func,this) ((void* (WINAPI*)(void*,void*))&call_thiscall_func)(func,this)
 463
 464 #else /* __i386__ */
 465
 466 #define call_func1(func,this) func(this)
 467
 468 #endif /* __i386__ */
 469
 470 #define MTX_MULTI_LOCK 0x100
 471 #define MTX_LOCKED 3
 472 typedef struct
 473 {
 474     DWORD flags;
 475     critical_section cs;
 476     DWORD thread_id;
 477     DWORD count;
 478 } *_Mtx_t;
 479
 480 #if _MSVCP_VER >= 140
 481 typedef _Mtx_t _Mtx_arg_t;
 482 #define MTX_T_FROM_ARG(m)   (m)
 483 #define MTX_T_TO_ARG(m)     (m)
 484 #else
 485 typedef _Mtx_t *_Mtx_arg_t;
 486 #define MTX_T_FROM_ARG(m)   (*(m))
 487 #define MTX_T_TO_ARG(m)     (&(m))
 488 #endif
 489
 490 void __cdecl _Mtx_init_in_situ(_Mtx_t mtx, int flags)
 491 {
 492     if(flags & ~MTX_MULTI_LOCK)
 493         FIXME("unknown flags ignored: %x\n", flags);
 494
 495     mtx->flags = flags;
 496     call_func1(critical_section_ctor, &mtx->cs);
 497     mtx->thread_id = -1;
 498     mtx->count = 0;
 499 }
 500
 501 int __cdecl _Mtx_init(_Mtx_t *mtx, int flags)
 502 {
 503     *mtx = MSVCRT_operator_new(sizeof(**mtx));
 504     _Mtx_init_in_situ(*mtx, flags);
 505     return 0;
 506 }
 507
 508 void __cdecl _Mtx_destroy_in_situ(_Mtx_t mtx)
 509 {
 510     call_func1(critical_section_dtor, &mtx->cs);
 511 }
 512
 513 void __cdecl _Mtx_destroy(_Mtx_arg_t mtx)
 514 {
 515     call_func1(critical_section_dtor, &MTX_T_FROM_ARG(mtx)->cs);
 516     MSVCRT_operator_delete(MTX_T_FROM_ARG(mtx));
 517 }
 518
 519 int __cdecl _Mtx_current_owns(_Mtx_arg_t mtx)
 520 {
 521     return MTX_T_FROM_ARG(mtx)->thread_id == GetCurrentThreadId();
 522 }
 523
 524 int __cdecl _Mtx_lock(_Mtx_arg_t mtx)
 525 {
 526     if(MTX_T_FROM_ARG(mtx)->thread_id != GetCurrentThreadId()) {
 527         call_func1(critical_section_lock, &MTX_T_FROM_ARG(mtx)->cs);
 528         MTX_T_FROM_ARG(mtx)->thread_id = GetCurrentThreadId();
 529     }else if(!(MTX_T_FROM_ARG(mtx)->flags & MTX_MULTI_LOCK)) {
 530         return MTX_LOCKED;
 531     }
 532
 533     MTX_T_FROM_ARG(mtx)->count++;
 534     return 0;
 535 }
 536
 537 int __cdecl _Mtx_unlock(_Mtx_arg_t mtx)
 538 {
 539     if(--MTX_T_FROM_ARG(mtx)->count)
 540         return 0;
 541
 542     MTX_T_FROM_ARG(mtx)->thread_id = -1;
 543     call_func1(critical_section_unlock, &MTX_T_FROM_ARG(mtx)->cs);
 544     return 0;
 545 }
 546
 547 int __cdecl _Mtx_trylock(_Mtx_arg_t mtx)
 548 {
 549     if(MTX_T_FROM_ARG(mtx)->thread_id != GetCurrentThreadId()) {
 550         if(!call_func1(critical_section_trylock, &MTX_T_FROM_ARG(mtx)->cs))
 551             return MTX_LOCKED;
 552         MTX_T_FROM_ARG(mtx)->thread_id = GetCurrentThreadId();
 553     }else if(!(MTX_T_FROM_ARG(mtx)->flags & MTX_MULTI_LOCK)) {
 554         return MTX_LOCKED;
 555     }
 556
 557     MTX_T_FROM_ARG(mtx)->count++;
 558     return 0;
 559 }
 560
 561 critical_section* __cdecl _Mtx_getconcrtcs(_Mtx_arg_t mtx)
 562 {
 563     return &MTX_T_FROM_ARG(mtx)->cs;
 564 }
 565
 566 static inline LONG interlocked_dec_if_nonzero( LONG *dest )
 567 {
 568     LONG val, tmp;
 569     for (val = *dest;; val = tmp)
 570     {
 571         if (!val || (tmp = InterlockedCompareExchange( dest, val - 1, val )) == val)
 572             break;
 573     }
 574     return val;
 575 }
 576
 577 #define CND_TIMEDOUT 2
 578
 579 typedef struct
 580 {
 581     CONDITION_VARIABLE cv;
 582 } *_Cnd_t;
 583
 584 #if _MSVCP_VER >= 140
 585 typedef _Cnd_t _Cnd_arg_t;
 586 #define CND_T_FROM_ARG(c)   (c)
 587 #define CND_T_TO_ARG(c)     (c)
 588 #else
 589 typedef _Cnd_t *_Cnd_arg_t;
 590 #define CND_T_FROM_ARG(c)   (*(c))
 591 #define CND_T_TO_ARG(c)     (&(c))
 592 #endif
 593
 594 static HANDLE keyed_event;
 595
 596 void __cdecl _Cnd_init_in_situ(_Cnd_t cnd)
 597 {
 598     InitializeConditionVariable(&cnd->cv);
 599
 600     if(!keyed_event) {
 601         HANDLE event;
 602
 603         NtCreateKeyedEvent(&event, GENERIC_READ|GENERIC_WRITE, NULL, 0);
 604         if(InterlockedCompareExchangePointer(&keyed_event, event, NULL) != NULL)
 605             NtClose(event);
 606     }
 607 }
 608
 609 int __cdecl _Cnd_init(_Cnd_t *cnd)
 610 {
 611     *cnd = MSVCRT_operator_new(sizeof(**cnd));
 612     _Cnd_init_in_situ(*cnd);
 613     return 0;
 614 }
 615
 616 int __cdecl _Cnd_wait(_Cnd_arg_t cnd, _Mtx_arg_t mtx)
 617 {
 618     CONDITION_VARIABLE *cv = &CND_T_FROM_ARG(cnd)->cv;
 619
 620     InterlockedExchangeAdd( (LONG *)&cv->Ptr, 1 );
 621     _Mtx_unlock(mtx);
 622
 623     NtWaitForKeyedEvent(keyed_event, &cv->Ptr, FALSE, NULL);
 624
 625     _Mtx_lock(mtx);
 626     return 0;
 627 }
 628
 629 int __cdecl _Cnd_timedwait(_Cnd_arg_t cnd, _Mtx_arg_t mtx, const xtime *xt)
 630 {
 631     CONDITION_VARIABLE *cv = &CND_T_FROM_ARG(cnd)->cv;
 632     LARGE_INTEGER timeout;
 633     NTSTATUS status;
 634
 635     InterlockedExchangeAdd( (LONG *)&cv->Ptr, 1 );
 636     _Mtx_unlock(mtx);
 637
 638     timeout.QuadPart = (ULONGLONG)(ULONG)_Xtime_diff_to_millis(xt) * -10000;
 639     status = NtWaitForKeyedEvent(keyed_event, &cv->Ptr, FALSE, &timeout);
 640     if (status)
 641     {
 642         if (!interlocked_dec_if_nonzero( (LONG *)&cv->Ptr ))
 643             status = NtWaitForKeyedEvent( keyed_event, &cv->Ptr, FALSE, NULL );
 644     }
 645
 646     _Mtx_lock(mtx);
 647     return status ? CND_TIMEDOUT : 0;
 648 }
 649
 650 int __cdecl _Cnd_broadcast(_Cnd_arg_t cnd)
 651 {
 652     CONDITION_VARIABLE *cv = &CND_T_FROM_ARG(cnd)->cv;
 653     LONG val = InterlockedExchange( (LONG *)&cv->Ptr, 0 );
 654     while (val-- > 0)
 655         NtReleaseKeyedEvent( keyed_event, &cv->Ptr, FALSE, NULL );
 656     return 0;
 657 }
 658
 659 int __cdecl _Cnd_signal(_Cnd_arg_t cnd)
 660 {
 661     CONDITION_VARIABLE *cv = &CND_T_FROM_ARG(cnd)->cv;
 662     if (interlocked_dec_if_nonzero( (LONG *)&cv->Ptr ))
 663         NtReleaseKeyedEvent( keyed_event, &cv->Ptr, FALSE, NULL );
 664     return 0;
 665 }
 666
 667 void __cdecl _Cnd_destroy_in_situ(_Cnd_t cnd)
 668 {
 669     _Cnd_broadcast(CND_T_TO_ARG(cnd));
 670 }
 671
 672 void __cdecl _Cnd_destroy(_Cnd_arg_t cnd)
 673 {
 674     if(cnd) {
 675         _Cnd_broadcast(cnd);
 676         MSVCRT_operator_delete(CND_T_FROM_ARG(cnd));
 677     }
 678 }
 679
 680 static struct {
 681     int used;
 682     int size;
 683
 684     struct _to_broadcast {
 685         DWORD thread_id;
 686         _Cnd_arg_t cnd;
 687         _Mtx_arg_t mtx;
 688         int *p;
 689     } *to_broadcast;
 690 } broadcast_at_thread_exit;
 691
 692 static CRITICAL_SECTION broadcast_at_thread_exit_cs;
 693 static CRITICAL_SECTION_DEBUG broadcast_at_thread_exit_cs_debug =
 694 {
 695         0, 0, &broadcast_at_thread_exit_cs,
 696         { &broadcast_at_thread_exit_cs_debug.ProcessLocksList, &broadcast_at_thread_exit_cs_debug.ProcessLocksList },
 697         0, 0, { (DWORD_PTR)(__FILE__ ": broadcast_at_thread_exit_cs") }
 698 };
 699 static CRITICAL_SECTION broadcast_at_thread_exit_cs = { &broadcast_at_thread_exit_cs_debug, -1, 0, 0, 0, 0 };
 700
 701 void __cdecl _Cnd_register_at_thread_exit(_Cnd_arg_t cnd, _Mtx_arg_t mtx, int *p)
 702 {
 703     struct _to_broadcast *add;
 704
 705     TRACE("(%p %p %p)\n", cnd, mtx, p);
 706
 707     EnterCriticalSection(&broadcast_at_thread_exit_cs);
 708     if(!broadcast_at_thread_exit.size) {
 709         broadcast_at_thread_exit.to_broadcast = HeapAlloc(GetProcessHeap(),
 710                 0, 8*sizeof(broadcast_at_thread_exit.to_broadcast[0]));
 711         if(!broadcast_at_thread_exit.to_broadcast) {
 712             LeaveCriticalSection(&broadcast_at_thread_exit_cs);
 713             return;
 714         }
 715         broadcast_at_thread_exit.size = 8;
 716     } else if(broadcast_at_thread_exit.size == broadcast_at_thread_exit.used) {
 717         add = HeapReAlloc(GetProcessHeap(), 0, broadcast_at_thread_exit.to_broadcast,
 718                 broadcast_at_thread_exit.size*2*sizeof(broadcast_at_thread_exit.to_broadcast[0]));
 719         if(!add) {
 720             LeaveCriticalSection(&broadcast_at_thread_exit_cs);
 721             return;
 722         }
 723         broadcast_at_thread_exit.to_broadcast = add;
 724         broadcast_at_thread_exit.size *= 2;
 725     }
 726
 727     add = broadcast_at_thread_exit.to_broadcast + broadcast_at_thread_exit.used++;
 728     add->thread_id = GetCurrentThreadId();
 729     add->cnd = cnd;
 730     add->mtx = mtx;
 731     add->p = p;
 732     LeaveCriticalSection(&broadcast_at_thread_exit_cs);
 733 }
 734
 735 void __cdecl _Cnd_unregister_at_thread_exit(_Mtx_arg_t mtx)
 736 {
 737     int i;
 738
 739     TRACE("(%p)\n", mtx);
 740
 741     EnterCriticalSection(&broadcast_at_thread_exit_cs);
 742     for(i=0; i<broadcast_at_thread_exit.used; i++) {
 743         if(broadcast_at_thread_exit.to_broadcast[i].mtx != mtx)
 744             continue;
 745
 746         memmove(broadcast_at_thread_exit.to_broadcast+i, broadcast_at_thread_exit.to_broadcast+i+1,
 747                 (broadcast_at_thread_exit.used-i-1)*sizeof(broadcast_at_thread_exit.to_broadcast[0]));
 748         broadcast_at_thread_exit.used--;
 749         i--;
 750     }
 751     LeaveCriticalSection(&broadcast_at_thread_exit_cs);
 752 }
 753
 754 void __cdecl _Cnd_do_broadcast_at_thread_exit(void)
 755 {
 756     int i, id = GetCurrentThreadId();
 757
 758     TRACE("()\n");
 759
 760     EnterCriticalSection(&broadcast_at_thread_exit_cs);
 761     for(i=0; i<broadcast_at_thread_exit.used; i++) {
 762         if(broadcast_at_thread_exit.to_broadcast[i].thread_id != id)
 763             continue;
 764
 765         _Mtx_unlock(broadcast_at_thread_exit.to_broadcast[i].mtx);
 766         _Cnd_broadcast(broadcast_at_thread_exit.to_broadcast[i].cnd);
 767         if(broadcast_at_thread_exit.to_broadcast[i].p)
 768             *broadcast_at_thread_exit.to_broadcast[i].p = 1;
 769
 770         memmove(broadcast_at_thread_exit.to_broadcast+i, broadcast_at_thread_exit.to_broadcast+i+1,
 771                 (broadcast_at_thread_exit.used-i-1)*sizeof(broadcast_at_thread_exit.to_broadcast[0]));
 772         broadcast_at_thread_exit.used--;
 773         i--;
 774     }
 775     LeaveCriticalSection(&broadcast_at_thread_exit_cs);
 776 }
 777
 778 #endif
 779
 780 #if _MSVCP_VER == 100
 781 typedef struct {
 782     const vtable_ptr *vtable;
 783 } error_category;
 784
 785 typedef struct {
 786     error_category base;
 787     const char *type;
 788 } custom_category;
 789 static custom_category iostream_category;
 790
 791 DEFINE_RTTI_DATA0(error_category, 0, ".?AVerror_category@std@@")
 792 DEFINE_RTTI_DATA1(iostream_category, 0, &error_category_rtti_base_descriptor, ".?AV_Iostream_error_category@std@@")
 793
 794 extern const vtable_ptr MSVCP_iostream_category_vtable;
 795
 796 static void iostream_category_ctor(custom_category *this)
 797 {
 798     this->base.vtable = &MSVCP_iostream_category_vtable;
 799     this->type = "iostream";
 800 }
 801
 802 DEFINE_THISCALL_WRAPPER(custom_category_vector_dtor, 8)
 803 custom_category* __thiscall custom_category_vector_dtor(custom_category *this, unsigned int flags)
 804 {
 805     TRACE("(%p %x)\n", this, flags);
 806     if(flags & 2) {
 807         /* we have an array, with the number of elements stored before the first object */
 808         INT_PTR i, *ptr = (INT_PTR *)this-1;
 809
 810         for(i=*ptr-1; i>=0; i--)
 811             MSVCRT_operator_delete(ptr);
 812     } else {
 813         if(flags & 1)
 814             MSVCRT_operator_delete(this);
 815     }
 816
 817     return this;
 818 }
 819
 820 DEFINE_THISCALL_WRAPPER(custom_category_name, 4)
 821 const char* __thiscall custom_category_name(const custom_category *this)
 822 {
 823     return this->type;
 824 }
 825
 826 DEFINE_THISCALL_WRAPPER(custom_category_message, 12)
 827 basic_string_char* __thiscall custom_category_message(const custom_category *this,
 828         basic_string_char *ret, int err)
 829 {
 830     return MSVCP_basic_string_char_ctor_cstr(ret, strerror(err));
 831 }
 832
 833 DEFINE_THISCALL_WRAPPER(custom_category_default_error_condition, 12)
 834 /*error_condition*/void* __thiscall custom_category_default_error_condition(
 835         custom_category *this, /*error_condition*/void *ret, int code)
 836 {
 837     FIXME("(%p %p %x) stub\n", this, ret, code);
 838     return NULL;
 839 }
 840
 841 DEFINE_THISCALL_WRAPPER(custom_category_equivalent, 12)
 842 MSVCP_bool __thiscall custom_category_equivalent(const custom_category *this,
 843         int code, const /*error_condition*/void *condition)
 844 {
 845     FIXME("(%p %x %p) stub\n", this, code, condition);
 846     return FALSE;
 847 }
 848
 849 DEFINE_THISCALL_WRAPPER(custom_category_equivalent_code, 12)
 850 MSVCP_bool __thiscall custom_category_equivalent_code(custom_category *this,
 851         const /*error_code*/void *code, int condition)
 852 {
 853     FIXME("(%p %p %x) stub\n", this, code, condition);
 854     return FALSE;
 855 }
 856
 857 DEFINE_THISCALL_WRAPPER(iostream_category_message, 12)
 858 basic_string_char* __thiscall iostream_category_message(const custom_category *this,
 859         basic_string_char *ret, int err)
 860 {
 861     if(err == 1) return MSVCP_basic_string_char_ctor_cstr(ret, "iostream error");
 862     return MSVCP_basic_string_char_ctor_cstr(ret, strerror(err));
 863 }
 864
 865 /* ?iostream_category@std@@YAABVerror_category@1@XZ */
 866 /* ?iostream_category@std@@YAAEBVerror_category@1@XZ */
 867 const error_category* __cdecl std_iostream_category(void)
 868 {
 869     TRACE("()\n");
 870     return &iostream_category.base;
 871 }
 872
 873 static custom_category system_category;
 874 DEFINE_RTTI_DATA1(system_category, 0, &error_category_rtti_base_descriptor, ".?AV_System_error_category@std@@")
 875
 876 extern const vtable_ptr MSVCP_system_category_vtable;
 877
 878 static void system_category_ctor(custom_category *this)
 879 {
 880     this->base.vtable = &MSVCP_system_category_vtable;
 881     this->type = "system";
 882 }
 883
 884 /* ?system_category@std@@YAABVerror_category@1@XZ */
 885 /* ?system_category@std@@YAAEBVerror_category@1@XZ */
 886 const error_category* __cdecl std_system_category(void)
 887 {
 888     TRACE("()\n");
 889     return &system_category.base;
 890 }
 891
 892 static custom_category generic_category;
 893 DEFINE_RTTI_DATA1(generic_category, 0, &error_category_rtti_base_descriptor, ".?AV_Generic_error_category@std@@")
 894
 895 extern const vtable_ptr MSVCP_generic_category_vtable;
 896
 897 static void generic_category_ctor(custom_category *this)
 898 {
 899     this->base.vtable = &MSVCP_generic_category_vtable;
 900     this->type = "generic";
 901 }
 902
 903 /* ?generic_category@std@@YAABVerror_category@1@XZ */
 904 /* ?generic_category@std@@YAAEBVerror_category@1@XZ */
 905 const error_category* __cdecl std_generic_category(void)
 906 {
 907     TRACE("()\n");
 908     return &generic_category.base;
 909 }
 910 #endif
 911
 912 #if _MSVCP_VER >= 110
 913 static CRITICAL_SECTION call_once_cs;
 914 static CRITICAL_SECTION_DEBUG call_once_cs_debug =
 915 {
 916     0, 0, &call_once_cs,
 917     { &call_once_cs_debug.ProcessLocksList, &call_once_cs_debug.ProcessLocksList },
 918     0, 0, { (DWORD_PTR)(__FILE__ ": call_once_cs") }
 919 };
 920 static CRITICAL_SECTION call_once_cs = { &call_once_cs_debug, -1, 0, 0, 0, 0 };
 921
 922 void __cdecl _Call_onceEx(int *once, void (__cdecl *func)(void*), void *argv)
 923 {
 924     TRACE("%p %p %p\n", once, func, argv);
 925
 926     EnterCriticalSection(&call_once_cs);
 927     if(!*once) {
 928         /* FIXME: handle exceptions */
 929         func(argv);
 930         *once = 1;
 931     }
 932     LeaveCriticalSection(&call_once_cs);
 933 }
 934
 935 static void __cdecl call_once_func_wrapper(void *func)
 936 {
 937     ((void (__cdecl*)(void))func)();
 938 }
 939
 940 void __cdecl _Call_once(int *once, void (__cdecl *func)(void))
 941 {
 942     TRACE("%p %p\n", once, func);
 943     _Call_onceEx(once, call_once_func_wrapper, func);
 944 }
 945
 946 void __cdecl _Do_call(void *this)
 947 {
 948     CALL_VTBL_FUNC(this, 0, void, (void*), (this));
 949 }
 950 #endif
 951
 952 #if _MSVCP_VER >= 110
 953 typedef struct
 954 {
 955     HANDLE hnd;
 956     DWORD  id;
 957 } _Thrd_t;
 958
 959 typedef int (__cdecl *_Thrd_start_t)(void*);
 960
 961 #define _THRD_ERROR 4
 962
 963 int __cdecl _Thrd_equal(_Thrd_t a, _Thrd_t b)
 964 {
 965     TRACE("(%p %u %p %u)\n", a.hnd, a.id, b.hnd, b.id);
 966     return a.id == b.id;
 967 }
 968
 969 int __cdecl _Thrd_lt(_Thrd_t a, _Thrd_t b)
 970 {
 971     TRACE("(%p %u %p %u)\n", a.hnd, a.id, b.hnd, b.id);
 972     return a.id < b.id;
 973 }
 974
 975 void __cdecl _Thrd_sleep(const xtime *t)
 976 {
 977     TRACE("(%p)\n", t);
 978     Sleep(_Xtime_diff_to_millis(t));
 979 }
 980
 981 void __cdecl _Thrd_yield(void)
 982 {
 983     TRACE("()\n");
 984     Sleep(0);
 985 }
 986
 987 static _Thrd_t thread_current(void)
 988 {
 989     _Thrd_t ret;
 990
 991     if(DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
 992                        GetCurrentProcess(), &ret.hnd, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
 993         CloseHandle(ret.hnd);
 994     } else {
 995         ret.hnd = 0;
 996     }
 997     ret.id  = GetCurrentThreadId();
 998
 999     TRACE("(%p %u)\n", ret.hnd, ret.id);
1000     return ret;
1001 }
1002
1003 #ifndef __i386__
1004 _Thrd_t __cdecl _Thrd_current(void)
1005 {
1006     return thread_current();
1007 }
1008 #else
1009 ULONGLONG __cdecl _Thrd_current(void)
1010 {
1011     union {
1012         _Thrd_t thr;
1013         ULONGLONG ull;
1014     } ret;
1015
1016     C_ASSERT(sizeof(_Thrd_t) <= sizeof(ULONGLONG));
1017
1018     ret.thr = thread_current();
1019     return ret.ull;
1020 }
1021 #endif
1022
1023 int __cdecl _Thrd_join(_Thrd_t thr, int *code)
1024 {
1025     TRACE("(%p %u %p)\n", thr.hnd, thr.id, code);
1026     if (WaitForSingleObject(thr.hnd, INFINITE))
1027         return _THRD_ERROR;
1028
1029     if (code)
1030         GetExitCodeThread(thr.hnd, (DWORD *)code);
1031
1032     CloseHandle(thr.hnd);
1033     return 0;
1034 }
1035
1036 int __cdecl _Thrd_start(_Thrd_t *thr, LPTHREAD_START_ROUTINE proc, void *arg)
1037 {
1038     TRACE("(%p %p %p)\n", thr, proc, arg);
1039     thr->hnd = CreateThread(NULL, 0, proc, arg, 0, &thr->id);
1040     return thr->hnd ? 0 : _THRD_ERROR;
1041 }
1042
1043 typedef struct
1044 {
1045     _Thrd_start_t proc;
1046     void *arg;
1047 } thread_proc_arg;
1048
1049 static DWORD WINAPI thread_proc_wrapper(void *arg)
1050 {
1051     thread_proc_arg wrapped_arg = *((thread_proc_arg*)arg);
1052     free(arg);
1053     return wrapped_arg.proc(wrapped_arg.arg);
1054 }
1055
1056 int __cdecl _Thrd_create(_Thrd_t *thr, _Thrd_start_t proc, void *arg)
1057 {
1058     thread_proc_arg *wrapped_arg;
1059     int ret;
1060
1061     TRACE("(%p %p %p)\n", thr, proc, arg);
1062
1063     wrapped_arg = malloc(sizeof(*wrapped_arg));
1064     if(!wrapped_arg)
1065         return _THRD_ERROR; /* TODO: probably different error should be returned here */
1066
1067     wrapped_arg->proc = proc;
1068     wrapped_arg->arg = arg;
1069     ret = _Thrd_start(thr, thread_proc_wrapper, wrapped_arg);
1070     if(ret) free(wrapped_arg);
1071     return ret;
1072 }
1073
1074 int __cdecl _Thrd_detach(_Thrd_t thr)
1075 {
1076     return CloseHandle(thr.hnd) ? 0 : _THRD_ERROR;
1077 }
1078
1079 typedef struct
1080 {
1081     const vtable_ptr *vtable;
1082     _Cnd_t cnd;
1083     _Mtx_t mtx;
1084     MSVCP_bool launched;
1085 } _Pad;
1086
1087 DEFINE_RTTI_DATA0(_Pad, 0, ".?AV_Pad@std@@")
1088
1089 /* ??_7_Pad@std@@6B@ */
1090 extern const vtable_ptr MSVCP__Pad_vtable;
1091
1092 unsigned int __cdecl _Thrd_hardware_concurrency(void)
1093 {
1094     static unsigned int val = -1;
1095
1096     TRACE("()\n");
1097
1098     if(val == -1) {
1099         SYSTEM_INFO si;
1100
1101         GetSystemInfo(&si);
1102         val = si.dwNumberOfProcessors;
1103     }
1104
1105     return val;
1106 }
1107
1108 unsigned int __cdecl _Thrd_id(void)
1109 {
1110     TRACE("()\n");
1111     return GetCurrentThreadId();
1112 }
1113
1114 /* ??0_Pad@std@@QAE@XZ */
1115 /* ??0_Pad@std@@QEAA@XZ */
1116 DEFINE_THISCALL_WRAPPER(_Pad_ctor, 4)
1117 _Pad* __thiscall _Pad_ctor(_Pad *this)
1118 {
1119     TRACE("(%p)\n", this);
1120
1121     this->vtable = &MSVCP__Pad_vtable;
1122     _Cnd_init(&this->cnd);
1123     _Mtx_init(&this->mtx, 0);
1124     this->launched = FALSE;
1125     _Mtx_lock(MTX_T_TO_ARG(this->mtx));
1126     return this;
1127 }
1128
1129 /* ??4_Pad@std@@QAEAAV01@ABV01@@Z */
1130 /* ??4_Pad@std@@QEAAAEAV01@AEBV01@@Z */
1131 DEFINE_THISCALL_WRAPPER(_Pad_op_assign, 8)
1132 _Pad* __thiscall _Pad_op_assign(_Pad *this, const _Pad *copy)
1133 {
1134     TRACE("(%p %p)\n", this, copy);
1135
1136     this->cnd = copy->cnd;
1137     this->mtx = copy->mtx;
1138     this->launched = copy->launched;
1139     return this;
1140 }
1141
1142 /* ??0_Pad@std@@QAE@ABV01@@Z */
1143 /* ??0_Pad@std@@QEAA@AEBV01@@Z */
1144 DEFINE_THISCALL_WRAPPER(_Pad_copy_ctor, 8)
1145 _Pad* __thiscall _Pad_copy_ctor(_Pad *this, const _Pad *copy)
1146 {
1147     TRACE("(%p %p)\n", this, copy);
1148
1149     this->vtable = &MSVCP__Pad_vtable;
1150     return _Pad_op_assign(this, copy);
1151 }
1152
1153 /* ??1_Pad@std@@QAE@XZ */
1154 /* ??1_Pad@std@@QEAA@XZ */
1155 DEFINE_THISCALL_WRAPPER(_Pad_dtor, 4)
1156 void __thiscall _Pad_dtor(_Pad *this)
1157 {
1158     TRACE("(%p)\n", this);
1159
1160     _Mtx_unlock(MTX_T_TO_ARG(this->mtx));
1161     _Mtx_destroy(MTX_T_TO_ARG(this->mtx));
1162     _Cnd_destroy(CND_T_TO_ARG(this->cnd));
1163 }
1164
1165 DEFINE_THISCALL_WRAPPER(_Pad__Go, 4)
1166 #define call__Pad__Go(this) CALL_VTBL_FUNC(this, 0, unsigned int, (_Pad*), (this))
1167 unsigned int __thiscall _Pad__Go(_Pad *this)
1168 {
1169     ERR("(%p) should not be called\n", this);
1170     return 0;
1171 }
1172
1173 static DWORD WINAPI launch_thread_proc(void *arg)
1174 {
1175     _Pad *this = arg;
1176     return call__Pad__Go(this);
1177 }
1178
1179 /* ?_Launch@_Pad@std@@QAEXPAU_Thrd_imp_t@@@Z */
1180 /* ?_Launch@_Pad@std@@QEAAXPEAU_Thrd_imp_t@@@Z */
1181 DEFINE_THISCALL_WRAPPER(_Pad__Launch, 8)
1182 void __thiscall _Pad__Launch(_Pad *this, _Thrd_t *thr)
1183 {
1184     TRACE("(%p %p)\n", this, thr);
1185
1186     _Thrd_start(thr, launch_thread_proc, this);
1187     _Cnd_wait(CND_T_TO_ARG(this->cnd), MTX_T_TO_ARG(this->mtx));
1188 }
1189
1190 /* ?_Release@_Pad@std@@QAEXXZ */
1191 /* ?_Release@_Pad@std@@QEAAXXZ */
1192 DEFINE_THISCALL_WRAPPER(_Pad__Release, 4)
1193 void __thiscall _Pad__Release(_Pad *this)
1194 {
1195     TRACE("(%p)\n", this);
1196
1197     _Mtx_lock(MTX_T_TO_ARG(this->mtx));
1198     this->launched = TRUE;
1199     _Cnd_signal(CND_T_TO_ARG(this->cnd));
1200     _Mtx_unlock(MTX_T_TO_ARG(this->mtx));
1201 }
1202 #endif
1203
1204 #if _MSVCP_VER >= 100
1205 typedef struct _Page
1206 {
1207     struct _Page *_Next;
1208     MSVCP_size_t _Mask;
1209     char data[1];
1210 } _Page;
1211
1212 typedef struct
1213 {
1214     LONG lock;
1215     _Page *head;
1216     _Page *tail;
1217     MSVCP_size_t head_pos;
1218     MSVCP_size_t tail_pos;
1219 } threadsafe_queue;
1220
1221 #define QUEUES_NO 8
1222 typedef struct
1223 {
1224     MSVCP_size_t tail_pos;
1225     MSVCP_size_t head_pos;
1226     threadsafe_queue queues[QUEUES_NO];
1227 } queue_data;
1228
1229 typedef struct
1230 {
1231     const vtable_ptr *vtable;
1232     queue_data *data; /* queue_data structure is not binary compatible */
1233     MSVCP_size_t alloc_count;
1234     MSVCP_size_t item_size;
1235 } _Concurrent_queue_base_v4;
1236
1237 extern const vtable_ptr MSVCP__Concurrent_queue_base_v4_vtable;
1238
1239 /* ?_Internal_throw_exception@_Concurrent_queue_base_v4@details@Concurrency@@IBEXXZ */
1240 /* ?_Internal_throw_exception@_Concurrent_queue_base_v4@details@Concurrency@@IEBAXXZ */
1241 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_throw_exception, 4)
1242 void __thiscall _Concurrent_queue_base_v4__Internal_throw_exception(
1243         const _Concurrent_queue_base_v4 *this)
1244 {
1245     TRACE("(%p)\n", this);
1246     throw_exception(EXCEPTION_BAD_ALLOC, NULL);
1247 }
1248
1249 /* ??0_Concurrent_queue_base_v4@details@Concurrency@@IAE@I@Z */
1250 /* ??0_Concurrent_queue_base_v4@details@Concurrency@@IEAA@_K@Z */
1251 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4_ctor, 8)
1252 _Concurrent_queue_base_v4* __thiscall _Concurrent_queue_base_v4_ctor(
1253         _Concurrent_queue_base_v4 *this, MSVCP_size_t size)
1254 {
1255     TRACE("(%p %ld)\n", this, size);
1256
1257     this->data = MSVCRT_operator_new(sizeof(*this->data));
1258     memset(this->data, 0, sizeof(*this->data));
1259
1260     this->vtable = &MSVCP__Concurrent_queue_base_v4_vtable;
1261     this->item_size = size;
1262
1263     /* alloc_count needs to be power of 2 */
1264     this->alloc_count =
1265         size <= 8 ? 32 :
1266         size <= 16 ? 16 :
1267         size <= 32 ? 8 :
1268         size <= 64 ? 4 :
1269         size <= 128 ? 2 : 1;
1270     return this;
1271 }
1272
1273 /* ??1_Concurrent_queue_base_v4@details@Concurrency@@MAE@XZ */
1274 /* ??1_Concurrent_queue_base_v4@details@Concurrency@@MEAA@XZ */
1275 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4_dtor, 4)
1276 void __thiscall _Concurrent_queue_base_v4_dtor(_Concurrent_queue_base_v4 *this)
1277 {
1278     FIXME("(%p) stub\n", this);
1279 }
1280
1281 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4_vector_dtor, 8)
1282 _Concurrent_queue_base_v4* __thiscall _Concurrent_queue_base_v4_vector_dtor(
1283         _Concurrent_queue_base_v4 *this, unsigned int flags)
1284 {
1285     TRACE("(%p %x)\n", this, flags);
1286     if(flags & 2) {
1287         /* we have an array, with the number of elements stored before the first object */
1288         INT_PTR i, *ptr = (INT_PTR *)this-1;
1289
1290         for(i=*ptr-1; i>=0; i--)
1291             _Concurrent_queue_base_v4_dtor(this+i);
1292         MSVCRT_operator_delete(ptr);
1293     } else {
1294         if(flags & 1)
1295             _Concurrent_queue_base_v4_dtor(this);
1296         MSVCRT_operator_delete(this);
1297     }
1298
1299     return this;
1300 }
1301
1302 /* ?_Internal_finish_clear@_Concurrent_queue_base_v4@details@Concurrency@@IAEXXZ */
1303 /* ?_Internal_finish_clear@_Concurrent_queue_base_v4@details@Concurrency@@IEAAXXZ */
1304 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_finish_clear, 4)
1305 void __thiscall _Concurrent_queue_base_v4__Internal_finish_clear(
1306         _Concurrent_queue_base_v4 *this)
1307 {
1308     FIXME("(%p) stub\n", this);
1309 }
1310
1311 /* ?_Internal_empty@_Concurrent_queue_base_v4@details@Concurrency@@IBE_NXZ */
1312 /* ?_Internal_empty@_Concurrent_queue_base_v4@details@Concurrency@@IEBA_NXZ */
1313 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_empty, 4)
1314 MSVCP_bool __thiscall _Concurrent_queue_base_v4__Internal_empty(
1315         const _Concurrent_queue_base_v4 *this)
1316 {
1317     FIXME("(%p) stub\n", this);
1318     return 0;
1319 }
1320
1321 /* ?_Internal_size@_Concurrent_queue_base_v4@details@Concurrency@@IBEIXZ */
1322 /* ?_Internal_size@_Concurrent_queue_base_v4@details@Concurrency@@IEBA_KXZ */
1323 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_size, 4)
1324 MSVCP_size_t __thiscall _Concurrent_queue_base_v4__Internal_size(
1325         const _Concurrent_queue_base_v4 *this)
1326 {
1327     FIXME("(%p) stub\n", this);
1328     return 0;
1329 }
1330
1331 /* ?_Internal_push@_Concurrent_queue_base_v4@details@Concurrency@@IAEXPBX@Z */
1332 /* ?_Internal_push@_Concurrent_queue_base_v4@details@Concurrency@@IEAAXPEBX@Z */
1333 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_push, 8)
1334 void __thiscall _Concurrent_queue_base_v4__Internal_push(
1335         _Concurrent_queue_base_v4 *this, const void *e)
1336 {
1337     FIXME("(%p %p) stub\n", this, e);
1338 }
1339
1340 /* ?_Internal_move_push@_Concurrent_queue_base_v4@details@Concurrency@@IAEXPAX@Z */
1341 /* ?_Internal_move_push@_Concurrent_queue_base_v4@details@Concurrency@@IEAAXPEAX@Z */
1342 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_move_push, 8)
1343 void __thiscall _Concurrent_queue_base_v4__Internal_move_push(
1344         _Concurrent_queue_base_v4 *this, void *e)
1345 {
1346     FIXME("(%p %p) stub\n", this, e);
1347 }
1348
1349 /* ?_Internal_pop_if_present@_Concurrent_queue_base_v4@details@Concurrency@@IAE_NPAX@Z */
1350 /* ?_Internal_pop_if_present@_Concurrent_queue_base_v4@details@Concurrency@@IEAA_NPEAX@Z */
1351 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_pop_if_present, 8)
1352 MSVCP_bool __thiscall _Concurrent_queue_base_v4__Internal_pop_if_present(
1353         _Concurrent_queue_base_v4 *this, void *e)
1354 {
1355     FIXME("(%p %p) stub\n", this, e);
1356     return 0;
1357 }
1358
1359 /* ?_Internal_swap@_Concurrent_queue_base_v4@details@Concurrency@@IAEXAAV123@@Z */
1360 /* ?_Internal_swap@_Concurrent_queue_base_v4@details@Concurrency@@IEAAXAEAV123@@Z */
1361 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4__Internal_swap, 8)
1362 void __thiscall _Concurrent_queue_base_v4__Internal_swap(
1363         _Concurrent_queue_base_v4 *this, _Concurrent_queue_base_v4 *r)
1364 {
1365     FIXME("(%p %p) stub\n", this, r);
1366 }
1367
1368 DEFINE_THISCALL_WRAPPER(_Concurrent_queue_base_v4_dummy, 4)
1369 void __thiscall _Concurrent_queue_base_v4_dummy(_Concurrent_queue_base_v4 *this)
1370 {
1371     ERR("unexpected call\n");
1372 }
1373
1374 DEFINE_RTTI_DATA0(_Concurrent_queue_base_v4, 0, ".?AV_Concurrent_queue_base_v4@details@Concurrency@@")
1375 #endif
1376
1377 #ifndef __GNUC__
1378 void __asm_dummy_vtables(void) {
1379 #endif
1380 #if _MSVCP_VER == 100
1381     __ASM_VTABLE(iostream_category,
1382             VTABLE_ADD_FUNC(custom_category_vector_dtor)
1383             VTABLE_ADD_FUNC(custom_category_name)
1384             VTABLE_ADD_FUNC(iostream_category_message)
1385             VTABLE_ADD_FUNC(custom_category_default_error_condition)
1386             VTABLE_ADD_FUNC(custom_category_equivalent)
1387             VTABLE_ADD_FUNC(custom_category_equivalent_code));
1388     __ASM_VTABLE(system_category,
1389             VTABLE_ADD_FUNC(custom_category_vector_dtor)
1390             VTABLE_ADD_FUNC(custom_category_name)
1391             VTABLE_ADD_FUNC(custom_category_message)
1392             VTABLE_ADD_FUNC(custom_category_default_error_condition)
1393             VTABLE_ADD_FUNC(custom_category_equivalent)
1394             VTABLE_ADD_FUNC(custom_category_equivalent_code));
1395     __ASM_VTABLE(generic_category,
1396             VTABLE_ADD_FUNC(custom_category_vector_dtor)
1397             VTABLE_ADD_FUNC(custom_category_name)
1398             VTABLE_ADD_FUNC(custom_category_message)
1399             VTABLE_ADD_FUNC(custom_category_default_error_condition)
1400             VTABLE_ADD_FUNC(custom_category_equivalent)
1401             VTABLE_ADD_FUNC(custom_category_equivalent_code));
1402 #endif
1403 #if _MSVCP_VER >= 100
1404     __ASM_VTABLE(_Concurrent_queue_base_v4,
1405 #if _MSVCP_VER >= 110
1406             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_dummy)
1407 #endif
1408             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_dummy)
1409             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_dummy)
1410             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_vector_dtor)
1411             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_dummy)
1412             VTABLE_ADD_FUNC(_Concurrent_queue_base_v4_dummy));
1413 #endif
1414 #if _MSVCP_VER >= 110
1415     __ASM_VTABLE(_Pad,
1416             VTABLE_ADD_FUNC(_Pad__Go));
1417 #endif
1418 #ifndef __GNUC__
1419 }
1420 #endif
1421
1422 /*********************************************************************
1423  *  __crtInitializeCriticalSectionEx (MSVCP140.@)
1424  */
1425 BOOL CDECL MSVCP__crtInitializeCriticalSectionEx(
1426         CRITICAL_SECTION *cs, DWORD spin_count, DWORD flags)
1427 {
1428     TRACE("(%p %x %x)\n", cs, spin_count, flags);
1429     return InitializeCriticalSectionEx(cs, spin_count, flags);
1430 }
1431
1432 /*********************************************************************
1433  *  __crtCreateEventExW (MSVCP140.@)
1434  */
1435 HANDLE CDECL MSVCP__crtCreateEventExW(
1436         SECURITY_ATTRIBUTES *attribs, LPCWSTR name, DWORD flags, DWORD access)
1437 {
1438     TRACE("(%p %s 0x%08x 0x%08x)\n", attribs, debugstr_w(name), flags, access);
1439     return CreateEventExW(attribs, name, flags, access);
1440 }
1441
1442 /*********************************************************************
1443  *  __crtGetTickCount64 (MSVCP140.@)
1444  */
1445 ULONGLONG CDECL MSVCP__crtGetTickCount64(void)
1446 {
1447     return GetTickCount64();
1448 }
1449
1450 /*********************************************************************
1451  *  __crtGetCurrentProcessorNumber (MSVCP140.@)
1452  */
1453 DWORD CDECL MSVCP__crtGetCurrentProcessorNumber(void)
1454 {
1455     return GetCurrentProcessorNumber();
1456 }
1457
1458 /*********************************************************************
1459  *  __crtFlushProcessWriteBuffers (MSVCP140.@)
1460  */
1461 VOID CDECL MSVCP__crtFlushProcessWriteBuffers(void)
1462 {
1463     return FlushProcessWriteBuffers();
1464 }
1465
1466 /*********************************************************************
1467  *  __crtCreateSemaphoreExW (MSVCP140.@)
1468  */
1469 HANDLE CDECL MSVCP__crtCreateSemaphoreExW(
1470         SECURITY_ATTRIBUTES *attribs, LONG initial_count, LONG max_count, LPCWSTR name,
1471         DWORD flags, DWORD access)
1472 {
1473     TRACE("(%p %d %d %s 0x%08x 0x%08x)\n", attribs, initial_count, max_count, debugstr_w(name),
1474             flags, access);
1475     return CreateSemaphoreExW(attribs, initial_count, max_count, name, flags, access);
1476 }
1477
1478 /*********************************************************************
1479  *  __crtCreateThreadpoolTimer (MSVCP140.@)
1480  */
1481 PTP_TIMER CDECL MSVCP__crtCreateThreadpoolTimer(PTP_TIMER_CALLBACK callback,
1482         PVOID userdata, TP_CALLBACK_ENVIRON *environment)
1483 {
1484     TRACE("(%p %p %p)\n", callback, userdata, environment);
1485     return CreateThreadpoolTimer(callback, userdata, environment);
1486 }
1487
1488 /*********************************************************************
1489  *  __crtCloseThreadpoolTimer (MSVCP140.@)
1490  */
1491 VOID CDECL MSVCP__crtCloseThreadpoolTimer(TP_TIMER *timer)
1492 {
1493     TRACE("(%p)\n", timer);
1494     CloseThreadpoolTimer(timer);
1495 }
1496
1497 /*********************************************************************
1498  *  __crtSetThreadpoolTimer (MSVCP140.@)
1499  */
1500 VOID CDECL MSVCP__crtSetThreadpoolTimer(TP_TIMER *timer,
1501         FILETIME *due_time, DWORD period, DWORD window_length)
1502 {
1503     TRACE("(%p %p 0x%08x 0x%08x)\n", timer, due_time, period, window_length);
1504     return SetThreadpoolTimer(timer, due_time, period, window_length);
1505 }
1506
1507 /*********************************************************************
1508  *  __crtWaitForThreadpoolTimerCallbacks (MSVCP140.@)
1509  */
1510 VOID CDECL MSVCP__crtWaitForThreadpoolTimerCallbacks(TP_TIMER *timer, BOOL cancel)
1511 {
1512     TRACE("(%p %d)\n", timer, cancel);
1513     WaitForThreadpoolTimerCallbacks(timer, cancel);
1514 }
1515
1516 /*********************************************************************
1517  *  __crtCreateThreadpoolWait (MSVCP140.@)
1518  */
1519 PTP_WAIT CDECL MSVCP__crtCreateThreadpoolWait(PTP_WAIT_CALLBACK callback,
1520         PVOID userdata, TP_CALLBACK_ENVIRON *environment)
1521 {
1522     TRACE("(%p %p %p)\n", callback, userdata, environment);
1523     return CreateThreadpoolWait(callback, userdata, environment);
1524 }
1525
1526 /*********************************************************************
1527  *  __crtCloseThreadpoolWait (MSVCP140.@)
1528  */
1529 VOID CDECL MSVCP__crtCloseThreadpoolWait(TP_WAIT *wait)
1530 {
1531     TRACE("(%p)\n", wait);
1532     CloseThreadpoolWait(wait);
1533 }
1534
1535 /*********************************************************************
1536  *  __crtSetThreadpoolWait (MSVCP140.@)
1537  */
1538 VOID CDECL MSVCP__crtSetThreadpoolWait(TP_WAIT *wait, HANDLE handle, FILETIME *due_time)
1539 {
1540     TRACE("(%p %p %p)\n", wait, handle, due_time);
1541     return SetThreadpoolWait(wait, handle, due_time);
1542 }
1543
1544 /*********************************************************************
1545  *  __crtFreeLibraryWhenCallbackReturns (MSVCP140.@)
1546  */
1547 VOID CDECL MSVCP__crtFreeLibraryWhenCallbackReturns(PTP_CALLBACK_INSTANCE instance, HMODULE mod)
1548 {
1549     TRACE("(%p %p)\n", instance, mod);
1550     FreeLibraryWhenCallbackReturns(instance, mod);
1551 }
1552
1553 /* ?_Execute_once@std@@YAHAAUonce_flag@1@P6GHPAX1PAPAX@Z1@Z */
1554 /* ?_Execute_once@std@@YAHAEAUonce_flag@1@P6AHPEAX1PEAPEAX@Z1@Z */
1555 BOOL __cdecl _Execute_once(INIT_ONCE *flag, PINIT_ONCE_FN func, void *param)
1556 {
1557     return InitOnceExecuteOnce(flag, func, param, NULL);
1558 }
1559
1560 #if _MSVCP_VER >= 100
1561 void init_misc(void *base)
1562 {
1563 #ifdef __x86_64__
1564 #if _MSVCP_VER == 100
1565     init_error_category_rtti(base);
1566     init_iostream_category_rtti(base);
1567     init_system_category_rtti(base);
1568     init_generic_category_rtti(base);
1569 #endif
1570 #if _MSVCP_VER >= 100
1571     init__Concurrent_queue_base_v4_rtti(base);
1572 #endif
1573 #if _MSVCP_VER >= 110
1574     init__Pad_rtti(base);
1575 #endif
1576 #endif
1577
1578 #if _MSVCP_VER == 100
1579     iostream_category_ctor(&iostream_category);
1580     system_category_ctor(&system_category);
1581     generic_category_ctor(&generic_category);
1582 #endif
1583 }
1584
1585 void free_misc(void)
1586 {
1587 #if _MSVCP_VER >= 110
1588     if(keyed_event)
1589         NtClose(keyed_event);
1590     HeapFree(GetProcessHeap(), 0, broadcast_at_thread_exit.to_broadcast);
1591 #endif
1592 }
1593 #endif
1594
1595 #if _MSVCP_VER >= 140
1596 LONGLONG __cdecl _Query_perf_counter(void)
1597 {
1598     LARGE_INTEGER li;
1599     QueryPerformanceCounter(&li);
1600     return li.QuadPart;
1601 }
1602
1603 LONGLONG __cdecl _Query_perf_frequency(void)
1604 {
1605     LARGE_INTEGER li;
1606     QueryPerformanceFrequency(&li);
1607     return li.QuadPart;
1608 }
1609 #endif
1610
1611 void __cdecl threads__Mtx_new(void **mtx)
1612 {
1613     *mtx = MSVCRT_operator_new(sizeof(CRITICAL_SECTION));
1614     InitializeCriticalSection(*mtx);
1615 }
1616
1617 void __cdecl threads__Mtx_delete(void *mtx)
1618 {
1619     DeleteCriticalSection(mtx);
1620 }
1621
1622 void __cdecl threads__Mtx_lock(void *mtx)
1623 {
1624     EnterCriticalSection(mtx);
1625 }
1626
1627 void __cdecl threads__Mtx_unlock(void *mtx)
1628 {
1629     LeaveCriticalSection(mtx);
1630 }
1631
1632 #if _MSVCP_VER >= 110
1633 static LONG shared_ptr_lock;
1634
1635 void __cdecl _Lock_shared_ptr_spin_lock(void)
1636 {
1637     LONG l = 0;
1638
1639     while(InterlockedCompareExchange(&shared_ptr_lock, 1, 0) != 0) {
1640         if(l++ == 1000) {
1641             Sleep(0);
1642             l = 0;
1643         }
1644     }
1645 }
1646
1647 void __cdecl _Unlock_shared_ptr_spin_lock(void)
1648 {
1649     shared_ptr_lock = 0;
1650 }
1651 #endif
1652
1653 #if _MSVCP_VER >= 100
1654 /* ?is_current_task_group_canceling@Concurrency@@YA_NXZ */
1655 MSVCP_bool __cdecl is_current_task_group_canceling(void)
1656 {
1657     return Context_IsCurrentTaskCollectionCanceling();
1658 }
1659 #endif
1660
1661 #if _MSVCP_VER >= 140
1662 typedef struct {
1663     void *unk0;
1664     BYTE unk1;
1665 } task_continuation_context;
1666
1667 /* ??0task_continuation_context@Concurrency@@AAE@XZ */
1668 /* ??0task_continuation_context@Concurrency@@AEAA@XZ */
1669 DEFINE_THISCALL_WRAPPER(task_continuation_context_ctor, 4)
1670 task_continuation_context* __thiscall task_continuation_context_ctor(task_continuation_context *this)
1671 {
1672     TRACE("(%p)\n", this);
1673     memset(this, 0, sizeof(*this));
1674     return this;
1675 }
1676
1677 typedef struct {
1678     const vtable_ptr *vtable;
1679     void (__cdecl *func)(void);
1680     int unk[4];
1681     void *unk2[3];
1682     void *this;
1683 } function_void_cdecl_void;
1684
1685 /* ?_Assign@_ContextCallback@details@Concurrency@@AAEXPAX@Z */
1686 /* ?_Assign@_ContextCallback@details@Concurrency@@AEAAXPEAX@Z */
1687 DEFINE_THISCALL_WRAPPER(_ContextCallback__Assign, 8)
1688 void __thiscall _ContextCallback__Assign(void *this, void *v)
1689 {
1690     TRACE("(%p %p)\n", this, v);
1691 }
1692
1693 #define call_function_do_call(this) CALL_VTBL_FUNC(this, 8, void, (function_void_cdecl_void*), (this))
1694 #define call_function_do_clean(this,b) CALL_VTBL_FUNC(this, 16, void, (function_void_cdecl_void*,MSVCP_bool), (this, b))
1695 /* ?_CallInContext@_ContextCallback@details@Concurrency@@QBEXV?$function@$$A6AXXZ@std@@_N@Z */
1696 /* ?_CallInContext@_ContextCallback@details@Concurrency@@QEBAXV?$function@$$A6AXXZ@std@@_N@Z */
1697 DEFINE_THISCALL_WRAPPER(_ContextCallback__CallInContext, 48)
1698 void __thiscall _ContextCallback__CallInContext(const void *this, function_void_cdecl_void func, MSVCP_bool b)
1699 {
1700     TRACE("(%p %p %x)\n", this, func.func, b);
1701     call_function_do_call(func.this);
1702     call_function_do_clean(func.this, func.this!=&func);
1703 }
1704
1705 /* ?_Capture@_ContextCallback@details@Concurrency@@AAEXXZ */
1706 /* ?_Capture@_ContextCallback@details@Concurrency@@AEAAXXZ */
1707 DEFINE_THISCALL_WRAPPER(_ContextCallback__Capture, 4)
1708 void __thiscall _ContextCallback__Capture(void *this)
1709 {
1710     TRACE("(%p)\n", this);
1711 }
1712
1713 /* ?_Reset@_ContextCallback@details@Concurrency@@AAEXXZ */
1714 /* ?_Reset@_ContextCallback@details@Concurrency@@AEAAXXZ */
1715 DEFINE_THISCALL_WRAPPER(_ContextCallback__Reset, 4)
1716 void __thiscall _ContextCallback__Reset(void *this)
1717 {
1718     TRACE("(%p)\n", this);
1719 }
1720
1721 /* ?_IsCurrentOriginSTA@_ContextCallback@details@Concurrency@@CA_NXZ */
1722 MSVCP_bool __cdecl _ContextCallback__IsCurrentOriginSTA(void *this)
1723 {
1724     TRACE("(%p)\n", this);
1725     return FALSE;
1726 }
1727
1728 typedef struct {
1729     /*_Task_impl_base*/void *task;
1730     MSVCP_bool scheduled;
1731     MSVCP_bool started;
1732 } _TaskEventLogger;
1733
1734 /* ?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QAEXXZ */
1735 /* ?_LogCancelTask@_TaskEventLogger@details@Concurrency@@QEAAXXZ */
1736 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogCancelTask, 4)
1737 void __thiscall _TaskEventLogger__LogCancelTask(_TaskEventLogger *this)
1738 {
1739     TRACE("(%p)\n", this);
1740 }
1741
1742 /* ?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QAEX_N@Z */
1743 /* ?_LogScheduleTask@_TaskEventLogger@details@Concurrency@@QEAAX_N@Z */
1744 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogScheduleTask, 8)
1745 void __thiscall _TaskEventLogger__LogScheduleTask(_TaskEventLogger *this, MSVCP_bool continuation)
1746 {
1747     TRACE("(%p %x)\n", this, continuation);
1748 }
1749
1750 /* ?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ */
1751 /* ?_LogTaskCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ */
1752 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogTaskCompleted, 4)
1753 void __thiscall _TaskEventLogger__LogTaskCompleted(_TaskEventLogger *this)
1754 {
1755     TRACE("(%p)\n", this);
1756 }
1757
1758 /* ?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ */
1759 /* ?_LogTaskExecutionCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ */
1760 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogTaskExecutionCompleted, 4)
1761 void __thiscall _TaskEventLogger__LogTaskExecutionCompleted(_TaskEventLogger *this)
1762 {
1763     TRACE("(%p)\n", this);
1764 }
1765
1766 /* ?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QAEXXZ */
1767 /* ?_LogWorkItemCompleted@_TaskEventLogger@details@Concurrency@@QEAAXXZ */
1768 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogWorkItemCompleted, 4)
1769 void __thiscall _TaskEventLogger__LogWorkItemCompleted(_TaskEventLogger *this)
1770 {
1771     TRACE("(%p)\n", this);
1772 }
1773
1774 /* ?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QAEXXZ */
1775 /* ?_LogWorkItemStarted@_TaskEventLogger@details@Concurrency@@QEAAXXZ */
1776 DEFINE_THISCALL_WRAPPER(_TaskEventLogger__LogWorkItemStarted, 4)
1777 void __thiscall _TaskEventLogger__LogWorkItemStarted(_TaskEventLogger *this)
1778 {
1779     TRACE("(%p)\n", this);
1780 }
1781
1782 typedef struct {
1783     PTP_WORK work;
1784     void (__cdecl *callback)(void*);
1785     void *arg;
1786 } _Threadpool_chore;
1787
1788 /* ?_Reschedule_chore@details@Concurrency@@YAHPBU_Threadpool_chore@12@@Z */
1789 /* ?_Reschedule_chore@details@Concurrency@@YAHPEBU_Threadpool_chore@12@@Z */
1790 int __cdecl _Reschedule_chore(const _Threadpool_chore *chore)
1791 {
1792     TRACE("(%p)\n", chore);
1793
1794     SubmitThreadpoolWork(chore->work);
1795     return 0;
1796 }
1797
1798 static void WINAPI threadpool_callback(PTP_CALLBACK_INSTANCE instance, void *context, PTP_WORK work)
1799 {
1800     _Threadpool_chore *chore = context;
1801     TRACE("calling chore callback: %p\n", chore);
1802     if (chore->callback)
1803         chore->callback(chore->arg);
1804 }
1805
1806 /* ?_Schedule_chore@details@Concurrency@@YAHPAU_Threadpool_chore@12@@Z */
1807 /* ?_Schedule_chore@details@Concurrency@@YAHPEAU_Threadpool_chore@12@@Z */
1808 int __cdecl _Schedule_chore(_Threadpool_chore *chore)
1809 {
1810     TRACE("(%p)\n", chore);
1811
1812     chore->work = CreateThreadpoolWork(threadpool_callback, chore, NULL);
1813     /* FIXME: what should be returned in case of error */
1814     if(!chore->work)
1815         return -1;
1816
1817     return _Reschedule_chore(chore);
1818 }
1819
1820 /* ?_Release_chore@details@Concurrency@@YAXPAU_Threadpool_chore@12@@Z */
1821 /* ?_Release_chore@details@Concurrency@@YAXPEAU_Threadpool_chore@12@@Z */
1822 void __cdecl _Release_chore(_Threadpool_chore *chore)
1823 {
1824     TRACE("(%p)\n", chore);
1825
1826     if(!chore->work) return;
1827     CloseThreadpoolWork(chore->work);
1828     chore->work = NULL;
1829 }
1830 #endif
1831
1832 #if _MSVCP_VER >= 110 && _MSVCP_VER <= 120
1833 typedef struct {
1834     char dummy;
1835 } _Ph;
1836
1837 /* ?_1@placeholders@std@@3V?$_Ph@$00@2@A */
1838 /* ?_20@placeholders@std@@3V?$_Ph@$0BE@@2@A */
1839 _Ph _Ph_1 = {0}, _Ph_2 = {0}, _Ph_3 = {0}, _Ph_4 = {0}, _Ph_5 = {0};
1840 _Ph _Ph_6 = {0}, _Ph_7 = {0}, _Ph_8 = {0}, _Ph_9 = {0}, _Ph_10 = {0};
1841 _Ph _Ph_11 = {0}, _Ph_12 = {0}, _Ph_13 = {0}, _Ph_14 = {0}, _Ph_15 = {0};
1842 _Ph _Ph_16 = {0}, _Ph_17 = {0}, _Ph_18 = {0}, _Ph_19 = {0}, _Ph_20 = {0};
1843 #endif
1844
1845 #if _MSVCP_VER >= 100
1846 /* based on wined3d_log2i from wined3d.h */
1847 /* Return the integer base-2 logarithm of (x|1). Result is 0 for x == 0. */
1848 static inline unsigned int log2i(unsigned int x)
1849 {
1850 #ifdef HAVE___BUILTIN_CLZ
1851     return __builtin_clz(x|1) ^ 0x1f;
1852 #else
1853     static const unsigned int l[] =
1854     {
1855         ~0u, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
1856           4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
1857           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1858           5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1859           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
1860           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
1861           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
1862           6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
1863           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1864           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1865           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1866           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1867           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1868           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1869           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1870           7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
1871     };
1872     unsigned int i;
1873
1874     x |= 1;
1875     return (i = x >> 16) ? (x = i >> 8) ? l[x] + 24 : l[i] + 16 : (i = x >> 8) ? l[i] + 8 : l[x];
1876 #endif
1877 }
1878
1879 /* ?_Segment_index_of@_Concurrent_vector_base_v4@details@Concurrency@@KAII@Z */
1880 /* ?_Segment_index_of@_Concurrent_vector_base_v4@details@Concurrency@@KA_K_K@Z */
1881 MSVCP_size_t __cdecl _vector_base_v4__Segment_index_of(MSVCP_size_t x)
1882 {
1883     unsigned int half;
1884
1885     TRACE("(%lu)\n", x);
1886
1887     if((sizeof(x) == 8) && (half = x >> 32))
1888         return log2i(half) + 32;
1889
1890     return log2i(x);
1891 }
1892
1893 /* ?_Internal_throw_exception@_Concurrent_vector_base_v4@details@Concurrency@@IBEXI@Z */
1894 /* ?_Internal_throw_exception@_Concurrent_vector_base_v4@details@Concurrency@@IEBAX_K@Z */
1895 DEFINE_THISCALL_WRAPPER(_vector_base_v4__Internal_throw_exception, 8)
1896 void __thiscall _vector_base_v4__Internal_throw_exception(void/*_vector_base_v4*/ *this, MSVCP_size_t idx)
1897 {
1898     static const struct {
1899         exception_type type;
1900         const char *msg;
1901     } exceptions[] = {
1902         { EXCEPTION_OUT_OF_RANGE, "Index out of range" },
1903         { EXCEPTION_OUT_OF_RANGE, "Index out of segments table range" },
1904         { EXCEPTION_RANGE_ERROR,  "Index is inside segment which failed to be allocated" },
1905     };
1906
1907     TRACE("(%p %lu)\n", this, idx);
1908
1909     if(idx < sizeof(exceptions)/sizeof(exceptions[0]))
1910         throw_exception(exceptions[idx].type, exceptions[idx].msg);
1911 }
1912 #endif