2 * Copyright 1993 Robert J. Amstadt
3 * Copyright 1995 Alexandre Julliard
9 #include "wine/winbase16.h"
14 #include "stackframe.h"
20 DEFAULT_DEBUG_CHANNEL(relay
)
23 /***********************************************************************
30 /* Allocate the code selector for CallTo16 routines */
32 extern void CALLTO16_Start(), CALLTO16_End();
33 extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
34 extern void CALLTO16_Ret_eax();
35 extern void CALL32_CBClient_Ret();
36 extern void CALL32_CBClientEx_Ret();
37 extern DWORD CALLTO16_RetAddr_word
;
38 extern DWORD CALLTO16_RetAddr_long
;
39 extern DWORD CALLTO16_RetAddr_eax
;
40 extern DWORD CALL32_CBClient_RetAddr
;
41 extern DWORD CALL32_CBClientEx_RetAddr
;
43 codesel
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)CALLTO16_Start
,
44 (int)CALLTO16_End
- (int)CALLTO16_Start
,
45 0, TRUE
, TRUE
, FALSE
, NULL
);
46 if (!codesel
) return FALSE
;
48 /* Patch the return addresses for CallTo16 routines */
50 CALLTO16_RetAddr_word
=MAKELONG( (int)CALLTO16_Ret_word
-(int)CALLTO16_Start
,
52 CALLTO16_RetAddr_long
=MAKELONG( (int)CALLTO16_Ret_long
-(int)CALLTO16_Start
,
54 CALLTO16_RetAddr_eax
=MAKELONG( (int)CALLTO16_Ret_eax
-(int)CALLTO16_Start
,
56 CALL32_CBClient_RetAddr
=
57 MAKELONG( (int)CALL32_CBClient_Ret
-(int)CALLTO16_Start
, codesel
);
58 CALL32_CBClientEx_RetAddr
=
59 MAKELONG( (int)CALL32_CBClientEx_Ret
-(int)CALLTO16_Start
, codesel
);
61 /* Create built-in modules */
62 if (!BUILTIN_Init()) return FALSE
;
64 /* Initialize thunking */
69 /* from relay32/relay386.c */
70 extern char **debug_relay_excludelist
,**debug_relay_includelist
;
72 /***********************************************************************
73 * RELAY_DebugCallFrom16
75 void RELAY_DebugCallFrom16( int func_type
, char *args
,
76 void *entry_point
, CONTEXT
*context
)
84 if (!TRACE_ON(relay
)) return;
86 frame
= CURRENT_STACK16
;
87 funstr
= BUILTIN_GetEntryPoint16(frame
->entry_cs
,frame
->entry_ip
,&ordinal
);
88 if (!funstr
) return; /* happens for the two snoop register relays */
89 if (!RELAY_ShowDebugmsgRelay(funstr
)) return;
90 DPRINTF( "Call %s(",funstr
);
93 if (func_type
& 4) /* cdecl */
101 DPRINTF( "0x%04x", *(WORD
*)args16
);
105 DPRINTF( "0x%08x", *(int *)args16
);
109 DPRINTF( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
110 if (HIWORD(*(SEGPTR
*)args16
))
111 debug_dumpstr( (LPSTR
)PTR_SEG_TO_LIN(*(SEGPTR
*)args16
));
115 DPRINTF( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
119 DPRINTF( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
120 if (HIWORD( *(SEGPTR
*)args16
))
121 debug_dumpstr( (LPSTR
)PTR_SEG_TO_LIN(*(SEGPTR
*)args16
));
126 if (*args
) DPRINTF( "," );
131 /* Start with the last arg */
132 for (i
= 0; args
[i
]; i
++)
156 DPRINTF( "0x%04x", *(WORD
*)args16
);
160 DPRINTF( "0x%08x", *(int *)args16
);
164 DPRINTF( "0x%08x", *(int *)args16
);
165 if (HIWORD(*(SEGPTR
*)args16
))
166 debug_dumpstr( (LPSTR
)PTR_SEG_TO_LIN(*(SEGPTR
*)args16
));
170 DPRINTF( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
174 DPRINTF( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
175 if (HIWORD( *(SEGPTR
*)args16
))
176 debug_dumpstr( (LPSTR
)PTR_SEG_TO_LIN(*(SEGPTR
*)args16
));
180 if (*args
) DPRINTF( "," );
184 DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame
->cs
, frame
->ip
, frame
->ds
);
187 if (func_type
& 2) /* register function */
188 DPRINTF( " AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
189 AX_reg(context
), BX_reg(context
), CX_reg(context
),
190 DX_reg(context
), SI_reg(context
), DI_reg(context
),
191 (WORD
)ES_reg(context
), EFL_reg(context
) );
195 /***********************************************************************
196 * RELAY_DebugCallFrom16Ret
198 void RELAY_DebugCallFrom16Ret( int func_type
, int ret_val
, CONTEXT
*context
)
204 if (!TRACE_ON(relay
)) return;
205 frame
= CURRENT_STACK16
;
206 funstr
= BUILTIN_GetEntryPoint16(frame
->entry_cs
,frame
->entry_ip
,&ordinal
);
208 if (!RELAY_ShowDebugmsgRelay(funstr
)) return;
209 DPRINTF( "Ret %s() ",funstr
);
213 DPRINTF( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
214 ret_val
, frame
->cs
, frame
->ip
, frame
->ds
);
217 DPRINTF( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
218 ret_val
& 0xffff, frame
->cs
, frame
->ip
, frame
->ds
);
221 DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
222 (WORD
)CS_reg(context
), IP_reg(context
), (WORD
)DS_reg(context
));
223 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
224 AX_reg(context
), BX_reg(context
), CX_reg(context
),
225 DX_reg(context
), SI_reg(context
), DI_reg(context
),
226 (WORD
)ES_reg(context
), EFL_reg(context
) );
232 /***********************************************************************
233 * RELAY_Unimplemented16
235 * This function is called for unimplemented 16-bit entry points (declared
236 * as 'stub' in the spec file).
238 void RELAY_Unimplemented16(void)
241 STACK16FRAME
*frame
= CURRENT_STACK16
;
242 MSG("No handler for Win16 routine %s (called from %04x:%04x)\n",
243 BUILTIN_GetEntryPoint16(frame
->entry_cs
,frame
->entry_ip
,&ordinal
),
244 frame
->cs
, frame
->ip
);
249 /***********************************************************************
250 * RELAY_DebugCallTo16
252 * 'stack' points to the called function address on the 32-bit stack.
257 * (stack) func to call
259 void RELAY_DebugCallTo16( int* stack
, int nb_args
)
263 if (!TRACE_ON(relay
)) return;
264 thdb
= THREAD_Current();
266 if (nb_args
== -1) /* Register function */
268 CONTEXT
*context
= (CONTEXT
*)stack
[0];
269 WORD
*stack16
= (WORD
*)THREAD_STACK16(thdb
);
270 DPRINTF("CallTo16(func=%04lx:%04x,ds=%04lx",
271 CS_reg(context
), IP_reg(context
), DS_reg(context
) );
272 nb_args
= stack
[1] / sizeof(WORD
);
275 DPRINTF( ",0x%04x", *stack16
);
277 DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(thdb
->cur_stack
),
278 OFFSETOF(thdb
->cur_stack
) );
279 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x FS=%04x\n",
280 AX_reg(context
), BX_reg(context
), CX_reg(context
),
281 DX_reg(context
), SI_reg(context
), DI_reg(context
),
282 BP_reg(context
), (WORD
)ES_reg(context
), (WORD
)FS_reg(context
) );
286 DPRINTF("CallTo16(func=%04x:%04x,ds=%04x",
287 HIWORD(stack
[0]), LOWORD(stack
[0]),
288 SELECTOROF(thdb
->cur_stack
) );
291 DPRINTF(",0x%04x", *stack
);
294 DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(thdb
->cur_stack
),
295 OFFSETOF(thdb
->cur_stack
) );
300 /***********************************************************************
301 * RELAY_DebugCallTo16Ret
303 void RELAY_DebugCallTo16Ret( int ret_val
)
307 if (!TRACE_ON(relay
)) return;
308 thdb
= THREAD_Current();
310 DPRINTF("CallTo16() ss:sp=%04x:%04x retval=0x%08x\n",
311 SELECTOROF(thdb
->cur_stack
), OFFSETOF(thdb
->cur_stack
), ret_val
);
315 /**********************************************************************
319 * INT16 WINAPI Catch( LPCATCHBUF lpbuf );
321 void WINAPI
Catch16( CONTEXT
*context
)
327 VA_START16( valist
);
328 buf
= VA_ARG16( valist
, SEGPTR
);
329 lpbuf
= (LPCATCHBUF
)PTR_SEG_TO_LIN( buf
);
332 /* Note: we don't save the current ss, as the catch buffer is */
333 /* only 9 words long. Hopefully no one will have the silly */
334 /* idea to change the current stack before calling Throw()... */
348 lpbuf
[0] = IP_reg(context
);
349 lpbuf
[1] = CS_reg(context
);
350 /* Windows pushes 4 more words before saving sp */
351 lpbuf
[2] = SP_reg(context
) - 4 * sizeof(WORD
);
352 lpbuf
[3] = BP_reg(context
);
353 lpbuf
[4] = SI_reg(context
);
354 lpbuf
[5] = DI_reg(context
);
355 lpbuf
[6] = DS_reg(context
);
357 lpbuf
[8] = SS_reg(context
);
358 AX_reg(context
) = 0; /* Return 0 */
362 /**********************************************************************
366 * INT16 WINAPI Throw( LPCATCHBUF lpbuf, INT16 retval );
368 void WINAPI
Throw16( CONTEXT
*context
)
373 STACK16FRAME
*pFrame
;
374 STACK32FRAME
*frame32
;
375 THDB
*thdb
= THREAD_Current();
377 VA_START16( valist
);
378 AX_reg(context
) = VA_ARG16( valist
, WORD
); /* retval */
379 buf
= VA_ARG16( valist
, SEGPTR
);
380 lpbuf
= (LPCATCHBUF
)PTR_SEG_TO_LIN( buf
);
383 /* Find the frame32 corresponding to the frame16 we are jumping to */
384 pFrame
= THREAD_STACK16( thdb
);
385 frame32
= THREAD_STACK16( thdb
)->frame32
;
386 while (frame32
&& frame32
->frame16
)
388 if (OFFSETOF(frame32
->frame16
) < OFFSETOF(thdb
->cur_stack
))
389 break; /* Something strange is going on */
390 if (OFFSETOF(frame32
->frame16
) > lpbuf
[2])
392 /* We found the right frame */
393 pFrame
->frame32
= frame32
;
396 frame32
= ((STACK16FRAME
*)PTR_SEG_TO_LIN(frame32
->frame16
))->frame32
;
399 IP_reg(context
) = lpbuf
[0];
400 CS_reg(context
) = lpbuf
[1];
401 SP_reg(context
) = lpbuf
[2] + 4 * sizeof(WORD
) - sizeof(WORD
) /*extra arg*/;
402 BP_reg(context
) = lpbuf
[3];
403 SI_reg(context
) = lpbuf
[4];
404 DI_reg(context
) = lpbuf
[5];
405 DS_reg(context
) = lpbuf
[6];
407 if (lpbuf
[8] != SS_reg(context
))
408 ERR(relay
, "Switching stack segment with Throw() not supported; expect crash now\n" );
410 if (TRACE_ON(relay
)) /* Make sure we have a valid entry point address */
412 static FARPROC16 entryPoint
= NULL
;
414 if (!entryPoint
) /* Get entry point for Throw() */
415 entryPoint
= NE_GetEntryPoint( GetModuleHandle16("KERNEL"), 56 );
416 pFrame
->entry_cs
= SELECTOROF(entryPoint
);
417 pFrame
->entry_ip
= OFFSETOF(entryPoint
);
422 /**********************************************************************
425 * Helper for CallProc[Ex]32W
427 static DWORD
RELAY_CallProc32W(int Ex
)
429 DWORD nrofargs
, argconvmask
;
435 dbg_decl_str(relay
, 1024);
437 VA_START16( valist
);
438 nrofargs
= VA_ARG16( valist
, DWORD
);
439 argconvmask
= VA_ARG16( valist
, DWORD
);
440 proc32
= VA_ARG16( valist
, FARPROC
);
441 dsprintf(relay
, "CallProc32W(%ld,%ld,%p, Ex%d args[",nrofargs
,argconvmask
,proc32
,Ex
);
442 args
= (DWORD
*)HEAP_xalloc( GetProcessHeap(), 0,
443 sizeof(DWORD
)*nrofargs
);
444 /* CallProcEx doesn't need its args reversed */
445 for (i
=0;i
<nrofargs
;i
++) {
449 aix
= nrofargs
- i
- 1;
451 if (argconvmask
& (1<<i
))
453 SEGPTR ptr
= VA_ARG16( valist
, SEGPTR
);
454 args
[aix
] = (DWORD
)PTR_SEG_TO_LIN(ptr
);
455 dsprintf(relay
,"%08lx(%p),",ptr
,PTR_SEG_TO_LIN(ptr
));
459 args
[aix
] = VA_ARG16( valist
, DWORD
);
460 dsprintf(relay
,"%ld,",args
[aix
]);
463 dsprintf(relay
,"])");
466 if (!proc32
) ret
= 0;
467 else switch (nrofargs
)
469 case 0: ret
= proc32();
471 case 1: ret
= proc32(args
[0]);
473 case 2: ret
= proc32(args
[0],args
[1]);
475 case 3: ret
= proc32(args
[0],args
[1],args
[2]);
477 case 4: ret
= proc32(args
[0],args
[1],args
[2],args
[3]);
479 case 5: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4]);
481 case 6: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5]);
483 case 7: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6]);
485 case 8: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7]);
487 case 9: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8]);
489 case 10: ret
= proc32(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],args
[6],args
[7],args
[8],args
[9]);
491 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]);
494 /* FIXME: should go up to 32 arguments */
495 ERR(relay
,"Unsupported number of arguments %ld, please report.\n",nrofargs
);
499 /* POP nrofargs DWORD arguments and 3 DWORD parameters */
500 if (!Ex
) STACK16_POP( THREAD_Current(),
501 (3 + nrofargs
) * sizeof(DWORD
) );
503 TRACE(relay
,"%s - returns %08lx\n",dbg_str(relay
),ret
);
504 HeapFree( GetProcessHeap(), 0, args
);
509 /**********************************************************************
510 * CallProc32W (KERNEL.517)
512 DWORD WINAPI
CallProc32W_16()
514 return RELAY_CallProc32W(0);
518 /**********************************************************************
519 * CallProcEx32W() (KERNEL.518)
521 * C - style linkage to CallProc32W - caller pops stack.
523 DWORD WINAPI
CallProcEx32W_16()
525 return RELAY_CallProc32W(TRUE
);