2 * Copyright 1993 Robert J. Amstadt
3 * Copyright 1995 Alexandre Julliard
12 #include "stackframe.h"
17 /* #define DEBUG_RELAY */
21 /* Make make_debug think these were really used */
26 /***********************************************************************
29 BOOL32
RELAY_Init(void)
32 extern BOOL32
THUNK_Init(void);
34 /* Allocate the code selector for CallTo16 routines */
36 extern void CALLTO16_Start(), CALLTO16_End();
37 extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
38 extern DWORD CALLTO16_RetAddr_word
, CALLTO16_RetAddr_long
;
40 codesel
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)CALLTO16_Start
,
41 (int)CALLTO16_End
- (int)CALLTO16_Start
,
42 0, TRUE
, TRUE
, FALSE
, NULL
);
43 if (!codesel
) return FALSE
;
45 /* Patch the return addresses for CallTo16 routines */
47 CALLTO16_RetAddr_word
=MAKELONG( (int)CALLTO16_Ret_word
-(int)CALLTO16_Start
,
49 CALLTO16_RetAddr_long
=MAKELONG( (int)CALLTO16_Ret_long
-(int)CALLTO16_Start
,
52 /* Initialize thunking */
58 /***********************************************************************
59 * RELAY_DebugCallFrom16
61 void RELAY_DebugCallFrom16( int func_type
, char *args
,
62 void *entry_point
, CONTEXT
*context
)
69 if (!debugging_relay
) return;
71 frame
= CURRENT_STACK16
;
72 printf( "Call %s(", BUILTIN_GetEntryPoint16( frame
->entry_cs
,
75 args16
= (char *)frame
->args
;
76 for (i
= 0; i
< strlen(args
); i
++)
100 printf( "0x%04x", *(WORD
*)args16
);
104 printf( "0x%08x", *(int *)args16
);
108 printf( "0x%08x", *(int *)args16
);
109 if (HIWORD(*(int *)args16
))
110 printf( " \"%s\"", (char *)PTR_SEG_TO_LIN(*(int *)args16
) );
114 printf( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
118 printf( "%04x:%04x", *(WORD
*)(args16
+2), *(WORD
*)args16
);
119 if (HIWORD(*(int *)args16
))
120 printf( " \"%s\"", (char *)PTR_SEG_TO_LIN(*(int *)args16
) );
124 if (*args
) printf( "," );
126 printf( ") ret=%04x:%04x ds=%04x\n", frame
->cs
, frame
->ip
, frame
->ds
);
128 if (func_type
== 2) /* register function */
129 printf( " AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
130 AX_reg(context
), BX_reg(context
), CX_reg(context
),
131 DX_reg(context
), SI_reg(context
), DI_reg(context
),
132 (WORD
)ES_reg(context
), EFL_reg(context
) );
136 /***********************************************************************
137 * RELAY_DebugCallFrom16Ret
139 void RELAY_DebugCallFrom16Ret( int func_type
, int ret_val
, CONTEXT
*context
)
144 if (!debugging_relay
) return;
145 frame
= CURRENT_STACK16
;
146 printf( "Ret %s() ", BUILTIN_GetEntryPoint16( frame
->entry_cs
,
152 printf( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
153 ret_val
, frame
->cs
, frame
->ip
, frame
->ds
);
156 printf( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
157 ret_val
& 0xffff, frame
->cs
, frame
->ip
, frame
->ds
);
160 printf( "retval=none ret=%04x:%04x ds=%04x\n",
161 frame
->cs
, frame
->ip
, frame
->ds
);
162 printf( " AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
163 AX_reg(context
), BX_reg(context
), CX_reg(context
),
164 DX_reg(context
), SI_reg(context
), DI_reg(context
),
165 (WORD
)ES_reg(context
), EFL_reg(context
) );
171 /***********************************************************************
172 * RELAY_Unimplemented16
174 * This function is called for unimplemented 16-bit entry points (declared
175 * as 'stub' in the spec file).
177 void RELAY_Unimplemented16(void)
180 STACK16FRAME
*frame
= CURRENT_STACK16
;
181 fprintf(stderr
,"No handler for Win16 routine %s (called from %04x:%04x)\n",
182 BUILTIN_GetEntryPoint16(frame
->entry_cs
,frame
->entry_ip
,&ordinal
),
183 frame
->cs
, frame
->ip
);
184 TASK_KillCurrentTask(1);
188 /***********************************************************************
189 * RELAY_Unimplemented32
191 * This function is called for unimplemented 32-bit entry points (declared
192 * as 'stub' in the spec file).
193 * (The args are the same than for RELAY_DebugCallFrom32).
195 void RELAY_Unimplemented32( int nb_args
, void *relay_addr
,
196 void *entry_point
, int ebp
, int ret_addr
)
198 fprintf( stderr
, "No handler for Win32 routine %s (called from %08x)\n",
199 BUILTIN_GetEntryPoint32( relay_addr
), ret_addr
);
200 TASK_KillCurrentTask(1);
204 /***********************************************************************
205 * RELAY_DebugCallTo16
207 * 'stack' points to the called function address on the 32-bit stack.
212 * (stack) func to call
214 void RELAY_DebugCallTo16( int* stack
, int nb_args
)
216 if (!debugging_relay
) return;
218 if (nb_args
== -1) /* Register function */
220 CONTEXT
*context
= *(CONTEXT
**)stack
;
221 printf( "CallTo16(func=%04lx:%04x,ds=%04lx)\n",
222 CS_reg(context
), IP_reg(context
), DS_reg(context
) );
223 printf( " AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x\n",
224 AX_reg(context
), BX_reg(context
), CX_reg(context
),
225 DX_reg(context
), SI_reg(context
), DI_reg(context
),
226 BP_reg(context
), (WORD
)ES_reg(context
) );
230 printf( "CallTo16(func=%04x:%04x,ds=%04x",
231 HIWORD(stack
[0]), LOWORD(stack
[0]), CURRENT_DS
);
233 while (nb_args
--) printf( ",0x%04x", *stack
++ );
239 /***********************************************************************
240 * RELAY_DebugCallFrom32
242 * 'stack' points to the saved ebp on the stack.
249 * (stack-4) entry point
250 * (stack-8) relay addr
252 void RELAY_DebugCallFrom32( int *stack
, int nb_args
)
256 if (!debugging_relay
) return;
257 printf( "Call %s(", BUILTIN_GetEntryPoint32( (void *)stack
[-2] ));
258 for (i
= nb_args
& 0x7fffffff, parg
= &stack
[2]; i
; parg
++, i
--)
260 printf( "%08x", *parg
);
261 if (i
> 1) printf( "," );
263 printf( ") ret=%08x\n", stack
[1] );
264 if (nb_args
& 0x80000000) /* Register function */
266 CONTEXT
*context
= (CONTEXT
*)((BYTE
*)stack
- sizeof(CONTEXT
) - 8);
267 printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
268 context
->Eax
, context
->Ebx
, context
->Ecx
, context
->Edx
,
269 context
->Esi
, context
->Edi
);
270 printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
271 context
->Ebp
, context
->Esp
, context
->Eip
, context
->SegDs
,
272 context
->SegEs
, context
->SegFs
, context
->SegGs
,
278 /***********************************************************************
279 * RELAY_DebugCallFrom32Ret
281 * 'stack' points to the saved ebp on the stack.
288 * (stack-4) entry point
289 * (stack-8) relay addr
291 void RELAY_DebugCallFrom32Ret( int *stack
, int nb_args
, int ret_val
)
293 if (!debugging_relay
) return;
294 printf( "Ret %s() retval=%08x ret=%08x\n",
295 BUILTIN_GetEntryPoint32( (void *)stack
[-2] ), ret_val
, stack
[1] );
296 if (nb_args
& 0x80000000) /* Register function */
298 CONTEXT
*context
= (CONTEXT
*)((BYTE
*)stack
- sizeof(CONTEXT
) - 8);
299 printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
300 context
->Eax
, context
->Ebx
, context
->Ecx
, context
->Edx
,
301 context
->Esi
, context
->Edi
);
302 printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
303 context
->Ebp
, context
->Esp
, context
->Eip
, context
->SegDs
,
304 context
->SegEs
, context
->SegFs
, context
->SegGs
,
310 /***********************************************************************
311 * RELAY_DebugCallTo32
313 void RELAY_DebugCallTo32( unsigned int func
, int nbargs
, unsigned int arg1
)
315 unsigned int *argptr
;
317 if (!debugging_relay
) return;
319 printf( "CallTo32(func=%08x", func
);
320 for (argptr
= &arg1
; nbargs
; nbargs
--, argptr
++)
321 printf( ",%08x", *argptr
);
326 /**********************************************************************
329 INT16
Catch( LPCATCHBUF lpbuf
)
331 STACK16FRAME
*pFrame
= CURRENT_STACK16
;
333 /* Note: we don't save the current ss, as the catch buffer is */
334 /* only 9 words long. Hopefully no one will have the silly */
335 /* idea to change the current stack before calling Throw()... */
348 /* FIXME: we need to save %si and %di */
350 lpbuf
[0] = OFFSETOF(IF1632_Saved16_ss_sp
);
351 lpbuf
[1] = LOWORD(IF1632_Saved32_esp
);
352 lpbuf
[2] = HIWORD(IF1632_Saved32_esp
);
353 lpbuf
[3] = LOWORD(pFrame
->saved_ss_sp
);
354 lpbuf
[4] = HIWORD(pFrame
->saved_ss_sp
);
355 lpbuf
[5] = pFrame
->ds
;
356 lpbuf
[6] = pFrame
->bp
;
357 lpbuf
[7] = pFrame
->ip
;
358 lpbuf
[8] = pFrame
->cs
;
363 /**********************************************************************
366 INT16
Throw( LPCATCHBUF lpbuf
, INT16 retval
)
368 STACK16FRAME
*pFrame
;
369 WORD es
= CURRENT_STACK16
->es
;
371 IF1632_Saved16_ss_sp
= MAKELONG( lpbuf
[0] - sizeof(WORD
),
372 HIWORD(IF1632_Saved16_ss_sp
) );
373 IF1632_Saved32_esp
= MAKELONG( lpbuf
[1], lpbuf
[2] );
374 pFrame
= CURRENT_STACK16
;
375 pFrame
->saved_ss_sp
= MAKELONG( lpbuf
[3], lpbuf
[4] );
376 pFrame
->ds
= lpbuf
[5];
377 pFrame
->bp
= lpbuf
[6];
378 pFrame
->ip
= lpbuf
[7];
379 pFrame
->cs
= lpbuf
[8];
381 if (debugging_relay
) /* Make sure we have a valid entry point address */
383 static FARPROC16 entryPoint
= NULL
;
385 if (!entryPoint
) /* Get entry point for Throw() */
386 entryPoint
= MODULE_GetEntryPoint( GetModuleHandle16("KERNEL"),
388 pFrame
->entry_cs
= SELECTOROF(entryPoint
);
389 pFrame
->entry_ip
= OFFSETOF(entryPoint
);
394 /**********************************************************************
395 * CallProc32W (KERNEL.56)
398 WIN16_CallProc32W() {
399 DWORD
*win_stack
= (DWORD
*)CURRENT_STACK16
->args
;
400 DWORD nrofargs
= win_stack
[0];
401 DWORD argconvmask
= win_stack
[1];
402 FARPROC32 proc32
= (FARPROC32
)win_stack
[2];
407 fprintf(stderr
,"CallProc32W(%ld,%ld,%p,args[",nrofargs
,argconvmask
,proc32
);
408 args
= (DWORD
*)xmalloc(sizeof(DWORD
)*nrofargs
);
409 for (i
=nrofargs
;i
--;) {
410 if (argconvmask
& (1<<i
)) {
411 args
[nrofargs
-i
-1] = (DWORD
)PTR_SEG_TO_LIN(win_stack
[3+i
]);
412 fprintf(stderr
,"%08lx(%p),",win_stack
[3+i
],PTR_SEG_TO_LIN(win_stack
[3+i
]));
414 args
[nrofargs
-i
-1] = win_stack
[3+i
];
415 fprintf(stderr
,"%ld,",win_stack
[3+i
]);
418 fprintf(stderr
,"]) - ");
420 case 0: ret
= CallTo32_0(proc32
);
422 case 1: ret
= CallTo32_1(proc32
,args
[0]);
424 case 2: ret
= CallTo32_2(proc32
,args
[0],args
[1]);
426 case 3: ret
= CallTo32_3(proc32
,args
[0],args
[1],args
[2]);
428 case 4: ret
= CallTo32_4(proc32
,args
[0],args
[1],args
[2],args
[3]);
430 case 5: ret
= CallTo32_5(proc32
,args
[0],args
[1],args
[2],args
[3],args
[4]);
433 /* FIXME: should go up to 32 arguments */
434 fprintf(stderr
,"CallProc32W: unsupported number of arguments %ld, please report.\n",nrofargs
);
438 /* POP nrofargs DWORD arguments and 3 DWORD parameters */
439 /* FIXME: this is a BAD hack, but I don't see any other way to
440 * pop a variable number of arguments. -MM
441 * The -2 in the size is for not copying WORD args[0] (which would
442 * overwrite the top WORD on the return stack)
444 memcpy(&stf16
,CURRENT_STACK16
,sizeof(stf16
)-2);
445 IF1632_Saved16_ss_sp
+= (3+nrofargs
)*sizeof(DWORD
);
446 memcpy(CURRENT_STACK16
,&stf16
,sizeof(stf16
)-2);
448 fprintf(stderr
,"returns %08lx\n",ret
);