2 * Copyright 1993 Robert J. Amstadt
3 * Copyright 1995 Alexandre Julliard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include "wine/winbase16.h"
28 #include "stackframe.h"
29 #include "selectors.h"
30 #include "builtin16.h"
32 #include "wine/library.h"
33 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(relay);
37 /***********************************************************************
45 /* Allocate the code selector for CallTo16 routines */
47 extern void Call16_Ret_Start(), Call16_Ret_End();
48 extern void CallTo16_Ret();
49 extern void CALL32_CBClient_Ret();
50 extern void CALL32_CBClientEx_Ret();
51 extern SEGPTR CallTo16_RetAddr;
52 extern DWORD CallTo16_DataSelector;
53 extern SEGPTR CALL32_CBClient_RetAddr;
54 extern SEGPTR CALL32_CBClientEx_RetAddr;
56 codesel = SELECTOR_AllocBlock( (void *)Call16_Ret_Start,
57 (char *)Call16_Ret_End - (char *)Call16_Ret_Start,
58 WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
59 if (!codesel) return FALSE;
61 /* Patch the return addresses for CallTo16 routines */
63 CallTo16_DataSelector = wine_get_ds();
65 MAKESEGPTR( codesel, (char*)CallTo16_Ret - (char*)Call16_Ret_Start );
66 CALL32_CBClient_RetAddr =
67 MAKESEGPTR( codesel, (char*)CALL32_CBClient_Ret - (char*)Call16_Ret_Start );
68 CALL32_CBClientEx_RetAddr =
69 MAKESEGPTR( codesel, (char*)CALL32_CBClientEx_Ret - (char*)Call16_Ret_Start );
75 * Stubs for the CallTo16/CallFrom16 routines on non-Intel architectures
76 * (these will never be called but need to be present to satisfy the linker ...)
79 /***********************************************************************
80 * wine_call_to_16_word (KERNEL32.@)
82 WORD WINAPI wine_call_to_16_word( FARPROC16 target, INT nArgs )
87 /***********************************************************************
88 * wine_call_to_16_long (KERNEL32.@)
90 LONG WINAPI wine_call_to_16_long( FARPROC16 target, INT nArgs )
95 /***********************************************************************
96 * wine_call_to_16_regs_short (KERNEL32.@)
98 void WINAPI wine_call_to_16_regs_short( CONTEXT86 *context, INT nArgs )
103 /***********************************************************************
104 * wine_call_to_16_regs_long (KERNEL32.@)
106 void WINAPI wine_call_to_16_regs_long ( CONTEXT86 *context, INT nArgs )
111 /***********************************************************************
112 * __wine_call_from_16_word (KERNEL32.@)
114 WORD __wine_call_from_16_word()
119 /***********************************************************************
120 * __wine_call_from_16_long (KERNEL32.@)
122 LONG __wine_call_from_16_long()
127 /***********************************************************************
128 * __wine_call_from_16_regs (KERNEL32.@)
130 void __wine_call_from_16_regs()
135 DWORD WINAPI CALL32_CBClient( FARPROC proc, LPWORD args, DWORD *esi )
138 DWORD WINAPI CALL32_CBClientEx( FARPROC proc, LPWORD args, DWORD *esi, INT *nArgs )
143 /***********************************************************************
144 * RELAY_ShowDebugmsgRelay
146 * Simple function to decide if a particular debugging message is
149 static int RELAY_ShowDebugmsgRelay(const char *func)
151 /* from relay32/relay386.c */
152 extern const char **debug_relay_excludelist,**debug_relay_includelist;
154 if(debug_relay_excludelist || debug_relay_includelist) {
155 const char *term = strchr(func, ':');
156 const char **listitem;
157 int len, len2, itemlen, show;
159 if(debug_relay_excludelist) {
161 listitem = debug_relay_excludelist;
164 listitem = debug_relay_includelist;
167 assert(strlen(term) > 2);
169 len2 = strchr(func, '.') - func;
170 assert(len2 && len2 > 0 && len2 < 64);
172 for(; *listitem; listitem++) {
173 itemlen = strlen(*listitem);
174 if((itemlen == len && !strncasecmp(*listitem, func, len)) ||
175 (itemlen == len2 && !strncasecmp(*listitem, func, len2)) ||
176 !strcasecmp(*listitem, term)) {
187 /***********************************************************************
190 * Return the ordinal, name, and type info corresponding to a CS:IP address.
192 static const CALLFROM16 *get_entry_point( STACK16FRAME *frame, LPSTR name, WORD *pOrd )
200 if (!(pModule = NE_GetPtr( FarGetOwner16( GlobalHandle16( frame->module_cs ) ))))
205 bundle = (ET_BUNDLE *)((BYTE *)pModule + pModule->entry_table);
208 entry = (ET_ENTRY *)((BYTE *)bundle+6);
209 for (i = bundle->first + 1; i <= bundle->last; i++)
211 if ((entry->offs < frame->entry_ip)
212 && (entry->segnum == 1) /* code segment ? */
213 && (entry->offs >= max_offset))
215 max_offset = entry->offs;
220 } while ( (bundle->next)
221 && (bundle = (ET_BUNDLE *)((BYTE *)pModule+bundle->next)));
223 /* Search for the name in the resident names table */
224 /* (built-in modules have no non-resident table) */
226 p = (BYTE *)pModule + pModule->name_table;
229 p += *p + 1 + sizeof(WORD);
230 if (*(WORD *)(p + *p + 1) == *pOrd) break;
233 sprintf( name, "%.*s.%d: %.*s",
234 *((BYTE *)pModule + pModule->name_table),
235 (char *)pModule + pModule->name_table + 1,
236 *pOrd, *p, (char *)(p + 1) );
238 /* Retrieve entry point call structure */
239 p = MapSL( MAKESEGPTR( frame->module_cs, frame->callfrom_ip ) );
240 /* p now points to lret, get the start of CALLFROM16 structure */
241 return (CALLFROM16 *)(p - (BYTE *)&((CALLFROM16 *)0)->lret);
245 /***********************************************************************
246 * RELAY_DebugCallFrom16
248 void RELAY_DebugCallFrom16( CONTEXT86 *context )
252 char *args16, funstr[80];
253 const CALLFROM16 *call;
256 if (!TRACE_ON(relay)) return;
258 frame = CURRENT_STACK16;
259 call = get_entry_point( frame, funstr, &ordinal );
260 if (!call) return; /* happens for the two snoop register relays */
261 if (!RELAY_ShowDebugmsgRelay(funstr)) return;
262 DPRINTF( "%08lx:Call %s(",GetCurrentThreadId(),funstr);
263 VA_START16( args16 );
265 if (call->lret == 0xcb66) /* cdecl */
267 for (i = 0; i < 20; i++)
269 int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
271 if (type == ARG_NONE) break;
272 if (i) DPRINTF( "," );
277 DPRINTF( "%04x", *(WORD *)args16 );
278 args16 += sizeof(WORD);
281 DPRINTF( "%08x", *(int *)args16 );
282 args16 += sizeof(int);
285 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
286 args16 += sizeof(SEGPTR);
289 DPRINTF( "%08x %s", *(int *)args16,
290 debugstr_a( MapSL(*(SEGPTR *)args16 )));
291 args16 += sizeof(int);
294 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
295 debugstr_a( MapSL(*(SEGPTR *)args16 )) );
296 args16 += sizeof(SEGPTR);
305 /* Start with the last arg */
306 args16 += call->nArgs;
307 for (i = 0; i < 20; i++)
309 int type = (call->arg_types[i / 10] >> (3 * (i % 10))) & 7;
311 if (type == ARG_NONE) break;
312 if (i) DPRINTF( "," );
317 args16 -= sizeof(WORD);
318 DPRINTF( "%04x", *(WORD *)args16 );
321 args16 -= sizeof(int);
322 DPRINTF( "%08x", *(int *)args16 );
325 args16 -= sizeof(SEGPTR);
326 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
329 args16 -= sizeof(int);
330 DPRINTF( "%08x %s", *(int *)args16,
331 debugstr_a( MapSL(*(SEGPTR *)args16 )));
334 args16 -= sizeof(SEGPTR);
335 DPRINTF( "%04x:%04x %s", *(WORD *)(args16+2), *(WORD *)args16,
336 debugstr_a( MapSL(*(SEGPTR *)args16 )) );
344 DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
347 if (call->arg_types[0] & ARG_REGISTER)
348 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
349 AX_reg(context), BX_reg(context), CX_reg(context),
350 DX_reg(context), SI_reg(context), DI_reg(context),
351 (WORD)context->SegEs, context->EFlags );
353 SYSLEVEL_CheckNotLevel( 2 );
357 /***********************************************************************
358 * RELAY_DebugCallFrom16Ret
360 void RELAY_DebugCallFrom16Ret( CONTEXT86 *context, int ret_val )
365 const CALLFROM16 *call;
367 if (!TRACE_ON(relay)) return;
368 frame = CURRENT_STACK16;
369 call = get_entry_point( frame, funstr, &ordinal );
371 if (!RELAY_ShowDebugmsgRelay(funstr)) return;
372 DPRINTF( "%08lx:Ret %s() ",GetCurrentThreadId(),funstr);
374 if (call->arg_types[0] & ARG_REGISTER)
376 DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
377 (WORD)context->SegCs, LOWORD(context->Eip), (WORD)context->SegDs);
378 DPRINTF(" AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
379 AX_reg(context), BX_reg(context), CX_reg(context),
380 DX_reg(context), SI_reg(context), DI_reg(context),
381 (WORD)context->SegEs, context->EFlags );
383 else if (call->arg_types[0] & ARG_RET16)
385 DPRINTF( "retval=%04x ret=%04x:%04x ds=%04x\n",
386 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
390 DPRINTF( "retval=%08x ret=%04x:%04x ds=%04x\n",
391 ret_val, frame->cs, frame->ip, frame->ds );
393 SYSLEVEL_CheckNotLevel( 2 );
397 /***********************************************************************
398 * RELAY_DebugCallTo16
400 * 'target' contains either the function to call (normal CallTo16)
401 * or a pointer to the CONTEXT86 struct (register CallTo16).
402 * 'nb_args' is the number of argument bytes on the 16-bit stack;
403 * 'reg_func' specifies whether we have a register CallTo16 or not.
405 void RELAY_DebugCallTo16( LPVOID target, int nb_args, BOOL reg_func )
410 if (!TRACE_ON(relay)) return;
411 teb = NtCurrentTeb();
412 stack16 = (WORD *)THREAD_STACK16(teb);
414 nb_args /= sizeof(WORD);
418 CONTEXT86 *context = (CONTEXT86 *)target;
420 DPRINTF("%08lx:CallTo16(func=%04lx:%04x,ds=%04lx",
421 GetCurrentThreadId(),
422 context->SegCs, LOWORD(context->Eip), context->SegDs );
423 while (nb_args--) DPRINTF( ",%04x", *--stack16 );
424 DPRINTF(") ss:sp=%04x:%04x", SELECTOROF(teb->cur_stack),
425 OFFSETOF(teb->cur_stack) );
426 DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x bp=%04x es=%04x fs=%04x\n",
427 AX_reg(context), BX_reg(context), CX_reg(context),
428 DX_reg(context), SI_reg(context), DI_reg(context),
429 BP_reg(context), (WORD)context->SegEs, (WORD)context->SegFs );
433 DPRINTF("%08lx:CallTo16(func=%04x:%04x,ds=%04x",
434 GetCurrentThreadId(),
435 HIWORD(target), LOWORD(target), SELECTOROF(teb->cur_stack) );
436 while (nb_args--) DPRINTF( ",%04x", *--stack16 );
437 DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(teb->cur_stack),
438 OFFSETOF(teb->cur_stack) );
441 SYSLEVEL_CheckNotLevel( 2 );
445 /***********************************************************************
446 * RELAY_DebugCallTo16Ret
448 void RELAY_DebugCallTo16Ret( BOOL reg_func, int ret_val )
450 if (!TRACE_ON(relay)) return;
454 DPRINTF("%08lx:RetFrom16() ss:sp=%04x:%04x retval=%08x\n",
455 GetCurrentThreadId(),
456 SELECTOROF(NtCurrentTeb()->cur_stack),
457 OFFSETOF(NtCurrentTeb()->cur_stack), ret_val);
461 CONTEXT86 *context = (CONTEXT86 *)ret_val;
463 DPRINTF("%08lx:RetFrom16() ss:sp=%04x:%04x ",
464 GetCurrentThreadId(),
465 SELECTOROF(NtCurrentTeb()->cur_stack),
466 OFFSETOF(NtCurrentTeb()->cur_stack));
467 DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n",
468 AX_reg(context), BX_reg(context), CX_reg(context),
469 DX_reg(context), BP_reg(context), LOWORD(context->Esp));
472 SYSLEVEL_CheckNotLevel( 2 );