4 * Copyright 1996, 1997 Alexandre Julliard
5 * Copyright 1998 Ulrich Weigand
17 #include "stackframe.h"
18 #include "selectors.h"
23 #include "flatthunk.h"
26 /* List of the 16-bit callback functions. This list is used */
27 /* by the build program to generate the file if1632/callto16.S */
29 /* ### start build ### */
30 extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT32 offset);
31 extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT32 offset);
32 extern WORD CALLBACK CallTo16_word_ (FARPROC16);
33 extern LONG CALLBACK CallTo16_long_ (FARPROC16);
34 extern WORD CALLBACK CallTo16_word_w (FARPROC16,WORD);
35 extern LONG CALLBACK CallTo16_long_l (FARPROC16,LONG);
36 extern WORD CALLBACK CallTo16_word_ww (FARPROC16,WORD,WORD);
37 extern WORD CALLBACK CallTo16_word_wl (FARPROC16,WORD,LONG);
38 extern WORD CALLBACK CallTo16_word_ll (FARPROC16,LONG,LONG);
39 extern LONG CALLBACK CallTo16_long_ll (FARPROC16,LONG,LONG);
40 extern WORD CALLBACK CallTo16_word_www (FARPROC16,WORD,WORD,WORD);
41 extern WORD CALLBACK CallTo16_word_wwl (FARPROC16,WORD,WORD,LONG);
42 extern WORD CALLBACK CallTo16_word_wlw (FARPROC16,WORD,LONG,WORD);
43 extern LONG CALLBACK CallTo16_long_wwl (FARPROC16,WORD,WORD,LONG);
44 extern LONG CALLBACK CallTo16_long_lll (FARPROC16,LONG,LONG,LONG);
45 extern WORD CALLBACK CallTo16_word_llwl (FARPROC16,LONG,LONG,WORD,LONG);
46 extern WORD CALLBACK CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG);
47 extern WORD CALLBACK CallTo16_word_lwww (FARPROC16,LONG,WORD,WORD,WORD);
48 extern WORD CALLBACK CallTo16_word_wwll (FARPROC16,WORD,WORD,LONG,LONG);
49 extern WORD CALLBACK CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG);
50 extern LONG CALLBACK CallTo16_long_llll (FARPROC16,LONG,LONG,LONG,LONG);
51 extern WORD CALLBACK CallTo16_word_wllwl(FARPROC16,WORD,LONG,LONG,WORD,LONG);
52 extern LONG CALLBACK CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
53 extern WORD CALLBACK CallTo16_word_wwlll(FARPROC16,WORD,WORD,LONG,LONG,LONG);
54 extern WORD CALLBACK CallTo16_word_wwwww(FARPROC16,WORD,WORD,WORD,WORD,WORD);
55 extern WORD CALLBACK CallTo16_word_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
56 extern LONG CALLBACK CallTo16_long_lwlll(FARPROC16,LONG,WORD,LONG,LONG,LONG);
57 extern LONG CALLBACK CallTo16_long_lllll(FARPROC16,LONG,LONG,LONG,LONG,LONG);
58 extern LONG CALLBACK CallTo16_long_llllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
60 extern LONG CALLBACK CallTo16_long_lllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
62 extern WORD CALLBACK CallTo16_word_llwwlll(FARPROC16,LONG,LONG,WORD,WORD,LONG,
64 extern LONG CALLBACK CallTo16_word_lwwlllll(FARPROC16,LONG,WORD,WORD,LONG,LONG,
66 extern LONG CALLBACK CallTo16_long_llllllll(FARPROC16,LONG,LONG,LONG,LONG,LONG,
68 extern LONG CALLBACK CallTo16_long_lllllllll(FARPROC16,LONG,LONG,LONG,LONG,
69 LONG,LONG,LONG,LONG,LONG);
70 extern LONG CALLBACK CallTo16_long_llllllllll(FARPROC16,LONG,LONG,LONG,LONG,
71 LONG,LONG,LONG,LONG,LONG,LONG);
72 extern LONG CALLBACK CallTo16_long_lllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
73 LONG,LONG,LONG,LONG,LONG,LONG,
75 extern LONG CALLBACK CallTo16_long_llllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
76 LONG,LONG,LONG,LONG,LONG,LONG,
78 extern LONG CALLBACK CallTo16_long_lwwllwlllllw(FARPROC16,LONG,WORD,WORD,LONG,
79 LONG,WORD,LONG,LONG,LONG,LONG,
81 extern LONG CALLBACK CallTo16_long_lllllllllllll(FARPROC16,LONG,LONG,LONG,LONG,
82 LONG,LONG,LONG,LONG,LONG,LONG,
84 extern LONG CALLBACK CallTo16_long_llllllllllllll(FARPROC16,LONG,LONG,LONG,
85 LONG,LONG,LONG,LONG,LONG,
86 LONG,LONG,LONG,LONG,LONG,
88 extern LONG CALLBACK CallTo16_word_lwwwwlwwwwllll(FARPROC16,LONG,WORD,WORD,
89 WORD,WORD,LONG,WORD,WORD,
90 WORD,WORD,LONG,LONG,LONG,
92 extern LONG CALLBACK CallTo16_long_lllllllllllllll(FARPROC16,LONG,LONG,LONG,
93 LONG,LONG,LONG,LONG,LONG,
94 LONG,LONG,LONG,LONG,LONG,
96 extern LONG CALLBACK CallTo16_long_llllllllllllllll(FARPROC16,LONG,LONG,LONG,
97 LONG,LONG,LONG,LONG,LONG,
98 LONG,LONG,LONG,LONG,LONG,
100 /* ### stop build ### */
103 typedef void (*RELAY)();
107 typedef struct tagTHUNK
109 BYTE popl_eax; /* 0x58 popl %eax (return address)*/
110 BYTE pushl_func; /* 0x68 pushl $proc */
111 FARPROC32 proc WINE_PACKED;
112 BYTE pushl_eax; /* 0x50 pushl %eax */
113 BYTE jmp; /* 0xe9 jmp relay (relative jump)*/
114 RELAY relay WINE_PACKED;
115 struct tagTHUNK *next WINE_PACKED;
120 #define DECL_THUNK(name,proc,relay) \
121 THUNK name = { 0x58, 0x68, (FARPROC32)(proc), 0x50, 0xe9, \
122 (RELAY)((char *)(relay) - (char *)(&(name).next)), NULL }
125 static THUNK *firstThunk = NULL;
127 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
128 UINT16 msg, WPARAM16 wParam,
130 static void WINAPI THUNK_CallTaskReschedule(void);
131 static BOOL32 WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
134 /* TASK_Reschedule() 16-bit entry point */
135 static FARPROC16 TASK_RescheduleProc;
137 extern void CallFrom16_p_long_wwwll(void);
139 /* Callbacks function table for the emulator */
140 static const CALLBACKS_TABLE CALLBACK_EmulatorTable =
142 (void *)CallTo16_sreg_, /* CallRegisterShortProc */
143 (void *)CallTo16_lreg_, /* CallRegisterLongProc */
144 THUNK_CallTaskReschedule, /* CallTaskRescheduleProc */
145 CallFrom16_p_long_wwwll, /* CallFrom16WndProc */
146 THUNK_CallWndProc16, /* CallWndProc */
147 (void *)CallTo16_long_lwwll, /* CallDriverProc */
148 (void *)CallTo16_word_wwlll, /* CallDriverCallback */
149 (void *)CallTo16_word_wwlll, /* CallTimeFuncProc */
150 (void *)CallTo16_word_w, /* CallWindowsExitProc */
151 (void *)CallTo16_word_lwww, /* CallWordBreakProc */
152 (void *)CallTo16_word_ww, /* CallBootAppProc */
153 (void *)CallTo16_word_www, /* CallLoadAppSegProc */
154 (void *)CallTo16_word_, /* CallSystemTimerProc */
155 (void *)CallTo16_word_www, /* CallResourceHandlerProc */
156 (void *)CallTo16_long_l, /* CallWOWCallbackProc */
157 THUNK_WOWCallback16Ex, /* CallWOWCallback16Ex */
158 (void *)CallTo16_long_l, /* CallASPIPostProc */
159 (void *)CallTo16_word_lwll, /* CallDrvControlProc */
160 (void *)CallTo16_word_lwlll, /* CallDrvEnableProc */
161 (void *)CallTo16_word_llll, /* CallDrvEnumDFontsProc */
162 (void *)CallTo16_word_lwll, /* CallDrvEnumObjProc */
163 (void *)CallTo16_word_lwwlllll, /* CallDrvOutputProc */
164 (void *)CallTo16_long_lwlll, /* CallDrvRealizeProc */
165 (void *)CallTo16_word_lwwwwlwwwwllll, /* CallDrvStretchBltProc */
166 (void *)CallTo16_long_lwwllwlllllw, /* CallDrvExtTextOutProc */
167 (void *)CallTo16_word_llwwlll /* CallDrvGetCharWidth */
171 /***********************************************************************
174 BOOL32 THUNK_Init(void)
176 /* Set the window proc calling functions */
177 Callbacks = &CALLBACK_EmulatorTable;
178 /* Get the 16-bit reschedule function pointer */
179 TASK_RescheduleProc = MODULE_GetWndProcEntry16( "TASK_Reschedule" );
184 /***********************************************************************
187 static THUNK *THUNK_Alloc( FARPROC32 func, RELAY relay )
189 THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) );
192 thunk->popl_eax = 0x58;
193 thunk->pushl_func = 0x68;
195 thunk->pushl_eax = 0x50;
197 thunk->relay = (RELAY)((char *)relay - (char *)(&thunk->next));
198 thunk->next = firstThunk;
205 /***********************************************************************
208 static THUNK *THUNK_Find( FARPROC32 func )
210 THUNK *thunk = firstThunk;
211 while (thunk && (thunk->proc != func)) thunk = thunk->next;
216 /***********************************************************************
219 static void THUNK_Free( THUNK *thunk )
221 if (HEAP_IsInsideHeap( GetProcessHeap(), 0, thunk ))
223 THUNK **prev = &firstThunk;
224 while (*prev && (*prev != thunk)) prev = &(*prev)->next;
228 HeapFree( GetProcessHeap(), 0, thunk );
232 ERR(thunk, "invalid thunk addr %p\n", thunk );
236 /***********************************************************************
237 * THUNK_CallWndProc16
239 * Call a 16-bit window procedure
241 static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
242 UINT16 msg, WPARAM16 wParam,
248 WND *wndPtr = WIN_FindWndPtr( hwnd );
250 THDB *thdb = THREAD_Current();
252 /* Window procedures want ax = hInstance, ds = es = ss */
254 memset(&context, '\0', sizeof(context));
255 DS_reg(&context) = SELECTOROF(thdb->cur_stack);
256 ES_reg(&context) = DS_reg(&context);
257 EAX_reg(&context) = wndPtr ? wndPtr->hInstance : DS_reg(&context);
258 CS_reg(&context) = SELECTOROF(proc);
259 EIP_reg(&context) = OFFSETOF(proc);
260 EBP_reg(&context) = OFFSETOF(thdb->cur_stack)
261 + (WORD)&((STACK16FRAME*)0)->bp;
265 /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
266 work if structures passed in lParam are placed in the stack/data
267 segment. Programmers easily make the mistake of converting lParam
268 to a near rather than a far pointer, since Windows apparently
269 allows this. We copy the structures to the 16 bit stack; this is
270 ugly but makes these programs work. */
275 offset = sizeof(CREATESTRUCT16); break;
277 offset = sizeof(DRAWITEMSTRUCT16); break;
279 offset = sizeof(COMPAREITEMSTRUCT16); break;
283 void *s = PTR_SEG_TO_LIN(lParam);
284 lParam = STACK16_PUSH( thdb, offset );
285 memcpy( PTR_SEG_TO_LIN(lParam), s, offset );
289 args = (WORD *)THREAD_STACK16(thdb) - 5;
290 args[0] = LOWORD(lParam);
291 args[1] = HIWORD(lParam);
296 ret = CallTo16_sreg_( &context, 5 * sizeof(WORD) );
297 if (offset) STACK16_POP( thdb, offset );
302 /***********************************************************************
303 * THUNK_CallTaskReschedule
305 static void WINAPI THUNK_CallTaskReschedule(void)
307 CallTo16_word_(TASK_RescheduleProc);
311 /***********************************************************************
312 * THUNK_EnumObjects16 (GDI.71)
314 INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
315 GOBJENUMPROC16 func, LPARAM lParam )
317 DECL_THUNK( thunk, func, CallTo16_word_ll );
318 return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam );
322 /*************************************************************************
323 * THUNK_EnumFonts16 (GDI.70)
325 INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
326 FONTENUMPROC16 func, LPARAM lParam )
328 DECL_THUNK( thunk, func, CallTo16_word_llwl );
329 return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam );
332 /******************************************************************
333 * THUNK_EnumMetaFile16 (GDI.175)
335 BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
336 MFENUMPROC16 func, LPARAM lParam )
338 DECL_THUNK( thunk, func, CallTo16_word_wllwl );
339 return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam );
343 /*************************************************************************
344 * THUNK_EnumFontFamilies16 (GDI.330)
346 INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
347 FONTENUMPROC16 func, LPARAM lParam )
349 DECL_THUNK( thunk, func, CallTo16_word_llwl );
350 return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
354 /*************************************************************************
355 * THUNK_EnumFontFamiliesEx16 (GDI.613)
357 INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
358 FONTENUMPROCEX16 func, LPARAM lParam,
361 DECL_THUNK( thunk, func, CallTo16_word_llwl );
362 return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk,
367 /**********************************************************************
368 * THUNK_LineDDA16 (GDI.100)
370 void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
371 INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam )
373 DECL_THUNK( thunk, func, CallTo16_word_wwl );
374 LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam );
378 /*******************************************************************
379 * THUNK_EnumWindows16 (USER.54)
381 BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
383 DECL_THUNK( thunk, func, CallTo16_word_wl );
384 return EnumWindows16( (WNDENUMPROC16)&thunk, lParam );
388 /**********************************************************************
389 * THUNK_EnumChildWindows16 (USER.55)
391 BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
394 DECL_THUNK( thunk, func, CallTo16_word_wl );
395 return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam );
399 /**********************************************************************
400 * THUNK_EnumTaskWindows16 (USER.225)
402 BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
405 DECL_THUNK( thunk, func, CallTo16_word_wl );
406 return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam );
410 /***********************************************************************
411 * THUNK_EnumProps16 (USER.27)
413 INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
415 DECL_THUNK( thunk, func, CallTo16_word_wlw );
416 return EnumProps16( hwnd, (PROPENUMPROC16)&thunk );
420 /***********************************************************************
421 * THUNK_GrayString16 (USER.185)
423 BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr,
424 GRAYSTRINGPROC16 func, LPARAM lParam,
425 INT16 cch, INT16 x, INT16 y,
428 DECL_THUNK( thunk, func, CallTo16_word_wlw );
430 return GrayString16( hdc, hbr, NULL, lParam, cch, x, y, cx, cy );
432 return GrayString16( hdc, hbr, (GRAYSTRINGPROC16)&thunk, lParam, cch,
437 /***********************************************************************
438 * THUNK_SetWindowsHook16 (USER.121)
440 FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
442 HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) );
443 HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
444 THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
445 if (!thunk) return 0;
446 return (FARPROC16)SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask);
450 /***********************************************************************
451 * THUNK_UnhookWindowsHook16 (USER.234)
453 BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
456 THUNK *thunk = THUNK_Find( (FARPROC16)proc );
457 if (!thunk) return FALSE;
458 ret = UnhookWindowsHook16( id, (HOOKPROC16)thunk );
464 /***********************************************************************
465 * THUNK_SetWindowsHookEx16 (USER.291)
467 HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc,
468 HINSTANCE16 hInst, HTASK16 hTask )
470 THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
471 if (!thunk) return 0;
472 return SetWindowsHookEx16( id, (HOOKPROC16)thunk, hInst, hTask );
476 /***********************************************************************
477 * THUNK_UnhookWindowHookEx16 (USER.292)
479 BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook )
481 THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook );
482 BOOL16 ret = UnhookWindowsHookEx16( hhook );
483 if (thunk) THUNK_Free( thunk );
489 static FARPROC16 defDCHookProc = NULL;
491 /***********************************************************************
492 * THUNK_SetDCHook (GDI.190)
494 BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
496 THUNK *thunk, *oldThunk;
498 if (!defDCHookProc) /* Get DCHook Win16 entry point */
499 defDCHookProc = NE_GetEntryPoint( GetModuleHandle16("USER"), 362 );
501 if (proc != defDCHookProc)
503 thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwll );
504 if (!thunk) return FALSE;
506 else thunk = (THUNK *)DCHook;
508 /* Free the previous thunk */
509 GetDCHook( hdc, (FARPROC16 *)&oldThunk );
510 if (oldThunk && (oldThunk != (THUNK *)DCHook)) THUNK_Free( oldThunk );
512 return SetDCHook( hdc, (FARPROC16)thunk, dwHookData );
516 /***********************************************************************
517 * THUNK_GetDCHook (GDI.191)
519 DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
522 DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
525 if (thunk == (THUNK *)DCHook)
527 if (!defDCHookProc) /* Get DCHook Win16 entry point */
528 defDCHookProc = NE_GetEntryPoint(GetModuleHandle16("USER"),362);
529 *phookProc = defDCHookProc;
531 else *phookProc = thunk->proc;
537 /***********************************************************************
538 * THUNK_SetTaskSignalProc (KERNEL.38)
540 FARPROC16 WINAPI THUNK_SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
542 static FARPROC16 defSignalProc16 = NULL;
546 if( !defSignalProc16 )
547 defSignalProc16 = NE_GetEntryPoint(GetModuleHandle16("USER"), 314 );
549 if( proc == defSignalProc16 )
550 thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)&USER_SignalProc );
553 thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwwww );
554 if( !thunk ) return FALSE;
555 thunk = (THUNK*)SetTaskSignalProc( hTask, (FARPROC16)thunk );
558 if( thunk != (THUNK*)USER_SignalProc )
560 if( !thunk ) return NULL;
566 return defSignalProc16;
569 /***********************************************************************
570 * THUNK_CreateThread16 (KERNEL.441)
572 static DWORD CALLBACK THUNK_StartThread16( LPVOID threadArgs )
574 FARPROC16 start = ((FARPROC16 *)threadArgs)[0];
575 DWORD param = ((DWORD *)threadArgs)[1];
576 HeapFree( GetProcessHeap(), 0, threadArgs );
578 return CallTo16_long_l( start, param );
580 HANDLE32 WINAPI THUNK_CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
581 FARPROC16 start, SEGPTR param,
582 DWORD flags, LPDWORD id )
584 DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
585 if (!threadArgs) return INVALID_HANDLE_VALUE32;
586 threadArgs[0] = (DWORD)start;
587 threadArgs[1] = (DWORD)param;
589 return CreateThread( sa, stack, THUNK_StartThread16, threadArgs, flags, id );
592 /***********************************************************************
593 * THUNK_WOWCallback16Ex (WOW32.3)(KERNEL32.55)
594 * Generic thunking routine to call 16 bit functions from 32bit code.
597 * TRUE if the call was done
599 static BOOL32 WINAPI THUNK_WOWCallback16Ex(
600 FARPROC16 proc, /* [in] 16bit function to call */
601 DWORD dwFlags, /* [in] flags (WCB_*) */
602 DWORD cbArgs, /* [in] number of arguments */
603 LPVOID xargs, /* [in/out] arguments */
604 LPDWORD pdwret /* [out] return value of the 16bit call */
606 LPDWORD args = (LPDWORD)xargs;
609 TRACE(relay,"(%p,0x%08lx,%ld,%p,%p)\n",
610 proc,dwFlags,cbArgs,xargs,pdwret
612 if (dwFlags == WCB16_CDECL) {
613 /* swap the arguments */
614 args = HeapAlloc(GetProcessHeap(),0,cbArgs*sizeof(DWORD));
615 for (i=0;i<cbArgs;i++)
616 args[i] = ((DWORD*)xargs)[cbArgs-i-1];
619 case 0: ret = CallTo16_long_(proc);break;
620 case 1: ret = CallTo16_long_l(proc,args[0]);break;
621 case 2: ret = CallTo16_long_ll(proc,args[0],args[1]);break;
622 case 3: ret = CallTo16_long_lll(proc,args[0],args[1],args[2]);break;
623 case 4: ret = CallTo16_long_llll(proc,args[0],args[1],args[2],args[3]);
625 case 5: ret = CallTo16_long_lllll(proc,args[0],args[1],args[2],args[3],
629 case 6: ret = CallTo16_long_llllll(proc,args[0],args[1],args[2],args[3],
633 case 7: ret = CallTo16_long_lllllll(proc,args[0],args[1],args[2],args[3],
634 args[4],args[5],args[6]
637 case 8: ret = CallTo16_long_llllllll(proc,args[0],args[1],args[2],args[3],
638 args[4],args[5],args[6],args[7]
641 case 9: ret = CallTo16_long_lllllllll(proc,args[0],args[1],args[2],args[3],
642 args[4],args[5],args[6],args[7],args[8]
645 case 10:ret = CallTo16_long_llllllllll(proc,args[0],args[1],args[2],args[3],
646 args[4],args[5],args[6],args[7],args[8],args[9]
649 case 11:ret = CallTo16_long_lllllllllll(proc,args[0],args[1],args[2],
650 args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]
653 case 12:ret = CallTo16_long_llllllllllll(proc,args[0],args[1],args[2],
654 args[3],args[4],args[5],args[6],args[7],args[8],args[9],
658 case 13:ret = CallTo16_long_lllllllllllll(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],args[12]
663 case 14:ret = CallTo16_long_llllllllllllll(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],args[13]
668 case 15:ret = CallTo16_long_lllllllllllllll(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],args[14]
673 case 16:ret = CallTo16_long_llllllllllllllll(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],args[15]
679 ERR(thunk,"%ld arguments not supported.\n",cbArgs);
680 if (dwFlags == WCB16_CDECL)
681 HeapFree(GetProcessHeap(),0,args);
684 if (dwFlags == WCB16_CDECL)
685 HeapFree(GetProcessHeap(),0,args);
692 /***********************************************************************
693 * 16->32 Flat Thunk routines:
696 /***********************************************************************
697 * ThunkConnect16 (KERNEL.651)
698 * Connects a 32bit and a 16bit thunkbuffer.
700 UINT32 WINAPI ThunkConnect16(
701 LPSTR module16, /* [in] name of win16 dll */
702 LPSTR module32, /* [in] name of win32 dll */
703 HINSTANCE16 hInst16, /* [in] hInst of win16 dll */
704 DWORD dwReason, /* [in] initialisation argument */
705 struct ThunkDataCommon *TD, /* [in/out] thunkbuffer */
706 LPSTR thunkfun32, /* [in] win32 thunkfunction */
707 WORD CS /* [in] CS of win16 dll */
711 if (!lstrncmp32A(TD->magic, "SL01", 4))
715 TRACE(thunk, "SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
716 module16, (DWORD)TD, module32, thunkfun32, dwReason);
718 else if (!lstrncmp32A(TD->magic, "LS01", 4))
722 TRACE(thunk, "LS01 thunk %s (%lx) <- %s (%s), Reason: %ld\n",
723 module16, (DWORD)TD, module32, thunkfun32, dwReason);
727 ERR(thunk, "Invalid magic %c%c%c%c\n",
728 TD->magic[0], TD->magic[1], TD->magic[2], TD->magic[3]);
734 case DLL_PROCESS_ATTACH:
737 struct ThunkDataSL16 *SL16 = (struct ThunkDataSL16 *)TD;
738 struct ThunkDataSL *SL = SL16->fpData;
742 SL = HeapAlloc(GetProcessHeap(), 0, sizeof(*SL));
744 SL->common = SL16->common;
745 SL->flags1 = SL16->flags1;
746 SL->flags2 = SL16->flags2;
748 SL->apiDB = PTR_SEG_TO_LIN(SL16->apiDatabase);
751 lstrcpyn32A(SL->pszDll16, module16, 255);
752 lstrcpyn32A(SL->pszDll32, module32, 255);
754 /* We should create a SEGPTR to the ThunkDataSL,
755 but since the contents are not in the original format,
756 any access to this by 16-bit code would crash anyway. */
762 if (SL->flags2 & 0x80000000)
764 TRACE(thunk, "Preloading 32-bit library\n");
765 LoadLibrary32A(module32);
774 case DLL_PROCESS_DETACH:
783 /***********************************************************************
784 * C16ThkSL (KERNEL.630)
787 void WINAPI C16ThkSL(CONTEXT *context)
789 extern void CallFrom16_t_long_(void);
790 LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
795 /* We produce the following code:
800 * mov edx, es:[ecx + $EDX]
803 * call __FLATCS:CallFrom16_t_long_
806 *x++ = 0xB8; *((WORD *)x)++ = ds;
807 *x++ = 0x8E; *x++ = 0xC0;
808 *x++ = 0x66; *x++ = 0x0F; *x++ = 0xB7; *x++ = 0xC9;
809 *x++ = 0x67; *x++ = 0x66; *x++ = 0x26; *x++ = 0x8B;
810 *x++ = 0x91; *((DWORD *)x)++ = EDX_reg(context);
813 *x++ = 0x66; *x++ = 0x52;
814 *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
817 /* Jump to the stub code just created */
818 IP_reg(context) = LOWORD(EAX_reg(context));
819 CS_reg(context) = HIWORD(EAX_reg(context));
821 /* Since C16ThkSL got called by a jmp, we need to leave the
822 orginal return address on the stack */
823 SP_reg(context) -= 4;
826 /***********************************************************************
827 * C16ThkSL01 (KERNEL.631)
830 void WINAPI C16ThkSL01(CONTEXT *context)
832 LPBYTE stub = PTR_SEG_TO_LIN(EAX_reg(context)), x = stub;
836 struct ThunkDataSL16 *SL16 = PTR_SEG_TO_LIN(EDX_reg(context));
837 struct ThunkDataSL *td = SL16->fpData;
839 extern void CallFrom16_t_long_(void);
840 DWORD procAddress = (DWORD)GetProcAddress16(GetModuleHandle16("KERNEL"), 631);
846 ERR(thunk, "ThunkConnect16 was not called!\n");
850 TRACE(thunk, "Creating stub for ThunkDataSL %08lx\n", (DWORD)td);
853 /* We produce the following code:
860 * call __FLATCS:CallFrom16_t_long_
863 *x++ = 0x66; *x++ = 0x33; *x++ = 0xC0;
864 *x++ = 0x66; *x++ = 0xBA; *((DWORD *)x)++ = (DWORD)td;
865 *x++ = 0x9A; *((DWORD *)x)++ = procAddress;
868 *x++ = 0x66; *x++ = 0x52;
869 *x++ = 0x66; *x++ = 0x9A; *((DWORD *)x)++ = (DWORD)CallFrom16_t_long_;
872 /* Jump to the stub code just created */
873 IP_reg(context) = LOWORD(EAX_reg(context));
874 CS_reg(context) = HIWORD(EAX_reg(context));
876 /* Since C16ThkSL01 got called by a jmp, we need to leave the
877 orginal return address on the stack */
878 SP_reg(context) -= 4;
882 struct ThunkDataSL *td = (struct ThunkDataSL *)EDX_reg(context);
883 DWORD targetNr = CX_reg(context) / 4;
884 struct SLTargetDB *tdb;
886 TRACE(thunk, "Process %08lx calling target %ld of ThunkDataSL %08lx\n",
887 (DWORD)PROCESS_Current(), targetNr, (DWORD)td);
889 for (tdb = td->targetDB; tdb; tdb = tdb->next)
890 if (tdb->process == PROCESS_Current())
895 TRACE(thunk, "Loading 32-bit library %s\n", td->pszDll32);
896 LoadLibrary32A(td->pszDll32);
898 for (tdb = td->targetDB; tdb; tdb = tdb->next)
899 if (tdb->process == PROCESS_Current())
905 EDX_reg(context) = tdb->targetTable[targetNr];
907 TRACE(thunk, "Call target is %08lx\n", EDX_reg(context));
911 WORD *stack = PTR_SEG_OFF_TO_LIN(SS_reg(context), SP_reg(context));
912 DX_reg(context) = HIWORD(td->apiDB[targetNr].errorReturnValue);
913 AX_reg(context) = LOWORD(td->apiDB[targetNr].errorReturnValue);
914 IP_reg(context) = stack[2];
915 CS_reg(context) = stack[3];
916 SP_reg(context) += td->apiDB[targetNr].nrArgBytes + 4;
918 ERR(thunk, "Process %08lx did not ThunkConnect32 %s to %s\n",
919 (DWORD)PROCESS_Current(), td->pszDll32, td->pszDll16);
925 WOW16Call(WORD x,WORD y,WORD z) {
928 FIXME(thunk,"(0x%04x,0x%04x,%d),calling (",x,y,z);
930 for (i=0;i<x/2;i++) {
931 WORD a = STACK16_POP(THREAD_Current(),2);
934 calladdr = STACK16_POP(THREAD_Current(),4);
935 DPRINTF(") calling address was 0x%08lx\n",calladdr);