dlls/kernel/wowthunk.c

   1 /*
   2  * Win32 WOW Generic Thunk API
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25
  26 #include "wine/winbase16.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "wownt32.h"
  30 #include "excpt.h"
  31 #include "winternl.h"
  32 #include "syslevel.h"
  33 #include "file.h"
  34 #include "task.h"
  35 #include "miscemu.h"
  36 #include "stackframe.h"
  37 #include "wine/exception.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(thunk);
  41 WINE_DECLARE_DEBUG_CHANNEL(relay);
  42
  43 /*
  44  * These are the 16-bit side WOW routines.  They reside in wownt16.h
  45  * in the SDK; since we don't support Win16 source code anyway, I've
  46  * placed them here for compilation with Wine ...
  47  */
  48
  49 DWORD WINAPI GetVDMPointer32W16(SEGPTR,UINT16);
  50
  51 DWORD WINAPI LoadLibraryEx32W16(LPCSTR,DWORD,DWORD);
  52 DWORD WINAPI GetProcAddress32W16(DWORD,LPCSTR);
  53 DWORD WINAPI FreeLibrary32W16(DWORD);
  54
  55 #define CPEX_DEST_STDCALL   0x00000000L
  56 #define CPEX_DEST_CDECL     0x80000000L
  57
  58 DWORD WINAPI CallProcExW16(VOID);
  59 DWORD WINAPI CallProcEx32W16(VOID);
  60
  61 /* thunk for 16-bit CreateThread */
  62 struct thread_args
  63 {
  64     FARPROC16 proc;
  65     DWORD     param;
  66 };
  67
  68 static DWORD CALLBACK start_thread16( LPVOID threadArgs )
  69 {
  70     struct thread_args args = *(struct thread_args *)threadArgs;
  71     HeapFree( GetProcessHeap(), 0, threadArgs );
  72     return K32WOWCallback16( (DWORD)args.proc, args.param );
  73 }
  74
  75
  76 #ifdef __i386__
  77 /* symbols exported from relay16.s */
  78 extern DWORD WINAPI wine_call_to_16( FARPROC16 target, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  79 extern void WINAPI wine_call_to_16_regs( CONTEXT86 *context, DWORD cbArgs, PEXCEPTION_HANDLER handler );
  80 extern void Call16_Ret_Start(), Call16_Ret_End();
  81 extern void CallTo16_Ret();
  82 extern void CALL32_CBClient_Ret();
  83 extern void CALL32_CBClientEx_Ret();
  84 extern DWORD CallTo16_DataSelector;
  85 extern SEGPTR CALL32_CBClient_RetAddr;
  86 extern SEGPTR CALL32_CBClientEx_RetAddr;
  87
  88 static SEGPTR call16_ret_addr;  /* segptr to CallTo16_Ret routine */
  89 #endif
  90
  91 /***********************************************************************
  92  *           WOWTHUNK_Init
  93  */
  94 BOOL WOWTHUNK_Init(void)
  95 {
  96 #ifdef __i386__
  97     /* allocate the code selector for CallTo16 routines */
  98     WORD codesel = SELECTOR_AllocBlock( (void *)Call16_Ret_Start,
  99                                         (char *)Call16_Ret_End - (char *)Call16_Ret_Start,
 100                                         WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
 101     if (!codesel) return FALSE;
 102
 103       /* Patch the return addresses for CallTo16 routines */
 104
 105     CallTo16_DataSelector = wine_get_ds();
 106     call16_ret_addr = MAKESEGPTR( codesel, (char*)CallTo16_Ret - (char*)Call16_Ret_Start );
 107     CALL32_CBClient_RetAddr =
 108         MAKESEGPTR( codesel, (char*)CALL32_CBClient_Ret - (char*)Call16_Ret_Start );
 109     CALL32_CBClientEx_RetAddr =
 110         MAKESEGPTR( codesel, (char*)CALL32_CBClientEx_Ret - (char*)Call16_Ret_Start );
 111 #endif
 112     return TRUE;
 113 }
 114
 115
 116 /*************************************************************
 117  *            call16_handler
 118  *
 119  * Handler for exceptions occurring in 16-bit code.
 120  */
 121 static DWORD call16_handler( EXCEPTION_RECORD *record, EXCEPTION_FRAME *frame,
 122                              CONTEXT *context, EXCEPTION_FRAME **pdispatcher )
 123 {
 124     if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
 125     {
 126         /* unwinding: restore the stack pointer in the TEB, and leave the Win16 mutex */
 127         STACK32FRAME *frame32 = (STACK32FRAME *)((char *)frame - offsetof(STACK32FRAME,frame));
 128         NtCurrentTeb()->cur_stack = frame32->frame16;
 129         _LeaveWin16Lock();
 130     }
 131     else if (!IS_SELECTOR_SYSTEM(context->SegCs))  /* check for Win16 __GP handler */
 132     {
 133         SEGPTR gpHandler = HasGPHandler16( MAKESEGPTR( context->SegCs, context->Eip ) );
 134         if (gpHandler)
 135         {
 136             WORD *stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
 137             *--stack = context->SegCs;
 138             *--stack = context->Eip;
 139
 140             if (!IS_SELECTOR_32BIT(context->SegSs))
 141                 context->Esp = MAKELONG( LOWORD(context->Esp - 2*sizeof(WORD)),
 142                                          HIWORD(context->Esp) );
 143             else
 144                 context->Esp -= 2*sizeof(WORD);
 145
 146             context->SegCs = SELECTOROF( gpHandler );
 147             context->Eip   = OFFSETOF( gpHandler );
 148             return ExceptionContinueExecution;
 149         }
 150     }
 151     return ExceptionContinueSearch;
 152 }
 153
 154
 155 /*
 156  *  32-bit WOW routines (in WOW32, but actually forwarded to KERNEL32)
 157  */
 158
 159 /**********************************************************************
 160  *           K32WOWGetDescriptor        (KERNEL32.70)
 161  */
 162 BOOL WINAPI K32WOWGetDescriptor( SEGPTR segptr, LPLDT_ENTRY ldtent )
 163 {
 164     return GetThreadSelectorEntry( GetCurrentThread(),
 165                                    segptr >> 16, ldtent );
 166 }
 167
 168 /**********************************************************************
 169  *           K32WOWGetVDMPointer        (KERNEL32.56)
 170  */
 171 LPVOID WINAPI K32WOWGetVDMPointer( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 172 {
 173     /* FIXME: add size check too */
 174
 175     if ( fProtectedMode )
 176         return MapSL( vp );
 177     else
 178         return DOSMEM_MapRealToLinear( vp );
 179 }
 180
 181 /**********************************************************************
 182  *           K32WOWGetVDMPointerFix     (KERNEL32.68)
 183  */
 184 LPVOID WINAPI K32WOWGetVDMPointerFix( DWORD vp, DWORD dwBytes, BOOL fProtectedMode )
 185 {
 186     /*
 187      * Hmmm. According to the docu, we should call:
 188      *
 189      *          GlobalFix16( SELECTOROF(vp) );
 190      *
 191      * But this is unnecessary under Wine, as we never move global
 192      * memory segments in linear memory anyway.
 193      *
 194      * (I'm not so sure what we are *supposed* to do if
 195      *  fProtectedMode is TRUE, anyway ...)
 196      */
 197
 198     return K32WOWGetVDMPointer( vp, dwBytes, fProtectedMode );
 199 }
 200
 201 /**********************************************************************
 202  *           K32WOWGetVDMPointerUnfix   (KERNEL32.69)
 203  */
 204 VOID WINAPI K32WOWGetVDMPointerUnfix( DWORD vp )
 205 {
 206     /*
 207      * See above why we don't call:
 208      *
 209      * GlobalUnfix16( SELECTOROF(vp) );
 210      *
 211      */
 212 }
 213
 214 /**********************************************************************
 215  *           K32WOWGlobalAlloc16        (KERNEL32.59)
 216  */
 217 WORD WINAPI K32WOWGlobalAlloc16( WORD wFlags, DWORD cb )
 218 {
 219     return (WORD)GlobalAlloc16( wFlags, cb );
 220 }
 221
 222 /**********************************************************************
 223  *           K32WOWGlobalFree16         (KERNEL32.62)
 224  */
 225 WORD WINAPI K32WOWGlobalFree16( WORD hMem )
 226 {
 227     return (WORD)GlobalFree16( (HGLOBAL16)hMem );
 228 }
 229
 230 /**********************************************************************
 231  *           K32WOWGlobalUnlock16       (KERNEL32.61)
 232  */
 233 BOOL WINAPI K32WOWGlobalUnlock16( WORD hMem )
 234 {
 235     return (BOOL)GlobalUnlock16( (HGLOBAL16)hMem );
 236 }
 237
 238 /**********************************************************************
 239  *           K32WOWGlobalAllocLock16    (KERNEL32.63)
 240  */
 241 DWORD WINAPI K32WOWGlobalAllocLock16( WORD wFlags, DWORD cb, WORD *phMem )
 242 {
 243     WORD hMem = K32WOWGlobalAlloc16( wFlags, cb );
 244     if (phMem) *phMem = hMem;
 245
 246     return K32WOWGlobalLock16( hMem );
 247 }
 248
 249 /**********************************************************************
 250  *           K32WOWGlobalLockSize16     (KERNEL32.65)
 251  */
 252 DWORD WINAPI K32WOWGlobalLockSize16( WORD hMem, PDWORD pcb )
 253 {
 254     if ( pcb )
 255         *pcb = GlobalSize16( (HGLOBAL16)hMem );
 256
 257     return K32WOWGlobalLock16( hMem );
 258 }
 259
 260 /**********************************************************************
 261  *           K32WOWGlobalUnlockFree16   (KERNEL32.64)
 262  */
 263 WORD WINAPI K32WOWGlobalUnlockFree16( DWORD vpMem )
 264 {
 265     if ( !K32WOWGlobalUnlock16( HIWORD(vpMem) ) )
 266         return FALSE;
 267
 268     return K32WOWGlobalFree16( HIWORD(vpMem) );
 269 }
 270
 271
 272 /**********************************************************************
 273  *           K32WOWYield16              (KERNEL32.66)
 274  */
 275 VOID WINAPI K32WOWYield16( void )
 276 {
 277     /*
 278      * This does the right thing for both Win16 and Win32 tasks.
 279      * More or less, at least :-/
 280      */
 281     Yield16();
 282 }
 283
 284 /**********************************************************************
 285  *           K32WOWDirectedYield16       (KERNEL32.67)
 286  */
 287 VOID WINAPI K32WOWDirectedYield16( WORD htask16 )
 288 {
 289     /*
 290      * Argh.  Our scheduler doesn't like DirectedYield by Win32
 291      * tasks at all.  So we do hope that this routine is indeed
 292      * only ever called by Win16 tasks that have thunked up ...
 293      */
 294     DirectedYield16( (HTASK16)htask16 );
 295 }
 296
 297
 298 /***********************************************************************
 299  *           K32WOWHandle32              (KERNEL32.57)
 300  */
 301 HANDLE WINAPI K32WOWHandle32( WORD handle, WOW_HANDLE_TYPE type )
 302 {
 303     switch ( type )
 304     {
 305     case WOW_TYPE_HWND:
 306     case WOW_TYPE_HMENU:
 307     case WOW_TYPE_HDWP:
 308     case WOW_TYPE_HDROP:
 309     case WOW_TYPE_HDC:
 310     case WOW_TYPE_HFONT:
 311     case WOW_TYPE_HRGN:
 312     case WOW_TYPE_HBITMAP:
 313     case WOW_TYPE_HBRUSH:
 314     case WOW_TYPE_HPALETTE:
 315     case WOW_TYPE_HPEN:
 316     case WOW_TYPE_HACCEL:
 317         return (HANDLE)(ULONG_PTR)handle;
 318
 319     case WOW_TYPE_HMETAFILE:
 320         FIXME( "conversion of metafile handles not supported yet\n" );
 321         return (HANDLE)(ULONG_PTR)handle;
 322
 323     case WOW_TYPE_HTASK:
 324         return (HANDLE)((TDB *)GlobalLock16(handle))->teb->tid;
 325
 326     case WOW_TYPE_FULLHWND:
 327         FIXME( "conversion of full window handles not supported yet\n" );
 328         return (HANDLE)(ULONG_PTR)handle;
 329
 330     default:
 331         ERR( "handle 0x%04x of unknown type %d\n", handle, type );
 332         return (HANDLE)(ULONG_PTR)handle;
 333     }
 334 }
 335
 336 /***********************************************************************
 337  *           K32WOWHandle16              (KERNEL32.58)
 338  */
 339 WORD WINAPI K32WOWHandle16( HANDLE handle, WOW_HANDLE_TYPE type )
 340 {
 341     switch ( type )
 342     {
 343     case WOW_TYPE_HWND:
 344     case WOW_TYPE_HMENU:
 345     case WOW_TYPE_HDWP:
 346     case WOW_TYPE_HDROP:
 347     case WOW_TYPE_HDC:
 348     case WOW_TYPE_HFONT:
 349     case WOW_TYPE_HRGN:
 350     case WOW_TYPE_HBITMAP:
 351     case WOW_TYPE_HBRUSH:
 352     case WOW_TYPE_HPALETTE:
 353     case WOW_TYPE_HPEN:
 354     case WOW_TYPE_HACCEL:
 355     case WOW_TYPE_FULLHWND:
 356         if ( HIWORD(handle ) )
 357                 ERR( "handle %p of type %d has non-zero HIWORD\n", handle, type );
 358         return LOWORD(handle);
 359
 360     case WOW_TYPE_HMETAFILE:
 361         FIXME( "conversion of metafile handles not supported yet\n" );
 362         return LOWORD(handle);
 363
 364     case WOW_TYPE_HTASK:
 365         return TASK_GetTaskFromThread( (DWORD)handle );
 366
 367     default:
 368         ERR( "handle %p of unknown type %d\n", handle, type );
 369         return LOWORD(handle);
 370     }
 371 }
 372
 373 /**********************************************************************
 374  *           K32WOWCallback16Ex         (KERNEL32.55)
 375  */
 376 BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags,
 377                                 DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode )
 378 {
 379 #ifdef __i386__
 380     /*
 381      * Arguments must be prepared in the correct order by the caller
 382      * (both for PASCAL and CDECL calling convention), so we simply
 383      * copy them to the 16-bit stack ...
 384      */
 385     WORD *stack = (WORD *)CURRENT_STACK16 - cbArgs / sizeof(WORD);
 386
 387     memcpy( stack, pArgs, cbArgs );
 388
 389     if (dwFlags & (WCB16_REGS|WCB16_REGS_LONG))
 390     {
 391         CONTEXT *context = (CONTEXT *)pdwRetCode;
 392
 393         if (TRACE_ON(relay))
 394         {
 395             DWORD count = cbArgs / sizeof(WORD);
 396
 397             DPRINTF("%04lx:CallTo16(func=%04lx:%04x,ds=%04lx",
 398                     GetCurrentThreadId(),
 399                     context->SegCs, LOWORD(context->Eip), context->SegDs );
 400             while (count) DPRINTF( ",%04x", stack[--count] );
 401             DPRINTF(") ss:sp=%04x:%04x",
 402                     SELECTOROF(NtCurrentTeb()->cur_stack), OFFSETOF(NtCurrentTeb()->cur_stack) );
 403             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x bp=%04x es=%04x fs=%04x\n",
 404                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 405                     (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi,
 406                     (WORD)context->Ebp, (WORD)context->SegEs, (WORD)context->SegFs );
 407             SYSLEVEL_CheckNotLevel( 2 );
 408         }
 409
 410         /* push return address */
 411         if (dwFlags & WCB16_REGS_LONG)
 412         {
 413             *((DWORD *)stack - 1) = HIWORD(call16_ret_addr);
 414             *((DWORD *)stack - 2) = LOWORD(call16_ret_addr);
 415             cbArgs += 2 * sizeof(DWORD);
 416         }
 417         else
 418         {
 419             *((SEGPTR *)stack - 1) = call16_ret_addr;
 420             cbArgs += sizeof(SEGPTR);
 421         }
 422
 423         _EnterWin16Lock();
 424         wine_call_to_16_regs( context, cbArgs, call16_handler );
 425         _LeaveWin16Lock();
 426
 427         if (TRACE_ON(relay))
 428         {
 429             DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x ",
 430                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->cur_stack),
 431                     OFFSETOF(NtCurrentTeb()->cur_stack));
 432             DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n",
 433                     (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx,
 434                     (WORD)context->Edx, (WORD)context->Ebp, (WORD)context->Esp );
 435             SYSLEVEL_CheckNotLevel( 2 );
 436         }
 437     }
 438     else
 439     {
 440         DWORD ret;
 441
 442         if (TRACE_ON(relay))
 443         {
 444             DWORD count = cbArgs / sizeof(WORD);
 445
 446             DPRINTF("%04lx:CallTo16(func=%04x:%04x,ds=%04x",
 447                     GetCurrentThreadId(), HIWORD(vpfn16), LOWORD(vpfn16),
 448                     SELECTOROF(NtCurrentTeb()->cur_stack) );
 449             while (count) DPRINTF( ",%04x", stack[--count] );
 450             DPRINTF(") ss:sp=%04x:%04x\n",
 451                     SELECTOROF(NtCurrentTeb()->cur_stack), OFFSETOF(NtCurrentTeb()->cur_stack) );
 452             SYSLEVEL_CheckNotLevel( 2 );
 453         }
 454
 455         /* push return address */
 456         *((SEGPTR *)stack - 1) = call16_ret_addr;
 457         cbArgs += sizeof(SEGPTR);
 458
 459         /*
 460          * Actually, we should take care whether the called routine cleans up
 461          * its stack or not.  Fortunately, our wine_call_to_16 core doesn't rely on
 462          * the callee to do so; after the routine has returned, the 16-bit
 463          * stack pointer is always reset to the position it had before.
 464          */
 465         _EnterWin16Lock();
 466         ret = wine_call_to_16( (FARPROC16)vpfn16, cbArgs, call16_handler );
 467         if (pdwRetCode) *pdwRetCode = ret;
 468         _LeaveWin16Lock();
 469
 470         if (TRACE_ON(relay))
 471         {
 472             DPRINTF("%04lx:RetFrom16() ss:sp=%04x:%04x retval=%08lx\n",
 473                     GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->cur_stack),
 474                     OFFSETOF(NtCurrentTeb()->cur_stack), ret);
 475             SYSLEVEL_CheckNotLevel( 2 );
 476         }
 477     }
 478 #else
 479     assert(0);  /* cannot call to 16-bit on non-Intel architectures */
 480 #endif  /* __i386__ */
 481
 482     return TRUE;  /* success */
 483 }
 484
 485 /**********************************************************************
 486  *           K32WOWCallback16            (KERNEL32.54)
 487  */
 488 DWORD WINAPI K32WOWCallback16( DWORD vpfn16, DWORD dwParam )
 489 {
 490     DWORD ret;
 491
 492     if ( !K32WOWCallback16Ex( vpfn16, WCB16_PASCAL,
 493                            sizeof(DWORD), &dwParam, &ret ) )
 494         ret = 0L;
 495
 496     return ret;
 497 }
 498
 499
 500 /*
 501  *  16-bit WOW routines (in KERNEL)
 502  */
 503
 504 /**********************************************************************
 505  *           GetVDMPointer32W      (KERNEL.516)
 506  */
 507 DWORD WINAPI GetVDMPointer32W16( SEGPTR vp, UINT16 fMode )
 508 {
 509     GlobalPageLock16(GlobalHandle16(SELECTOROF(vp)));
 510     return (DWORD)K32WOWGetVDMPointer( vp, 0, (DWORD)fMode );
 511 }
 512
 513 /***********************************************************************
 514  *           LoadLibraryEx32W      (KERNEL.513)
 515  */
 516 DWORD WINAPI LoadLibraryEx32W16( LPCSTR lpszLibFile, DWORD hFile, DWORD dwFlags )
 517 {
 518     HMODULE hModule;
 519     DOS_FULL_NAME full_name;
 520     DWORD mutex_count;
 521     UNICODE_STRING libfileW;
 522     LPCWSTR filenameW;
 523     static const WCHAR dllW[] = {'.','D','L','L',0};
 524
 525     if (!lpszLibFile)
 526     {
 527         SetLastError(ERROR_INVALID_PARAMETER);
 528         return 0;
 529     }
 530
 531     if (!RtlCreateUnicodeStringFromAsciiz(&libfileW, lpszLibFile))
 532     {
 533         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 534         return 0;
 535     }
 536
 537     /* if the file can not be found, call LoadLibraryExA anyway, since it might be
 538        a buildin module. This case is handled in MODULE_LoadLibraryExA */
 539
 540     filenameW = libfileW.Buffer;
 541     if ( DIR_SearchPath( NULL, filenameW, dllW, &full_name, FALSE ) )
 542         filenameW = full_name.short_name;
 543
 544     ReleaseThunkLock( &mutex_count );
 545     hModule = LoadLibraryExW( filenameW, (HANDLE)hFile, dwFlags );
 546     RestoreThunkLock( mutex_count );
 547
 548     RtlFreeUnicodeString(&libfileW);
 549
 550     return (DWORD)hModule;
 551 }
 552
 553 /***********************************************************************
 554  *           GetProcAddress32W     (KERNEL.515)
 555  */
 556 DWORD WINAPI GetProcAddress32W16( DWORD hModule, LPCSTR lpszProc )
 557 {
 558     return (DWORD)GetProcAddress( (HMODULE)hModule, lpszProc );
 559 }
 560
 561 /***********************************************************************
 562  *           FreeLibrary32W        (KERNEL.514)
 563  */
 564 DWORD WINAPI FreeLibrary32W16( DWORD hLibModule )
 565 {
 566     BOOL retv;
 567     DWORD mutex_count;
 568
 569     ReleaseThunkLock( &mutex_count );
 570     retv = FreeLibrary( (HMODULE)hLibModule );
 571     RestoreThunkLock( mutex_count );
 572     return (DWORD)retv;
 573 }
 574
 575
 576 /**********************************************************************
 577  *           WOW_CallProc32W
 578  */
 579 static DWORD WOW_CallProc32W16( BOOL Ex )
 580 {
 581     DWORD nrofargs, argconvmask;
 582     FARPROC proc32;
 583     DWORD *args, ret;
 584     DWORD mutex_count;
 585     VA_LIST16 valist;
 586     unsigned int i;
 587     int aix;
 588
 589     ReleaseThunkLock( &mutex_count );
 590
 591     VA_START16( valist );
 592     nrofargs    = VA_ARG16( valist, DWORD );
 593     argconvmask = VA_ARG16( valist, DWORD );
 594     proc32      = VA_ARG16( valist, FARPROC );
 595     TRACE("(%ld,%ld,%p, Ex%d args[",nrofargs,argconvmask,proc32,Ex);
 596     args = (DWORD*)HeapAlloc( GetProcessHeap(), 0, sizeof(DWORD)*nrofargs );
 597     if(args == NULL) proc32 = NULL; /* maybe we should WARN here? */
 598     /* CallProcEx doesn't need its args reversed */
 599     for (i=0;i<nrofargs;i++) {
 600             if (Ex) {
 601                aix = i;
 602             } else {
 603                aix = nrofargs - i - 1;
 604             }
 605             if (argconvmask & (1<<i))
 606             {
 607                 SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 608                 if (args) args[aix] = (DWORD)MapSL(ptr);
 609                 if (TRACE_ON(thunk)) DPRINTF("%08lx(%p),",ptr,MapSL(ptr));
 610             }
 611             else
 612             {
 613                 DWORD arg = VA_ARG16( valist, DWORD );
 614                 if (args) args[aix] = arg;
 615                 if (TRACE_ON(thunk)) DPRINTF("%ld,", arg);
 616             }
 617     }
 618     if (TRACE_ON(thunk)) DPRINTF("])\n");
 619     VA_END16( valist );
 620
 621     /*
 622      * FIXME:  If ( nrofargs & CPEX_DEST_CDECL ) != 0, we should call a
 623      *         32-bit CDECL routine ...
 624      */
 625
 626     if (!proc32) ret = 0;
 627     else switch (nrofargs)
 628     {
 629     case 0: ret = proc32();
 630             break;
 631     case 1: ret = proc32(args[0]);
 632             break;
 633     case 2: ret = proc32(args[0],args[1]);
 634             break;
 635     case 3: ret = proc32(args[0],args[1],args[2]);
 636             break;
 637     case 4: ret = proc32(args[0],args[1],args[2],args[3]);
 638             break;
 639     case 5: ret = proc32(args[0],args[1],args[2],args[3],args[4]);
 640             break;
 641     case 6: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5]);
 642             break;
 643     case 7: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
 644             break;
 645     case 8: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
 646             break;
 647     case 9: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
 648             break;
 649     case 10:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
 650             break;
 651     case 11:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
 652             break;
 653     case 12:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
 654             break;
 655     case 13:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
 656             break;
 657     case 14:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
 658             break;
 659     case 15:ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
 660             break;
 661     default:
 662             /* FIXME: should go up to 32  arguments */
 663             ERR("Unsupported number of arguments %ld, please report.\n",nrofargs);
 664             ret = 0;
 665             break;
 666     }
 667
 668     /* POP nrofargs DWORD arguments and 3 DWORD parameters */
 669     if (!Ex) stack16_pop( (3 + nrofargs) * sizeof(DWORD) );
 670
 671     TRACE("returns %08lx\n",ret);
 672     HeapFree( GetProcessHeap(), 0, args );
 673
 674     RestoreThunkLock( mutex_count );
 675     return ret;
 676 }
 677
 678 /**********************************************************************
 679  *           CallProc32W           (KERNEL.517)
 680  *
 681  * DWORD PASCAL CallProc32W( DWORD p1, ... , DWORD lpProcAddress,
 682  *                           DWORD fAddressConvert, DWORD cParams );
 683  */
 684 DWORD WINAPI CallProc32W16( void )
 685 {
 686     return WOW_CallProc32W16( FALSE );
 687 }
 688
 689 /**********************************************************************
 690  *           _CallProcEx32W         (KERNEL.518)
 691  *
 692  * DWORD CallProcEx32W( DWORD cParams, DWORD fAddressConvert,
 693  *                      DWORD lpProcAddress, DWORD p1, ... );
 694  */
 695 DWORD WINAPI CallProcEx32W16( void )
 696 {
 697     return WOW_CallProc32W16( TRUE );
 698 }
 699
 700
 701 /**********************************************************************
 702  *           WOW16Call               (KERNEL.500)
 703  *
 704  * FIXME!!!
 705  *
 706  */
 707 DWORD WINAPI WOW16Call(WORD x,WORD y,WORD z)
 708 {
 709         int     i;
 710         DWORD   calladdr;
 711         VA_LIST16 args;
 712         FIXME("(0x%04x,0x%04x,%d),calling (",x,y,z);
 713
 714         VA_START16(args);
 715         for (i=0;i<x/2;i++) {
 716                 WORD    a = VA_ARG16(args,WORD);
 717                 DPRINTF("%04x ",a);
 718         }
 719         calladdr = VA_ARG16(args,DWORD);
 720         VA_END16(args);
 721         stack16_pop( x + sizeof(DWORD) );
 722         DPRINTF(") calling address was 0x%08lx\n",calladdr);
 723         return 0;
 724 }
 725
 726
 727 /***********************************************************************
 728  *           CreateThread16   (KERNEL.441)
 729  */
 730 HANDLE WINAPI CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
 731                               FARPROC16 start, SEGPTR param,
 732                               DWORD flags, LPDWORD id )
 733 {
 734     struct thread_args *args = HeapAlloc( GetProcessHeap(), 0, sizeof(*args) );
 735     if (!args) return INVALID_HANDLE_VALUE;
 736     args->proc = start;
 737     args->param = param;
 738     return CreateThread( sa, stack, start_thread16, args, flags, id );
 739 }