git.oblomov.eu Git - wine/blob - if1632/thunk.c

   1 /*
   2  * Emulator thunks
   3  *
   4  * Copyright 1996, 1997 Alexandre Julliard
   5  * Copyright 1998       Ulrich Weigand
   6  */
   7
   8 #include <string.h>
   9 #include "wine/winbase16.h"
  10 #include "task.h"
  11 #include "hook.h"
  12 #include "callback.h"
  13 #include "builtin16.h"
  14 #include "user.h"
  15 #include "heap.h"
  16 #include "neexe.h"
  17 #include "process.h"
  18 #include "stackframe.h"
  19 #include "win.h"
  20 #include "flatthunk.h"
  21 #include "mouse.h"
  22 #include "keyboard.h"
  23 #include "debugtools.h"
  24
  25 DECLARE_DEBUG_CHANNEL(relay)
  26 DECLARE_DEBUG_CHANNEL(system)
  27 DECLARE_DEBUG_CHANNEL(thunk)
  28
  29
  30 extern LONG CALLBACK CallTo16RegisterShort(const CONTEXT86 *context, INT offset);
  31 extern LONG CALLBACK CallTo16RegisterLong(const CONTEXT86 *context, INT offset);
  32
  33 /* List of the 16-bit callback functions. This list is used  */
  34 /* by the build program to generate the file if1632/callto16.S */
  35
  36 /* ### start build ### */
  37 extern WORD CALLBACK THUNK_CallTo16_word_     (FARPROC16);
  38 extern LONG CALLBACK THUNK_CallTo16_long_     (FARPROC16);
  39 extern WORD CALLBACK THUNK_CallTo16_word_w    (FARPROC16,WORD);
  40 extern WORD CALLBACK THUNK_CallTo16_word_l    (FARPROC16,LONG);
  41 extern LONG CALLBACK THUNK_CallTo16_long_l    (FARPROC16,LONG);
  42 extern WORD CALLBACK THUNK_CallTo16_word_ww   (FARPROC16,WORD,WORD);
  43 extern WORD CALLBACK THUNK_CallTo16_word_wl   (FARPROC16,WORD,LONG);
  44 extern WORD CALLBACK THUNK_CallTo16_word_ll   (FARPROC16,LONG,LONG);
  45 extern LONG CALLBACK THUNK_CallTo16_long_ll   (FARPROC16,LONG,LONG);
  46 extern WORD CALLBACK THUNK_CallTo16_word_www  (FARPROC16,WORD,WORD,WORD);
  47 extern WORD CALLBACK THUNK_CallTo16_word_wwl  (FARPROC16,WORD,WORD,LONG);
  48 extern WORD CALLBACK THUNK_CallTo16_word_wlw  (FARPROC16,WORD,LONG,WORD);
  49 extern LONG CALLBACK THUNK_CallTo16_long_wwl  (FARPROC16,WORD,WORD,LONG);
  50 extern LONG CALLBACK THUNK_CallTo16_long_lll  (FARPROC16,LONG,LONG,LONG);
  51 extern WORD CALLBACK THUNK_CallTo16_word_llwl (FARPROC16,LONG,LONG,WORD,LONG);
  52 extern WORD CALLBACK THUNK_CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG);
  53 extern WORD CALLBACK THUNK_CallTo16_word_lwww (FARPROC16,LONG,WORD,WORD,WORD);
  54 extern WORD CALLBACK THUNK_CallTo16_word_wlww (FARPROC16,WORD,LONG,WORD,WORD);
  55 extern WORD CALLBACK THUNK_CallTo16_word_wwll (FARPROC16,WORD,WORD,LONG,LONG);
  56 extern WORD CALLBACK THUNK_CallTo16_word_wwwl (FARPROC16,WORD,WORD,WORD,LONG);
  57 extern LONG CALLBACK THUNK_CallTo16_long_wwwl (FARPROC16,WORD,WORD,WORD,LONG);
  58 extern WORD CALLBACK THUNK_CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG);
  59 extern LONG CALLBACK THUNK_CallTo16_long_llll (FARPROC16,LONG,LONG,LONG,LONG);
  60 extern WORD CALLBACK THUNK_CallTo16_word_wllwl(FARPROC16,WORD,LONG,LONG,WORD,LONG);
  61 extern WORD CALLBACK THUNK_CallTo16_word_lwwww(FARPROC16,LONG,WORD,WORD,WORD,WORD);
  62 extern LONG CALLBACK THUNK_CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
  63 extern WORD CALLBACK THUNK_CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG);
  64 extern WORD CALLBACK THUNK_CallTo16_word_wwwww(FARPROC16,WORD,WORD,WORD,WORD,WORD);
  65 extern WORD CALLBACK THUNK_CallTo16_word_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  66 extern LONG CALLBACK THUNK_CallTo16_long_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
  67 extern LONG CALLBACK THUNK_CallTo16_long_lllll(FARPROC16,LONG,LONG,LONG,LONG,LONG);
  68 extern LONG CALLBACK THUNK_CallTo16_long_llllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,LONG);
  69 extern LONG CALLBACK THUNK_CallTo16_long_lllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,LONG,LONG);
  70 extern WORD CALLBACK THUNK_CallTo16_word_llwwlll(FARPROC16,LONG,LONG,WORD,WORD,LONG,LONG,LONG);
  71 extern LONG CALLBACK THUNK_CallTo16_word_lwwlllll(FARPROC16,LONG,WORD,WORD,LONG,LONG,
  72                                                   LONG,LONG,LONG);
  73 extern LONG CALLBACK THUNK_CallTo16_long_llllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
  74                                                   LONG,LONG,LONG);
  75 extern LONG CALLBACK THUNK_CallTo16_long_lllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  76                                                    LONG,LONG,LONG,LONG,LONG);
  77 extern LONG CALLBACK THUNK_CallTo16_long_llllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  78                                                     LONG,LONG,LONG,LONG,LONG,LONG);
  79 extern LONG CALLBACK THUNK_CallTo16_long_lllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  80                                                      LONG,LONG,LONG,LONG,LONG,LONG,
  81                                                      LONG);
  82 extern LONG CALLBACK THUNK_CallTo16_long_llllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  83                                                       LONG,LONG,LONG,LONG,LONG,LONG,
  84                                                       LONG,LONG);
  85 extern LONG CALLBACK THUNK_CallTo16_long_lwwllwlllllw(FARPROC16,LONG,WORD,WORD,LONG,
  86                                                       LONG,WORD,LONG,LONG,LONG,LONG,
  87                                                       LONG,WORD);
  88 extern LONG CALLBACK THUNK_CallTo16_long_lllllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
  89                                                        LONG,LONG,LONG,LONG,LONG,LONG,
  90                                                        LONG,LONG,LONG);
  91 extern LONG CALLBACK THUNK_CallTo16_long_llllllllllllll(FARPROC16,LONG,LONG,LONG,
  92                                                         LONG,LONG,LONG,LONG,LONG,
  93                                                         LONG,LONG,LONG,LONG,LONG,
  94                                                         LONG);
  95 extern LONG CALLBACK THUNK_CallTo16_word_lwwwwlwwwwllll(FARPROC16,LONG,WORD,WORD,
  96                                                         WORD,WORD,LONG,WORD,WORD,
  97                                                         WORD,WORD,LONG,LONG,LONG,
  98                                                         LONG);
  99 extern LONG CALLBACK THUNK_CallTo16_long_lllllllllllllll(FARPROC16,LONG,LONG,LONG,
 100                                                          LONG,LONG,LONG,LONG,LONG,
 101                                                          LONG,LONG,LONG,LONG,LONG,
 102                                                          LONG,LONG);
 103 extern LONG CALLBACK THUNK_CallTo16_long_llllllllllllllll(FARPROC16,LONG,LONG,LONG,
 104                                                           LONG,LONG,LONG,LONG,LONG,
 105                                                           LONG,LONG,LONG,LONG,LONG,
 106                                                           LONG,LONG,LONG);
 107 extern void CALLBACK THUNK_CallFrom16_p_long_wwwll();
 108 /* ### stop build ### */
 109
 110
 111 typedef void (*RELAY)();
 112
 113 #include "pshpack1.h"
 114
 115 typedef struct tagTHUNK
 116 {
 117     BYTE             popl_eax;           /* 0x58  popl  %eax (return address)*/
 118     BYTE             pushl_func;         /* 0x68  pushl $proc */
 119     FARPROC        proc WINE_PACKED;
 120     BYTE             pushl_eax;          /* 0x50  pushl %eax */
 121     BYTE             jmp;                /* 0xe9  jmp   relay (relative jump)*/
 122     RELAY            relay WINE_PACKED;
 123     struct tagTHUNK *next WINE_PACKED;
 124 } THUNK;
 125
 126 #include "poppack.h"
 127
 128 #define DECL_THUNK(aname,aproc,arelay) \
 129     THUNK aname; \
 130     aname.popl_eax = 0x58; \
 131     aname.pushl_func = 0x68; \
 132     aname.proc = (FARPROC) (aproc); \
 133     aname.pushl_eax = 0x50; \
 134     aname.jmp = 0xe9; \
 135     aname.relay = (RELAY)((char *)(arelay) - (char *)(&(aname).next)); \
 136     aname.next = NULL;
 137
 138 static THUNK *firstThunk = NULL;
 139
 140 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 141                                            UINT16 msg, WPARAM16 wParam,
 142                                            LPARAM lParam );
 143 static BOOL WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
 144                                             LPVOID,LPDWORD );
 145 static BOOL THUNK_ThunkletInit( void );
 146
 147 /* Callbacks function table for the emulator */
 148 static const CALLBACKS_TABLE CALLBACK_EmulatorTable =
 149 {
 150     (void *)CallTo16RegisterShort,               /* CallRegisterShortProc */
 151     (void *)CallTo16RegisterLong,                /* CallRegisterLongProc */
 152     (void*)THUNK_CallFrom16_p_long_wwwll,        /* CallFrom16WndProc */
 153     THUNK_CallWndProc16,                         /* CallWndProc */
 154     (void *)THUNK_CallTo16_long_lwwll,           /* CallDriverProc */
 155     (void *)THUNK_CallTo16_word_wwlll,           /* CallDriverCallback */
 156     (void *)THUNK_CallTo16_word_wwlll,           /* CallTimeFuncProc */
 157     (void *)THUNK_CallTo16_word_w,               /* CallWindowsExitProc */
 158     (void *)THUNK_CallTo16_word_lwww,            /* CallWordBreakProc */
 159     (void *)THUNK_CallTo16_word_ww,              /* CallBootAppProc */
 160     (void *)THUNK_CallTo16_word_www,             /* CallLoadAppSegProc */
 161     (void *)THUNK_CallTo16_word_www,             /* CallLocalNotifyFunc */
 162     (void *)THUNK_CallTo16_word_www,             /* CallResourceHandlerProc */
 163     (void *)THUNK_CallTo16_long_l,               /* CallWOWCallbackProc */
 164     THUNK_WOWCallback16Ex,                       /* CallWOWCallback16Ex */
 165     (void *)THUNK_CallTo16_long_ll,              /* CallUTProc */
 166     (void *)THUNK_CallTo16_long_l,               /* CallASPIPostProc */
 167     (void *)THUNK_CallTo16_word_lwll,            /* CallDrvControlProc */
 168     (void *)THUNK_CallTo16_word_lwlll,           /* CallDrvEnableProc */
 169     (void *)THUNK_CallTo16_word_llll,            /* CallDrvEnumDFontsProc */
 170     (void *)THUNK_CallTo16_word_lwll,            /* CallDrvEnumObjProc */
 171     (void *)THUNK_CallTo16_word_lwwlllll,        /* CallDrvOutputProc */
 172     (void *)THUNK_CallTo16_long_lwlll,           /* CallDrvRealizeProc */
 173     (void *)THUNK_CallTo16_word_lwwwwlwwwwllll,  /* CallDrvStretchBltProc */
 174     (void *)THUNK_CallTo16_long_lwwllwlllllw,    /* CallDrvExtTextOutProc */
 175     (void *)THUNK_CallTo16_word_llwwlll,         /* CallDrvGetCharWidth */
 176     (void *)THUNK_CallTo16_word_ww               /* CallDrvAbortProc */
 177 };
 178
 179 const CALLBACKS_TABLE *Callbacks = &CALLBACK_EmulatorTable;
 180
 181 CALLOUT_TABLE Callout = { 0 };
 182
 183
 184 /***********************************************************************
 185  *           THUNK_Init
 186  */
 187 BOOL THUNK_Init(void)
 188 {
 189     /* Initialize Thunklets */
 190     return THUNK_ThunkletInit();
 191 }
 192
 193 /***********************************************************************
 194  *           THUNK_Alloc
 195  */
 196 static THUNK *THUNK_Alloc( FARPROC func, RELAY relay )
 197 {
 198     THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) );
 199     if (thunk)
 200     {
 201         thunk->popl_eax   = 0x58;
 202         thunk->pushl_func = 0x68;
 203         thunk->proc       = func;
 204         thunk->pushl_eax  = 0x50;
 205         thunk->jmp        = 0xe9;
 206         thunk->relay      = (RELAY)((char *)relay - (char *)(&thunk->next));
 207         thunk->next       = firstThunk;
 208         firstThunk = thunk;
 209     }
 210     return thunk;
 211 }
 212
 213
 214 /***********************************************************************
 215  *           THUNK_Find
 216  */
 217 static THUNK *THUNK_Find( FARPROC func )
 218 {
 219     THUNK *thunk = firstThunk;
 220     while (thunk && (thunk->proc != func)) thunk = thunk->next;
 221     return thunk;
 222 }
 223
 224
 225 /***********************************************************************
 226  *           THUNK_Free
 227  */
 228 static void THUNK_Free( THUNK *thunk )
 229 {
 230     if (HEAP_IsInsideHeap( GetProcessHeap(), 0, thunk ))
 231     {
 232         THUNK **prev = &firstThunk;
 233         while (*prev && (*prev != thunk)) prev = &(*prev)->next;
 234         if (*prev)
 235         {
 236             *prev = thunk->next;
 237             HeapFree( GetProcessHeap(), 0, thunk );
 238             return;
 239         }
 240     }
 241     ERR_(thunk)("invalid thunk addr %p\n", thunk );
 242 }
 243
 244
 245 /***********************************************************************
 246  *           THUNK_CallWndProc16
 247  *
 248  * Call a 16-bit window procedure
 249  */
 250 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
 251                                            UINT16 msg, WPARAM16 wParam,
 252                                            LPARAM lParam )
 253 {
 254     CONTEXT86 context;
 255     LRESULT ret;
 256     WORD *args;
 257     WND *wndPtr = WIN_FindWndPtr( hwnd );
 258     DWORD offset = 0;
 259     TEB *teb = NtCurrentTeb();
 260     int iWndsLocks;
 261
 262     /* Window procedures want ax = hInstance, ds = es = ss */
 263
 264     memset(&context, '\0', sizeof(context));
 265     DS_reg(&context)  = SELECTOROF(teb->cur_stack);
 266     ES_reg(&context)  = DS_reg(&context);
 267     EAX_reg(&context) = wndPtr ? wndPtr->hInstance : DS_reg(&context);
 268     CS_reg(&context)  = SELECTOROF(proc);
 269     EIP_reg(&context) = OFFSETOF(proc);
 270     EBP_reg(&context) = OFFSETOF(teb->cur_stack)
 271                         + (WORD)&((STACK16FRAME*)0)->bp;
 272
 273     WIN_ReleaseWndPtr(wndPtr);
 274
 275     if (lParam)
 276     {
 277         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
 278            work if structures passed in lParam are placed in the stack/data
 279            segment. Programmers easily make the mistake of converting lParam
 280            to a near rather than a far pointer, since Windows apparently
 281            allows this. We copy the structures to the 16 bit stack; this is
 282            ugly but makes these programs work. */
 283         switch (msg)
 284         {
 285           case WM_CREATE:
 286           case WM_NCCREATE:
 287             offset = sizeof(CREATESTRUCT16); break;
 288           case WM_DRAWITEM:
 289             offset = sizeof(DRAWITEMSTRUCT16); break;
 290           case WM_COMPAREITEM:
 291             offset = sizeof(COMPAREITEMSTRUCT16); break;
 292         }
 293         if (offset)
 294         {
 295             void *s = PTR_SEG_TO_LIN(lParam);
 296             lParam = stack16_push( offset );
 297             memcpy( PTR_SEG_TO_LIN(lParam), s, offset );
 298         }
 299     }
 300
 301     iWndsLocks = WIN_SuspendWndsLock();
 302
 303     args = (WORD *)THREAD_STACK16(teb) - 5;
 304     args[0] = LOWORD(lParam);
 305     args[1] = HIWORD(lParam);
 306     args[2] = wParam;
 307     args[3] = msg;
 308     args[4] = hwnd;
 309
 310     ret = CallTo16RegisterShort( &context, 5 * sizeof(WORD) );
 311     if (offset) stack16_pop( offset );
 312
 313     WIN_RestoreWndsLock(iWndsLocks);
 314
 315     return ret;
 316 }
 317
 318
 319 /***********************************************************************
 320  *           THUNK_EnumObjects16   (GDI.71)
 321  */
 322 INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
 323                                   GOBJENUMPROC16 func, LPARAM lParam )
 324 {
 325     DECL_THUNK( thunk, func, THUNK_CallTo16_word_ll );
 326     return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam );
 327 }
 328
 329
 330 /*************************************************************************
 331  *           THUNK_EnumFonts16   (GDI.70)
 332  */
 333 INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
 334                                 FONTENUMPROC16 func, LPARAM lParam )
 335 {
 336     DECL_THUNK( thunk, func, THUNK_CallTo16_word_llwl );
 337     return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam );
 338 }
 339
 340 /******************************************************************
 341  *           THUNK_EnumMetaFile16   (GDI.175)
 342  */
 343 BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
 344                                     MFENUMPROC16 func, LPARAM lParam )
 345 {
 346     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wllwl );
 347     return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam );
 348 }
 349
 350
 351 /*************************************************************************
 352  *           THUNK_EnumFontFamilies16   (GDI.330)
 353  */
 354 INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
 355                                        FONTENUMPROC16 func, LPARAM lParam )
 356 {
 357     DECL_THUNK( thunk, func, THUNK_CallTo16_word_llwl );
 358     return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
 359 }
 360
 361
 362 /*************************************************************************
 363  *           THUNK_EnumFontFamiliesEx16   (GDI.613)
 364  */
 365 INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
 366                                          FONTENUMPROCEX16 func, LPARAM lParam,
 367                                          DWORD reserved )
 368 {
 369     DECL_THUNK( thunk, func, THUNK_CallTo16_word_llwl );
 370     return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk,
 371                                  lParam, reserved );
 372 }
 373
 374
 375 /**********************************************************************
 376  *           THUNK_LineDDA16   (GDI.100)
 377  */
 378 void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
 379                              INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam )
 380 {
 381     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wwl );
 382     LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam );
 383 }
 384
 385
 386 /*******************************************************************
 387  *           THUNK_EnumWindows16   (USER.54)
 388  */
 389 BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
 390 {
 391     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wl );
 392     return EnumWindows16( (WNDENUMPROC16)&thunk, lParam );
 393 }
 394
 395
 396 /**********************************************************************
 397  *           THUNK_EnumChildWindows16   (USER.55)
 398  */
 399 BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
 400                                         LPARAM lParam )
 401 {
 402     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wl );
 403     return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam );
 404 }
 405
 406
 407 /**********************************************************************
 408  *           THUNK_EnumTaskWindows16   (USER.225)
 409  */
 410 BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
 411                                        LPARAM lParam )
 412 {
 413     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wl );
 414     return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam );
 415 }
 416
 417
 418 /***********************************************************************
 419  *           THUNK_EnumProps16   (USER.27)
 420  */
 421 INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 422 {
 423     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wlw );
 424     return EnumProps16( hwnd, (PROPENUMPROC16)&thunk );
 425 }
 426
 427
 428 /***********************************************************************
 429  *           THUNK_GrayString16   (USER.185)
 430  */
 431 BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr,
 432                                   GRAYSTRINGPROC16 func, LPARAM lParam,
 433                                   INT16 cch, INT16 x, INT16 y,
 434                                   INT16 cx, INT16 cy )
 435 {
 436     DECL_THUNK( thunk, func, THUNK_CallTo16_word_wlw );
 437     if (!func)
 438         return GrayString16( hdc, hbr, NULL, lParam, cch, x, y, cx, cy );
 439     else
 440         return GrayString16( hdc, hbr, (GRAYSTRINGPROC16)&thunk, lParam, cch,
 441                              x, y, cx, cy );
 442 }
 443
 444
 445 /***********************************************************************
 446  *           THUNK_SetWindowsHook16   (USER.121)
 447  */
 448 FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
 449 {
 450     HINSTANCE16 hInst = FarGetOwner16( HIWORD(proc) );
 451     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
 452     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)THUNK_CallTo16_long_wwl );
 453     if (!thunk) return 0;
 454     return (FARPROC16)SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask);
 455 }
 456
 457
 458 /***********************************************************************
 459  *           THUNK_UnhookWindowsHook16   (USER.234)
 460  */
 461 BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
 462 {
 463     BOOL16 ret;
 464     THUNK *thunk = THUNK_Find( (FARPROC16)proc );
 465     if (!thunk) return FALSE;
 466     ret = UnhookWindowsHook16( id, (HOOKPROC16)thunk );
 467     THUNK_Free( thunk );
 468     return ret;
 469 }
 470
 471
 472 /***********************************************************************
 473  *           THUNK_SetWindowsHookEx16   (USER.291)
 474  */
 475 HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc,
 476                                        HINSTANCE16 hInst, HTASK16 hTask )
 477 {
 478     THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)THUNK_CallTo16_long_wwl );
 479     if (!thunk) return 0;
 480     return SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask );
 481 }
 482
 483
 484 /***********************************************************************
 485  *           THUNK_UnhookWindowHookEx16   (USER.292)
 486  */
 487 BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook )
 488 {
 489     THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook );
 490     BOOL16 ret = UnhookWindowsHookEx16( hhook );
 491     if (thunk) THUNK_Free( thunk );
 492     return ret;
 493 }
 494
 495
 496
 497 static FARPROC16 defDCHookProc = NULL;
 498
 499 /***********************************************************************
 500  *           THUNK_SetDCHook   (GDI.190)
 501  */
 502 BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
 503 {
 504     THUNK *thunk, *oldThunk;
 505
 506     if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 507     {
 508         HMODULE16 hModule = GetModuleHandle16( "USER" );
 509         NE_MODULE *pModule = NE_GetPtr( hModule );
 510
 511         if ( pModule && (pModule->flags & NE_FFLAGS_BUILTIN) )
 512             defDCHookProc = NE_GetEntryPoint( hModule, 362 );
 513         else
 514             defDCHookProc = (FARPROC16)-1;
 515     }
 516
 517     if (!proc)
 518         thunk = NULL;
 519     else if (proc != defDCHookProc)
 520     {
 521         thunk = THUNK_Alloc( proc, (RELAY)THUNK_CallTo16_word_wwll );
 522         if (!thunk) return FALSE;
 523     }
 524     else thunk = (THUNK *)DCHook16;
 525
 526     /* Free the previous thunk */
 527     GetDCHook( hdc, (FARPROC16 *)&oldThunk );
 528     if (oldThunk && (oldThunk != (THUNK *)DCHook16)) THUNK_Free( oldThunk );
 529
 530     return SetDCHook( hdc, (FARPROC16)thunk, dwHookData );
 531 }
 532
 533
 534 /***********************************************************************
 535  *           THUNK_GetDCHook   (GDI.191)
 536  */
 537 DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
 538 {
 539     THUNK *thunk = NULL;
 540     DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
 541     if (thunk)
 542     {
 543         if (thunk == (THUNK *)DCHook16)
 544         {
 545             /* Note: we can only get here when running built-in USER */
 546
 547             if (!defDCHookProc)  /* Get DCHook Win16 entry point */
 548                 defDCHookProc = NE_GetEntryPoint(GetModuleHandle16("USER"),362);
 549
 550             *phookProc = defDCHookProc;
 551         }
 552         else *phookProc = thunk->proc;
 553     }
 554     return ret;
 555 }
 556
 557
 558 /***********************************************************************
 559  *           THUNK_SetTaskSignalProc (KERNEL.38)
 560  */
 561 FARPROC16 WINAPI THUNK_SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
 562 {
 563     THUNK *thunk = THUNK_Alloc( proc, (RELAY)THUNK_CallTo16_word_wwwww );
 564     if ( !thunk ) return NULL;
 565
 566     thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)thunk );
 567     if ( !thunk ) return NULL;
 568
 569     proc = thunk->proc;
 570     THUNK_Free( thunk );
 571     return proc;
 572 }
 573
 574 /***********************************************************************
 575  *           THUNK_CreateThread16   (KERNEL.441)
 576  */
 577 static DWORD CALLBACK THUNK_StartThread16( LPVOID threadArgs )
 578 {
 579     FARPROC16 start = ((FARPROC16 *)threadArgs)[0];
 580     DWORD     param = ((DWORD *)threadArgs)[1];
 581     HeapFree( GetProcessHeap(), 0, threadArgs );
 582
 583     return THUNK_CallTo16_long_l( start, param );
 584 }
 585 HANDLE WINAPI THUNK_CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
 586                                       FARPROC16 start, SEGPTR param,
 587                                       DWORD flags, LPDWORD id )
 588 {
 589     DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
 590     if (!threadArgs) return INVALID_HANDLE_VALUE;
 591     threadArgs[0] = (DWORD)start;
 592     threadArgs[1] = (DWORD)param;
 593
 594     return CreateThread( sa, stack, THUNK_StartThread16, threadArgs, flags, id );
 595 }
 596
 597 /***********************************************************************
 598  *           THUNK_WOWCallback16Ex      (WOW32.3)(KERNEL32.55)
 599  * Generic thunking routine to call 16 bit functions from 32bit code.
 600  *
 601  * RETURNS
 602  *      TRUE if the call was done
 603  */
 604 static BOOL WINAPI THUNK_WOWCallback16Ex(
 605         FARPROC16 proc,         /* [in] 16bit function to call */
 606         DWORD dwFlags,          /* [in] flags (WCB_*) */
 607         DWORD cbArgs,           /* [in] number of arguments */
 608         LPVOID xargs,           /* [in/out] arguments */
 609         LPDWORD pdwret          /* [out] return value of the 16bit call */
 610 ) {
 611     LPDWORD     args = (LPDWORD)xargs;
 612     DWORD       ret,i;
 613
 614     TRACE_(relay)("(%p,0x%08lx,%ld,%p,%p)\n",
 615         proc,dwFlags,cbArgs,xargs,pdwret
 616     );
 617     if (dwFlags == WCB16_CDECL) {
 618         /* swap the arguments */
 619         args = HeapAlloc(GetProcessHeap(),0,cbArgs*sizeof(DWORD));
 620         for (i=0;i<cbArgs;i++)
 621             args[i] = ((DWORD*)xargs)[cbArgs-i-1];
 622     }
 623     switch (cbArgs) {
 624     case 0: ret = THUNK_CallTo16_long_(proc);break;
 625     case 1: ret = THUNK_CallTo16_long_l(proc,args[0]);break;
 626     case 2: ret = THUNK_CallTo16_long_ll(proc,args[0],args[1]);break;
 627     case 3: ret = THUNK_CallTo16_long_lll(proc,args[0],args[1],args[2]);break;
 628     case 4: ret = THUNK_CallTo16_long_llll(proc,args[0],args[1],args[2],args[3]);
 629             break;
 630     case 5: ret = THUNK_CallTo16_long_lllll(proc,args[0],args[1],args[2],args[3],
 631                 args[4]
 632             );
 633             break;
 634     case 6: ret = THUNK_CallTo16_long_llllll(proc,args[0],args[1],args[2],args[3],
 635                 args[4],args[5]
 636             );
 637             break;
 638     case 7: ret = THUNK_CallTo16_long_lllllll(proc,args[0],args[1],args[2],args[3],
 639                 args[4],args[5],args[6]
 640             );
 641             break;
 642     case 8: ret = THUNK_CallTo16_long_llllllll(proc,args[0],args[1],args[2],args[3],
 643                 args[4],args[5],args[6],args[7]
 644             );
 645             break;
 646     case 9: ret = THUNK_CallTo16_long_lllllllll(proc,args[0],args[1],args[2],args[3],
 647                 args[4],args[5],args[6],args[7],args[8]
 648             );
 649             break;
 650     case 10:ret = THUNK_CallTo16_long_llllllllll(proc,args[0],args[1],args[2],args[3],
 651                 args[4],args[5],args[6],args[7],args[8],args[9]
 652             );
 653             break;
 654     case 11:ret = THUNK_CallTo16_long_lllllllllll(proc,args[0],args[1],args[2],
 655                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]
 656             );
 657             break;
 658     case 12:ret = THUNK_CallTo16_long_llllllllllll(proc,args[0],args[1],args[2],
 659                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 660                 args[10],args[11]
 661             );
 662             break;
 663     case 13:ret = THUNK_CallTo16_long_lllllllllllll(proc,args[0],args[1],args[2],
 664                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 665                 args[10],args[11],args[12]
 666             );
 667             break;
 668     case 14:ret = THUNK_CallTo16_long_llllllllllllll(proc,args[0],args[1],args[2],
 669                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 670                 args[10],args[11],args[12],args[13]
 671             );
 672             break;
 673     case 15:ret = THUNK_CallTo16_long_lllllllllllllll(proc,args[0],args[1],args[2],
 674                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 675                 args[10],args[11],args[12],args[13],args[14]
 676             );
 677             break;
 678     case 16:ret = THUNK_CallTo16_long_llllllllllllllll(proc,args[0],args[1],args[2],
 679                 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
 680                 args[10],args[11],args[12],args[13],args[14],args[15]
 681             );
 682             break;
 683     default:
 684             ERR_(thunk)("%ld arguments not supported.\n",cbArgs);
 685             if (dwFlags == WCB16_CDECL)
 686                 HeapFree(GetProcessHeap(),0,args);
 687             return FALSE;
 688     }
 689     if (dwFlags == WCB16_CDECL)
 690         HeapFree(GetProcessHeap(),0,args);
 691     if (pdwret)
 692         *pdwret = ret;
 693     return TRUE;
 694 }
 695
 696 /***********************************************************************
 697  *           THUNK_MOUSE_Enable   (MOUSE.2)
 698  */
 699 static VOID WINAPI THUNK_CallMouseEventProc( FARPROC16 proc,
 700                                              DWORD dwFlags, DWORD dx, DWORD dy,
 701                                              DWORD cButtons, DWORD dwExtraInfo )
 702 {
 703     CONTEXT86 context;
 704
 705     memset( &context, 0, sizeof(context) );
 706     CS_reg(&context)  = SELECTOROF( proc );
 707     EIP_reg(&context) = OFFSETOF( proc );
 708     AX_reg(&context)  = (WORD)dwFlags;
 709     BX_reg(&context)  = (WORD)dx;
 710     CX_reg(&context)  = (WORD)dy;
 711     DX_reg(&context)  = (WORD)cButtons;
 712     SI_reg(&context)  = LOWORD( dwExtraInfo );
 713     DI_reg(&context)  = HIWORD( dwExtraInfo );
 714
 715     CallTo16RegisterShort( &context, 0 );
 716 }
 717 VOID WINAPI THUNK_MOUSE_Enable( FARPROC16 proc )
 718 {
 719     static THUNK *lastThunk = NULL;
 720     static FARPROC16 lastProc = NULL;
 721
 722     if ( lastProc != proc )
 723     {
 724         if ( lastThunk )
 725             THUNK_Free( lastThunk );
 726
 727         if ( !proc )
 728             lastThunk = NULL;
 729         else
 730             lastThunk = THUNK_Alloc( proc, (RELAY)THUNK_CallMouseEventProc );
 731
 732         lastProc = proc;
 733     }
 734
 735     MOUSE_Enable( (LPMOUSE_EVENT_PROC)lastThunk );
 736 }
 737
 738 /***********************************************************************
 739  *           GetMouseEventProc   (USER.337)
 740  */
 741 FARPROC16 WINAPI GetMouseEventProc16(void)
 742 {
 743     HMODULE16 hmodule = GetModuleHandle16("USER");
 744     return NE_GetEntryPoint( hmodule, NE_GetOrdinal( hmodule, "mouse_event" ));
 745 }
 746
 747
 748 /***********************************************************************
 749  *           WIN16_mouse_event   (USER.299)
 750  */
 751 void WINAPI WIN16_mouse_event( CONTEXT86 *context )
 752 {
 753     mouse_event( AX_reg(context), BX_reg(context), CX_reg(context),
 754                  DX_reg(context), MAKELONG(SI_reg(context), DI_reg(context)) );
 755 }
 756
 757
 758 /***********************************************************************
 759  *           THUNK_KEYBD_Enable   (KEYBOARD.2)
 760  */
 761 static VOID WINAPI THUNK_CallKeybdEventProc( FARPROC16 proc,
 762                                              BYTE bVk, BYTE bScan,
 763                                              DWORD dwFlags, DWORD dwExtraInfo )
 764 {
 765     CONTEXT86 context;
 766
 767     memset( &context, 0, sizeof(context) );
 768     CS_reg(&context)  = SELECTOROF( proc );
 769     EIP_reg(&context) = OFFSETOF( proc );
 770     AH_reg(&context)  = (dwFlags & KEYEVENTF_KEYUP)? 0x80 : 0;
 771     AL_reg(&context)  = bVk;
 772     BH_reg(&context)  = (dwFlags & KEYEVENTF_EXTENDEDKEY)? 1 : 0;
 773     BL_reg(&context)  = bScan;
 774     SI_reg(&context)  = LOWORD( dwExtraInfo );
 775     DI_reg(&context)  = HIWORD( dwExtraInfo );
 776
 777     CallTo16RegisterShort( &context, 0 );
 778 }
 779 VOID WINAPI THUNK_KEYBOARD_Enable( FARPROC16 proc, LPBYTE lpKeyState )
 780 {
 781     static THUNK *lastThunk = NULL;
 782     static FARPROC16 lastProc = NULL;
 783
 784     if ( lastProc != proc )
 785     {
 786         if ( lastThunk )
 787             THUNK_Free( lastThunk );
 788
 789         if ( !proc )
 790             lastThunk = NULL;
 791         else
 792             lastThunk = THUNK_Alloc( proc, (RELAY)THUNK_CallKeybdEventProc );
 793
 794         lastProc = proc;
 795     }
 796
 797     KEYBOARD_Enable( (LPKEYBD_EVENT_PROC)lastThunk, lpKeyState );
 798 }
 799
 800 /***********************************************************************
 801  *           WIN16_keybd_event   (USER.289)
 802  */
 803 void WINAPI WIN16_keybd_event( CONTEXT86 *context )
 804 {
 805     DWORD dwFlags = 0;
 806
 807     if (AH_reg(context) & 0x80) dwFlags |= KEYEVENTF_KEYUP;
 808     if (BH_reg(context) & 1   ) dwFlags |= KEYEVENTF_EXTENDEDKEY;
 809
 810     keybd_event( AL_reg(context), BL_reg(context),
 811                  dwFlags, MAKELONG(SI_reg(context), DI_reg(context)) );
 812 }
 813
 814
 815 /***********************************************************************
 816  *           WIN16_CreateSystemTimer   (SYSTEM.2)
 817  */
 818 static void THUNK_CallSystemTimerProc( FARPROC16 proc, WORD timer )
 819 {
 820     CONTEXT86 context;
 821     memset( &context, '\0', sizeof(context) );
 822
 823     CS_reg( &context )  = SELECTOROF( proc );
 824     EIP_reg( &context ) = OFFSETOF( proc );
 825     EBP_reg( &context ) = OFFSETOF( NtCurrentTeb()->cur_stack )
 826                           + (WORD)&((STACK16FRAME*)0)->bp;
 827
 828     AX_reg( &context ) = timer;
 829
 830     if ( _ConfirmWin16Lock() )
 831     {
 832         FIXME_(system)("Skipping timer %d callback because timer signal "
 833                        "arrived while we own the Win16Lock!\n", timer );
 834         return;
 835     }
 836
 837     CallTo16RegisterShort( &context, 0 );
 838
 839     /* FIXME: This does not work if the signal occurs while this thread
 840               is currently in 16-bit code. With the current structure
 841               of the Wine thunking code, this seems to be hard to fix ... */
 842 }
 843 WORD WINAPI WIN16_CreateSystemTimer( WORD rate, FARPROC16 proc )
 844 {
 845     THUNK *thunk = THUNK_Alloc( proc, (RELAY)THUNK_CallSystemTimerProc );
 846     WORD timer = CreateSystemTimer( rate, (SYSTEMTIMERPROC)thunk );
 847     if (!timer) THUNK_Free( thunk );
 848     return timer;
 849 }
 850
 851 /***********************************************************************
 852  *           THUNK_GetCalloutThunk
 853  *
 854  * Retrieve API entry point with given name from given module.
 855  * If module is builtin, return the 32-bit entry point, otherwise
 856  * create a 32->16 thunk to the 16-bit entry point, using the
 857  * given relay code.
 858  *
 859  */
 860 static FARPROC THUNK_GetCalloutThunk( NE_MODULE *pModule, LPSTR name, RELAY relay )
 861 {
 862     FARPROC16 proc = WIN32_GetProcAddress16( pModule->self, name );
 863     if ( !proc ) return 0;
 864
 865     if ( pModule->flags & NE_FFLAGS_BUILTIN )
 866         return (FARPROC)((ENTRYPOINT16 *)PTR_SEG_TO_LIN( proc ))->target;
 867     else
 868         return (FARPROC)THUNK_Alloc( proc, relay );
 869 }
 870
 871 /***********************************************************************
 872  *           THUNK_InitCallout
 873  */
 874 void THUNK_InitCallout(void)
 875 {
 876     HMODULE hModule;
 877     NE_MODULE *pModule;
 878
 879     hModule = GetModuleHandleA( "USER32" );
 880     if ( hModule )
 881     {
 882 #define GETADDR( var, name )  \
 883         *(FARPROC *)&Callout.##var = GetProcAddress( hModule, name )
 884
 885         GETADDR( PeekMessageA, "PeekMessageA" );
 886         GETADDR( PeekMessageW, "PeekMessageW" );
 887         GETADDR( GetMessageA, "GetMessageA" );
 888         GETADDR( GetMessageW, "GetMessageW" );
 889         GETADDR( SendMessageA, "SendMessageA" );
 890         GETADDR( SendMessageW, "SendMessageW" );
 891         GETADDR( PostMessageA, "PostMessageA" );
 892         GETADDR( PostMessageW, "PostMessageW" );
 893         GETADDR( PostThreadMessageA, "PostThreadMessageA" );
 894         GETADDR( PostThreadMessageW, "PostThreadMessageW" );
 895         GETADDR( TranslateMessage, "TranslateMessage" );
 896         GETADDR( DispatchMessageW, "DispatchMessageW" );
 897         GETADDR( DispatchMessageA, "DispatchMessageA" );
 898         GETADDR( RedrawWindow, "RedrawWindow" );
 899         GETADDR( UserSignalProc, "UserSignalProc" );
 900
 901 #undef GETADDR
 902     }
 903
 904     pModule = NE_GetPtr( GetModuleHandle16( "USER" ) );
 905     if ( pModule )
 906     {
 907 #define GETADDR( var, name, thk )  \
 908         *(FARPROC *)&Callout.##var = THUNK_GetCalloutThunk( pModule, name, \
 909                                                  (RELAY)THUNK_CallTo16_##thk )
 910
 911         GETADDR( PeekMessage16, "PeekMessage", word_lwwww );
 912         GETADDR( GetMessage16, "GetMessage", word_lwww );
 913         GETADDR( SendMessage16, "SendMessage", long_wwwl );
 914         GETADDR( PostMessage16, "PostMessage", word_wwwl );
 915         GETADDR( PostAppMessage16, "PostAppMessage", word_wwwl );
 916         GETADDR( TranslateMessage16, "TranslateMessage", word_l );
 917         GETADDR( DispatchMessage16, "DispatchMessage", long_l );
 918         GETADDR( RedrawWindow16, "RedrawWindow", word_wlww );
 919         GETADDR( FinalUserInit16, "FinalUserInit", word_ );
 920         GETADDR( InitApp16, "InitApp", word_w );
 921         GETADDR( InitThreadInput16, "InitThreadInput", word_ww );
 922         GETADDR( UserYield16, "UserYield", word_ );
 923         GETADDR( DestroyIcon32, "DestroyIcon32", word_ww );
 924
 925 #undef GETADDR
 926     }
 927 }
 928
 929 /***********************************************************************
 930  * 16->32 Flat Thunk routines:
 931  */
 932
 933 /***********************************************************************
 934  *              ThunkConnect16          (KERNEL.651)
 935  * Connects a 32bit and a 16bit thunkbuffer.
 936  */
 937 UINT WINAPI ThunkConnect16(
 938         LPSTR module16,              /* [in] name of win16 dll */
 939         LPSTR module32,              /* [in] name of win32 dll */
 940         HINSTANCE16 hInst16,         /* [in] hInst of win16 dll */
 941         DWORD dwReason,              /* [in] initialisation argument */
 942         struct ThunkDataCommon *TD,  /* [in/out] thunkbuffer */
 943         LPSTR thunkfun32,            /* [in] win32 thunkfunction */
 944         WORD cs                      /* [in] CS of win16 dll */
 945 ) {
 946     BOOL directionSL;
 947
 948     if (!strncmp(TD->magic, "SL01", 4))
 949     {
 950         directionSL = TRUE;
 951
 952         TRACE_(thunk)("SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
 953                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 954     }
 955     else if (!strncmp(TD->magic, "LS01", 4))
 956     {
 957         directionSL = FALSE;
 958
 959         TRACE_(thunk)("LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
 960                      module16, (DWORD)TD, module32, thunkfun32, dwReason);
 961     }
 962     else
 963     {
 964         ERR_(thunk)("Invalid magic %c%c%c%c\n",
 965                    TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
 966         return 0;
 967     }
 968
 969     switch (dwReason)
 970     {
 971         case DLL_PROCESS_ATTACH:
 972             if (directionSL)
 973             {
 974                 struct ThunkDataSL16 *SL16 = (struct ThunkDataSL16 *)TD;
 975                 struct ThunkDataSL   *SL   = SL16->fpData;
 976
 977                 if (SL == NULL)
 978                 {
 979                     SL = HeapAlloc(GetProcessHeap(), 0, sizeof(*SL));
 980
 981                     SL->common   = SL16->common;
 982                     SL->flags1   = SL16->flags1;
 983                     SL->flags2   = SL16->flags2;
 984
 985                     SL->apiDB    = PTR_SEG_TO_LIN(SL16->apiDatabase);
 986                     SL->targetDB = NULL;
 987
 988                     lstrcpynA(SL->pszDll16, module16, 255);
 989                     lstrcpynA(SL->pszDll32, module32, 255);
 990
 991                     /* We should create a SEGPTR to the ThunkDataSL,
 992                        but since the contents are not in the original format,
 993                        any access to this by 16-bit code would crash anyway. */
 994                     SL16->spData = 0;
 995                     SL16->fpData = SL;
 996                 }
 997
 998
 999                 if (SL->flags2 & 0x80000000)
1000                 {
1001                     TRACE_(thunk)("Preloading 32-bit library\n");
1002                     LoadLibraryA(module32);
1003                 }
1004             }
1005             else
1006             {
1007                 /* nothing to do */
1008             }
1009             break;
1010
1011         case DLL_PROCESS_DETACH:
1012             /* FIXME: cleanup */
1013             break;
1014     }
1015
1016     return 1;
1017 }
1018
1019
1020 /***********************************************************************
1021  *           C16ThkSL                           (KERNEL.630)
1022  */
1023
1024 void WINAPI C16ThkSL(CONTEXT86 *context)
1025 {
1026     extern void CallFrom16Thunk(void);
1027     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
1028     WORD cs, ds;
1029     GET_CS(cs);
1030     GET_DS(ds);
1031
1032     /* We produce the following code:
1033      *
1034      *   mov ax, __FLATDS
1035      *   mov es, ax
1036      *   movzx ecx, cx
1037      *   mov edx, es:[ecx + $EDX]
1038      *   push bp
1039      *   push edx
1040      *   call __FLATCS:CallFrom16_t_long_
1041      */
1042
1043     *x++ = 0xB8; *((WORD *)x)++ = ds;
1044     *x++ = 0x8E; *x++ = 0xC0;
1045     *x++ = 0x66; *x++ = 0x0F; *x++ = 0xB7; *x++ = 0xC9;
1046     *x++ = 0x67; *x++ = 0x66; *x++ = 0x26; *x++ = 0x8B;
1047                  *x++ = 0x91; *((DWORD *)x)++ = EDX_reg(context);
1048
1049     *x++ = 0x55;
1050     *x++ = 0x66; *x++ = 0x52;
1051     *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16Thunk;
1052                               *((WORD *)x)++ = cs;
1053
1054     /* Jump to the stub code just created */
1055     EIP_reg(context) = LOWORD(EAX_reg(context));
1056     CS_reg(context)  = HIWORD(EAX_reg(context));
1057
1058     /* Since C16ThkSL got called by a jmp, we need to leave the
1059        original return address on the stack */
1060     ESP_reg(context) -= 4;
1061 }
1062
1063 /***********************************************************************
1064  *           C16ThkSL01                         (KERNEL.631)
1065  */
1066
1067 void WINAPI C16ThkSL01(CONTEXT86 *context)
1068 {
1069     LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
1070
1071     if (stub)
1072     {
1073         struct ThunkDataSL16 *SL16 = PTR_SEG_TO_LIN(EDX_reg(context));
1074         struct ThunkDataSL *td = SL16->fpData;
1075
1076         extern void CallFrom16Thunk(void);
1077         DWORD procAddress = (DWORD)GetProcAddress16(GetModuleHandle16("KERNEL"), 631);
1078         WORD cs;
1079         GET_CS(cs);
1080
1081         if (!td)
1082         {
1083             ERR_(thunk)("ThunkConnect16 was not called!\n");
1084             return;
1085         }
1086
1087         TRACE_(thunk)("Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
1088
1089
1090         /* We produce the following code:
1091          *
1092          *   xor eax, eax
1093          *   mov edx, $td
1094          *   call C16ThkSL01
1095          *   push bp
1096          *   push edx
1097          *   call __FLATCS:CallFrom16_t_long_
1098          */
1099
1100         *x++ = 0x66; *x++ = 0x33; *x++ = 0xC0;
1101         *x++ = 0x66; *x++ = 0xBA; *((DWORD *)x)++ = (DWORD)td;
1102         *x++ = 0x9A; *((DWORD *)x)++ = procAddress;
1103
1104         *x++ = 0x55;
1105         *x++ = 0x66; *x++ = 0x52;
1106         *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16Thunk;
1107                                   *((WORD *)x)++ = cs;
1108
1109         /* Jump to the stub code just created */
1110         EIP_reg(context) = LOWORD(EAX_reg(context));
1111         CS_reg(context)  = HIWORD(EAX_reg(context));
1112
1113         /* Since C16ThkSL01 got called by a jmp, we need to leave the
1114            orginal return address on the stack */
1115         ESP_reg(context) -= 4;
1116     }
1117     else
1118     {
1119         struct ThunkDataSL *td = (struct ThunkDataSL *)EDX_reg(context);
1120         DWORD targetNr = CX_reg(context) / 4;
1121         struct SLTargetDB *tdb;
1122
1123         TRACE_(thunk)("Process %08lx calling target %ld of ThunkDataSL %08lx\n",
1124                      (DWORD)PROCESS_Current(), targetNr, (DWORD)td);
1125
1126         for (tdb = td->targetDB; tdb; tdb = tdb->next)
1127             if (tdb->process == PROCESS_Current())
1128                 break;
1129
1130         if (!tdb)
1131         {
1132             TRACE_(thunk)("Loading 32-bit library %s\n", td->pszDll32);
1133             LoadLibraryA(td->pszDll32);
1134
1135             for (tdb = td->targetDB; tdb; tdb = tdb->next)
1136                 if (tdb->process == PROCESS_Current())
1137                     break;
1138         }
1139
1140         if (tdb)
1141         {
1142             EDX_reg(context) = tdb->targetTable[targetNr];
1143
1144             TRACE_(thunk)("Call target is %08lx\n", EDX_reg(context));
1145         }
1146         else
1147         {
1148             WORD *stack = PTR_SEG_OFF_TO_LIN(SS_reg(context), LOWORD(ESP_reg(context)));
1149             DX_reg(context) = HIWORD(td->apiDB[targetNr].errorReturnValue);
1150             AX_reg(context) = LOWORD(td->apiDB[targetNr].errorReturnValue);
1151             EIP_reg(context) = stack[2];
1152             CS_reg(context)  = stack[3];
1153             ESP_reg(context) += td->apiDB[targetNr].nrArgBytes + 4;
1154
1155             ERR_(thunk)("Process %08lx did not ThunkConnect32 %s to %s\n",
1156                        (DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
1157         }
1158     }
1159 }
1160
1161 DWORD WINAPI
1162 WOW16Call(WORD x,WORD y,WORD z) {
1163         int     i;
1164         DWORD   calladdr;
1165         VA_LIST16 args;
1166         FIXME_(thunk)("(0x%04x,0x%04x,%d),calling (",x,y,z);
1167
1168         VA_START16(args);
1169         for (i=0;i<x/2;i++) {
1170                 WORD    a = VA_ARG16(args,WORD);
1171                 DPRINTF("%04x ",a);
1172         }
1173         calladdr = VA_ARG16(args,DWORD);
1174         VA_END16(args);
1175         stack16_pop( x + sizeof(DWORD) );
1176         DPRINTF(") calling address was 0x%08lx\n",calladdr);
1177         return 0;
1178 }
1179
1180
1181 /***********************************************************************
1182  * 16<->32 Thunklet/Callback API:
1183  */
1184
1185 #include "pshpack1.h"
1186 typedef struct _THUNKLET
1187 {
1188     BYTE        prefix_target;
1189     BYTE        pushl_target;
1190     DWORD       target;
1191
1192     BYTE        prefix_relay;
1193     BYTE        pushl_relay;
1194     DWORD       relay;
1195
1196     BYTE        jmp_glue;
1197     DWORD       glue;
1198
1199     BYTE        type;
1200     HINSTANCE16 owner;
1201     struct _THUNKLET *next;
1202 } THUNKLET;
1203 #include "poppack.h"
1204
1205 #define THUNKLET_TYPE_LS  1
1206 #define THUNKLET_TYPE_SL  2
1207
1208 static HANDLE  ThunkletHeap = 0;
1209 static THUNKLET *ThunkletAnchor = NULL;
1210
1211 static FARPROC ThunkletSysthunkGlueLS = 0;
1212 static SEGPTR    ThunkletSysthunkGlueSL = 0;
1213
1214 static FARPROC ThunkletCallbackGlueLS = 0;
1215 static SEGPTR    ThunkletCallbackGlueSL = 0;
1216
1217 /***********************************************************************
1218  *     THUNK_ThunkletInit
1219  */
1220 static BOOL THUNK_ThunkletInit( void )
1221 {
1222     LPBYTE thunk;
1223
1224     ThunkletHeap = HeapCreate(HEAP_WINE_SEGPTR | HEAP_WINE_CODE16SEG, 0, 0);
1225     if (!ThunkletHeap) return FALSE;
1226
1227     thunk = HeapAlloc( ThunkletHeap, 0, 5 );
1228     if (!thunk) return FALSE;
1229
1230     ThunkletSysthunkGlueLS = (FARPROC)thunk;
1231     *thunk++ = 0x58;                             /* popl eax */
1232     *thunk++ = 0xC3;                             /* ret      */
1233
1234     ThunkletSysthunkGlueSL = HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1235     *thunk++ = 0x66; *thunk++ = 0x58;            /* popl eax */
1236     *thunk++ = 0xCB;                             /* lret     */
1237
1238     return TRUE;
1239 }
1240
1241 /***********************************************************************
1242  *     SetThunkletCallbackGlue             (KERNEL.560)
1243  */
1244 void WINAPI SetThunkletCallbackGlue16( FARPROC glueLS, SEGPTR glueSL )
1245 {
1246     ThunkletCallbackGlueLS = glueLS;
1247     ThunkletCallbackGlueSL = glueSL;
1248 }
1249
1250
1251 /***********************************************************************
1252  *     THUNK_FindThunklet
1253  */
1254 THUNKLET *THUNK_FindThunklet( DWORD target, DWORD relay,
1255                               DWORD glue, BYTE type )
1256 {
1257     THUNKLET *thunk;
1258
1259     for (thunk = ThunkletAnchor; thunk; thunk = thunk->next)
1260         if (    thunk->type   == type
1261              && thunk->target == target
1262              && thunk->relay  == relay
1263              && ( type == THUNKLET_TYPE_LS ?
1264                     ( thunk->glue == glue - (DWORD)&thunk->type )
1265                   : ( thunk->glue == glue ) ) )
1266             return thunk;
1267
1268      return NULL;
1269 }
1270
1271 /***********************************************************************
1272  *     THUNK_AllocLSThunklet
1273  */
1274 FARPROC THUNK_AllocLSThunklet( SEGPTR target, DWORD relay,
1275                                  FARPROC glue, HTASK16 owner )
1276 {
1277     THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
1278                                           THUNKLET_TYPE_LS );
1279     if (!thunk)
1280     {
1281         TDB *pTask = (TDB*)GlobalLock16( owner );
1282
1283         if ( !(thunk = HeapAlloc( ThunkletHeap, 0, sizeof(THUNKLET) )) )
1284             return 0;
1285
1286         thunk->prefix_target = thunk->prefix_relay = 0x90;
1287         thunk->pushl_target  = thunk->pushl_relay  = 0x68;
1288         thunk->jmp_glue = 0xE9;
1289
1290         thunk->target  = (DWORD)target;
1291         thunk->relay   = (DWORD)relay;
1292         thunk->glue    = (DWORD)glue - (DWORD)&thunk->type;
1293
1294         thunk->type    = THUNKLET_TYPE_LS;
1295         thunk->owner   = pTask? pTask->hInstance : 0;
1296
1297         thunk->next    = ThunkletAnchor;
1298         ThunkletAnchor = thunk;
1299     }
1300
1301     return (FARPROC)thunk;
1302 }
1303
1304 /***********************************************************************
1305  *     THUNK_AllocSLThunklet
1306  */
1307 SEGPTR THUNK_AllocSLThunklet( FARPROC target, DWORD relay,
1308                               SEGPTR glue, HTASK16 owner )
1309 {
1310     THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
1311                                           THUNKLET_TYPE_SL );
1312     if (!thunk)
1313     {
1314         TDB *pTask = (TDB*)GlobalLock16( owner );
1315
1316         if ( !(thunk = HeapAlloc( ThunkletHeap, 0, sizeof(THUNKLET) )) )
1317             return 0;
1318
1319         thunk->prefix_target = thunk->prefix_relay = 0x66;
1320         thunk->pushl_target  = thunk->pushl_relay  = 0x68;
1321         thunk->jmp_glue = 0xEA;
1322
1323         thunk->target  = (DWORD)target;
1324         thunk->relay   = (DWORD)relay;
1325         thunk->glue    = (DWORD)glue;
1326
1327         thunk->type    = THUNKLET_TYPE_SL;
1328         thunk->owner   = pTask? pTask->hInstance : 0;
1329
1330         thunk->next    = ThunkletAnchor;
1331         ThunkletAnchor = thunk;
1332     }
1333
1334     return HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1335 }
1336
1337 /**********************************************************************
1338  *     IsLSThunklet
1339  */
1340 BOOL16 WINAPI IsLSThunklet( THUNKLET *thunk )
1341 {
1342     return    thunk->prefix_target == 0x90 && thunk->pushl_target == 0x68
1343            && thunk->prefix_relay  == 0x90 && thunk->pushl_relay  == 0x68
1344            && thunk->jmp_glue == 0xE9 && thunk->type == THUNKLET_TYPE_LS;
1345 }
1346
1347 /**********************************************************************
1348  *     IsSLThunklet                        (KERNEL.612)
1349  */
1350 BOOL16 WINAPI IsSLThunklet16( THUNKLET *thunk )
1351 {
1352     return    thunk->prefix_target == 0x66 && thunk->pushl_target == 0x68
1353            && thunk->prefix_relay  == 0x66 && thunk->pushl_relay  == 0x68
1354            && thunk->jmp_glue == 0xEA && thunk->type == THUNKLET_TYPE_SL;
1355 }
1356
1357
1358
1359 /***********************************************************************
1360  *     AllocLSThunkletSysthunk             (KERNEL.607)
1361  */
1362 FARPROC WINAPI AllocLSThunkletSysthunk16( SEGPTR target,
1363                                           FARPROC relay, DWORD dummy )
1364 {
1365     return THUNK_AllocLSThunklet( (SEGPTR)relay, (DWORD)target,
1366                                   ThunkletSysthunkGlueLS, GetCurrentTask() );
1367 }
1368
1369 /***********************************************************************
1370  *     AllocSLThunkletSysthunk             (KERNEL.608)
1371  */
1372 SEGPTR WINAPI AllocSLThunkletSysthunk16( FARPROC target,
1373                                        SEGPTR relay, DWORD dummy )
1374 {
1375     return THUNK_AllocSLThunklet( (FARPROC)relay, (DWORD)target,
1376                                   ThunkletSysthunkGlueSL, GetCurrentTask() );
1377 }
1378
1379
1380 /***********************************************************************
1381  *     AllocLSThunkletCallbackEx           (KERNEL.567)
1382  */
1383 FARPROC WINAPI AllocLSThunkletCallbackEx16( SEGPTR target,
1384                                             DWORD relay, HTASK16 task )
1385 {
1386     THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
1387     if ( !thunk ) return NULL;
1388
1389     if (   IsSLThunklet16( thunk ) && thunk->relay == relay
1390         && thunk->glue == (DWORD)ThunkletCallbackGlueSL )
1391         return (FARPROC)thunk->target;
1392
1393     return THUNK_AllocLSThunklet( target, relay,
1394                                   ThunkletCallbackGlueLS, task );
1395 }
1396
1397 /***********************************************************************
1398  *     AllocSLThunkletCallbackEx           (KERNEL.568)
1399  */
1400 SEGPTR WINAPI AllocSLThunkletCallbackEx16( FARPROC target,
1401                                          DWORD relay, HTASK16 task )
1402 {
1403     THUNKLET *thunk = (THUNKLET *)target;
1404     if ( !thunk ) return 0;
1405
1406     if (   IsLSThunklet( thunk ) && thunk->relay == relay
1407         && thunk->glue == (DWORD)ThunkletCallbackGlueLS - (DWORD)&thunk->type )
1408         return (SEGPTR)thunk->target;
1409
1410     return THUNK_AllocSLThunklet( target, relay,
1411                                   ThunkletCallbackGlueSL, task );
1412 }
1413
1414 /***********************************************************************
1415  *     AllocLSThunkletCallback             (KERNEL.561) (KERNEL.606)
1416  */
1417 FARPROC WINAPI AllocLSThunkletCallback16( SEGPTR target, DWORD relay )
1418 {
1419     return AllocLSThunkletCallbackEx16( target, relay, GetCurrentTask() );
1420 }
1421
1422 /***********************************************************************
1423  *     AllocSLThunkletCallback             (KERNEL.562) (KERNEL.605)
1424  */
1425 SEGPTR WINAPI AllocSLThunkletCallback16( FARPROC target, DWORD relay )
1426 {
1427     return AllocSLThunkletCallbackEx16( target, relay, GetCurrentTask() );
1428 }
1429
1430 /***********************************************************************
1431  *     FindLSThunkletCallback              (KERNEL.563) (KERNEL.609)
1432  */
1433 FARPROC WINAPI FindLSThunkletCallback( SEGPTR target, DWORD relay )
1434 {
1435     THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
1436     if (   thunk && IsSLThunklet16( thunk ) && thunk->relay == relay
1437         && thunk->glue == (DWORD)ThunkletCallbackGlueSL )
1438         return (FARPROC)thunk->target;
1439
1440     thunk = THUNK_FindThunklet( (DWORD)target, relay,
1441                                 (DWORD)ThunkletCallbackGlueLS,
1442                                 THUNKLET_TYPE_LS );
1443     return (FARPROC)thunk;
1444 }
1445
1446 /***********************************************************************
1447  *     FindSLThunkletCallback              (KERNEL.564) (KERNEL.610)
1448  */
1449 SEGPTR WINAPI FindSLThunkletCallback( FARPROC target, DWORD relay )
1450 {
1451     THUNKLET *thunk = (THUNKLET *)target;
1452     if (   thunk && IsLSThunklet( thunk ) && thunk->relay == relay
1453         && thunk->glue == (DWORD)ThunkletCallbackGlueLS - (DWORD)&thunk->type )
1454         return (SEGPTR)thunk->target;
1455
1456     thunk = THUNK_FindThunklet( (DWORD)target, relay,
1457                                 (DWORD)ThunkletCallbackGlueSL,
1458                                 THUNKLET_TYPE_SL );
1459     return HEAP_GetSegptr( ThunkletHeap, 0, thunk );
1460 }
1461
1462
1463 /***********************************************************************
1464  *     FreeThunklet16            (KERNEL.611)
1465  */
1466 BOOL16 WINAPI FreeThunklet16( DWORD unused1, DWORD unused2 )
1467 {
1468     return FALSE;
1469 }
1470
1471 /***********************************************************************
1472  * Callback Client API
1473  */
1474
1475 #define N_CBC_FIXED    20
1476 #define N_CBC_VARIABLE 10
1477 #define N_CBC_TOTAL    (N_CBC_FIXED + N_CBC_VARIABLE)
1478
1479 static SEGPTR    *CBClientRelay16[ N_CBC_TOTAL ];
1480 static FARPROC *CBClientRelay32[ N_CBC_TOTAL ];
1481
1482 /***********************************************************************
1483  *     RegisterCBClient                    (KERNEL.619)
1484  */
1485 INT16 WINAPI RegisterCBClient16( INT16 wCBCId,
1486                                SEGPTR *relay16, FARPROC *relay32 )
1487 {
1488     /* Search for free Callback ID */
1489     if ( wCBCId == -1 )
1490         for ( wCBCId = N_CBC_FIXED; wCBCId < N_CBC_TOTAL; wCBCId++ )
1491             if ( !CBClientRelay16[ wCBCId ] )
1492                 break;
1493
1494     /* Register Callback ID */
1495     if ( wCBCId > 0 && wCBCId < N_CBC_TOTAL )
1496     {
1497         CBClientRelay16[ wCBCId ] = relay16;
1498         CBClientRelay32[ wCBCId ] = relay32;
1499     }
1500     else
1501         wCBCId = 0;
1502
1503     return wCBCId;
1504 }
1505
1506 /***********************************************************************
1507  *     UnRegisterCBClient                  (KERNEL.622)
1508  */
1509 INT16 WINAPI UnRegisterCBClient16( INT16 wCBCId,
1510                                  SEGPTR *relay16, FARPROC *relay32 )
1511 {
1512     if (    wCBCId >= N_CBC_FIXED && wCBCId < N_CBC_TOTAL
1513          && CBClientRelay16[ wCBCId ] == relay16
1514          && CBClientRelay32[ wCBCId ] == relay32 )
1515     {
1516         CBClientRelay16[ wCBCId ] = 0;
1517         CBClientRelay32[ wCBCId ] = 0;
1518     }
1519     else
1520         wCBCId = 0;
1521
1522     return wCBCId;
1523 }
1524
1525
1526 /***********************************************************************
1527  *     InitCBClient                        (KERNEL.623)
1528  */
1529 void WINAPI InitCBClient16( FARPROC glueLS )
1530 {
1531     HMODULE16 kernel = GetModuleHandle16( "KERNEL" );
1532     SEGPTR glueSL = (SEGPTR)WIN32_GetProcAddress16( kernel, (LPCSTR)604 );
1533
1534     SetThunkletCallbackGlue16( glueLS, glueSL );
1535 }
1536
1537 /***********************************************************************
1538  *     CBClientGlueSL                      (KERNEL.604)
1539  */
1540 void WINAPI CBClientGlueSL( CONTEXT86 *context )
1541 {
1542     /* Create stack frame */
1543     SEGPTR stackSeg = stack16_push( 12 );
1544     LPWORD stackLin = PTR_SEG_TO_LIN( stackSeg );
1545     SEGPTR glue;
1546
1547     stackLin[3] = BP_reg( context );
1548     stackLin[2] = SI_reg( context );
1549     stackLin[1] = DI_reg( context );
1550     stackLin[0] = DS_reg( context );
1551
1552     EBP_reg( context ) = OFFSETOF( stackSeg ) + 6;
1553     ESP_reg( context ) = OFFSETOF( stackSeg ) - 4;
1554     GS_reg( context ) = 0;
1555
1556     /* Jump to 16-bit relay code */
1557     glue = CBClientRelay16[ stackLin[5] ][ stackLin[4] ];
1558     CS_reg ( context ) = SELECTOROF( glue );
1559     EIP_reg( context ) = OFFSETOF  ( glue );
1560 }
1561
1562 /***********************************************************************
1563  *     CBClientThunkSL                      (KERNEL.620)
1564  */
1565 extern DWORD WINAPI CALL32_CBClient( FARPROC proc, LPWORD args, DWORD *esi );
1566 void WINAPI CBClientThunkSL( CONTEXT86 *context )
1567 {
1568     /* Call 32-bit relay code */
1569
1570     LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), BP_reg( context ) );
1571     FARPROC proc = CBClientRelay32[ args[2] ][ args[1] ];
1572
1573     EAX_reg(context) = CALL32_CBClient( proc, args, &ESI_reg( context ) );
1574 }
1575
1576 /***********************************************************************
1577  *     CBClientThunkSLEx                    (KERNEL.621)
1578  */
1579 extern DWORD WINAPI CALL32_CBClientEx( FARPROC proc, LPWORD args,
1580                                        DWORD *esi, INT *nArgs );
1581 void WINAPI CBClientThunkSLEx( CONTEXT86 *context )
1582 {
1583     /* Call 32-bit relay code */
1584
1585     LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), BP_reg( context ) );
1586     FARPROC proc = CBClientRelay32[ args[2] ][ args[1] ];
1587     INT nArgs;
1588     LPWORD stackLin;
1589
1590     EAX_reg(context) = CALL32_CBClientEx( proc, args, &ESI_reg( context ), &nArgs );
1591
1592     /* Restore registers saved by CBClientGlueSL */
1593     stackLin = (LPWORD)((LPBYTE)CURRENT_STACK16 + sizeof(STACK16FRAME) - 4);
1594     BP_reg( context ) = stackLin[3];
1595     SI_reg( context ) = stackLin[2];
1596     DI_reg( context ) = stackLin[1];
1597     DS_reg( context ) = stackLin[0];
1598     ESP_reg( context ) += 16+nArgs;
1599
1600     /* Return to caller of CBClient thunklet */
1601     CS_reg ( context ) = stackLin[9];
1602     EIP_reg( context ) = stackLin[8];
1603 }
1604