2 * 386-specific Win32 relay functions
4 * Copyright 1997 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
29 #include "stackframe.h"
30 #include "wine/unicode.h"
31 #include "wine/debug.h"
32 #include "ntdll_misc.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(relay
);
35 WINE_DECLARE_DEBUG_CHANNEL(snoop
);
37 const char **debug_relay_excludelist
= NULL
;
38 const char **debug_relay_includelist
= NULL
;
39 const char **debug_snoop_excludelist
= NULL
;
40 const char **debug_snoop_includelist
= NULL
;
42 static const char **debug_from_relay_excludelist
;
43 static const char **debug_from_relay_includelist
;
45 /***********************************************************************
48 * Build a function list from a ';'-separated string.
50 static const char **build_list( const WCHAR
*bufferW
)
54 const char *p
= buffer
;
57 RtlUnicodeToMultiByteN( buffer
, sizeof(buffer
), NULL
,
58 bufferW
, (strlenW(bufferW
)+1) * sizeof(WCHAR
) );
60 while ((p
= strchr( p
, ';' )))
65 /* allocate count+1 pointers, plus the space for a copy of the string */
66 if ((ret
= RtlAllocateHeap( ntdll_get_process_heap(), 0, (count
+1) * sizeof(char*) + strlen(buffer
) + 1 )))
68 char *str
= (char *)(ret
+ count
+ 1);
71 strcpy( str
, buffer
);
76 if (!(p
= strchr( p
, ';' ))) break;
85 /***********************************************************************
86 * RELAY_InitDebugLists
88 * Build the relay include/exclude function lists.
90 void RELAY_InitDebugLists(void)
92 OBJECT_ATTRIBUTES attr
;
98 static const WCHAR configW
[] = {'M','a','c','h','i','n','e','\\',
99 'S','o','f','t','w','a','r','e','\\',
100 'W','i','n','e','\\',
101 'W','i','n','e','\\',
102 'C','o','n','f','i','g','\\',
103 'D','e','b','u','g',0};
104 static const WCHAR RelayIncludeW
[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0};
105 static const WCHAR RelayExcludeW
[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0};
106 static const WCHAR SnoopIncludeW
[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0};
107 static const WCHAR SnoopExcludeW
[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0};
108 static const WCHAR RelayFromIncludeW
[] = {'R','e','l','a','y','F','r','o','m','I','n','c','l','u','d','e',0};
109 static const WCHAR RelayFromExcludeW
[] = {'R','e','l','a','y','F','r','o','m','E','x','c','l','u','d','e',0};
111 attr
.Length
= sizeof(attr
);
112 attr
.RootDirectory
= 0;
113 attr
.ObjectName
= &name
;
115 attr
.SecurityDescriptor
= NULL
;
116 attr
.SecurityQualityOfService
= NULL
;
117 RtlInitUnicodeString( &name
, configW
);
119 if (NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
)) return;
121 str
= (WCHAR
*)((KEY_VALUE_PARTIAL_INFORMATION
*)buffer
)->Data
;
122 RtlInitUnicodeString( &name
, RelayIncludeW
);
123 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
125 TRACE("RelayInclude = %s\n", debugstr_w(str
) );
126 debug_relay_includelist
= build_list( str
);
129 RtlInitUnicodeString( &name
, RelayExcludeW
);
130 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
132 TRACE( "RelayExclude = %s\n", debugstr_w(str
) );
133 debug_relay_excludelist
= build_list( str
);
136 RtlInitUnicodeString( &name
, SnoopIncludeW
);
137 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
139 TRACE_(snoop
)( "SnoopInclude = %s\n", debugstr_w(str
) );
140 debug_snoop_includelist
= build_list( str
);
143 RtlInitUnicodeString( &name
, SnoopExcludeW
);
144 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
146 TRACE_(snoop
)( "SnoopExclude = %s\n", debugstr_w(str
) );
147 debug_snoop_excludelist
= build_list( str
);
150 RtlInitUnicodeString( &name
, RelayFromIncludeW
);
151 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
153 TRACE("RelayFromInclude = %s\n", debugstr_w(str
) );
154 debug_from_relay_includelist
= build_list( str
);
157 RtlInitUnicodeString( &name
, RelayFromExcludeW
);
158 if (!NtQueryValueKey( hkey
, &name
, KeyValuePartialInformation
, buffer
, sizeof(buffer
), &count
))
160 TRACE( "RelayFromExclude = %s\n", debugstr_w(str
) );
161 debug_from_relay_excludelist
= build_list( str
);
172 BYTE call
; /* 0xe8 call callfrom32 (relative) */
173 DWORD callfrom32 WINE_PACKED
; /* RELAY_CallFrom32 relative addr */
174 BYTE ret
; /* 0xc2 ret $n or 0xc3 ret */
175 WORD args
; /* nb of args to remove from the stack */
176 void *orig
; /* original entry point */
177 DWORD argtypes
; /* argument types */
181 /***********************************************************************
182 * check_relay_include
184 * Check if a given function must be included in the relay output.
186 static BOOL
check_relay_include( const char *module
, const char *func
)
188 const char **listitem
;
191 if (!debug_relay_excludelist
&& !debug_relay_includelist
) return TRUE
;
192 if (debug_relay_excludelist
)
195 listitem
= debug_relay_excludelist
;
200 listitem
= debug_relay_includelist
;
202 for(; *listitem
; listitem
++)
204 char *p
= strrchr( *listitem
, '.' );
205 if (p
&& p
> *listitem
) /* check module and function */
207 int len
= p
- *listitem
;
208 if (strncasecmp( *listitem
, module
, len
-1 ) || module
[len
]) continue;
209 if (!strcmp( p
+ 1, func
) || !strcmp( p
+ 1, "*" )) return !show
;
211 else /* function only */
213 if (!strcmp( *listitem
, func
)) return !show
;
220 /***********************************************************************
221 * check_relay_from_module
223 * Check if calls from a given module must be included in the relay output.
225 static BOOL
check_relay_from_module( const char *module
)
227 const char **listitem
;
230 if (!debug_from_relay_excludelist
&& !debug_from_relay_includelist
) return TRUE
;
231 if (debug_from_relay_excludelist
)
234 listitem
= debug_from_relay_excludelist
;
239 listitem
= debug_from_relay_includelist
;
241 for(; *listitem
; listitem
++)
245 if (!strcasecmp( *listitem
, module
)) return !show
;
246 len
= strlen( *listitem
);
247 if (!strncasecmp( *listitem
, module
, len
) && !strcasecmp( module
+ len
, ".dll" ))
254 /***********************************************************************
257 * Find the name of an exported function.
259 static const char *find_exported_name( const char *module
,
260 IMAGE_EXPORT_DIRECTORY
*exp
, int ordinal
)
263 const char *ret
= NULL
;
265 WORD
*ordptr
= (WORD
*)(module
+ exp
->AddressOfNameOrdinals
);
266 for (i
= 0; i
< exp
->NumberOfNames
; i
++, ordptr
++)
267 if (*ordptr
+ exp
->Base
== ordinal
) break;
268 if (i
< exp
->NumberOfNames
)
269 ret
= module
+ ((DWORD
*)(module
+ exp
->AddressOfNames
))[i
];
274 /***********************************************************************
277 * Get the name of the DLL entry point corresponding to a relay address.
279 static void get_entry_point( char *buffer
, DEBUG_ENTRY_POINT
*relay
)
281 IMAGE_EXPORT_DIRECTORY
*exp
= NULL
;
282 DEBUG_ENTRY_POINT
*debug
;
283 char *p
, *base
= NULL
;
286 PLIST_ENTRY mark
, entry
;
287 PLDR_MODULE mod
= NULL
;
290 /* First find the module */
292 mark
= &NtCurrentTeb()->Peb
->LdrData
->InLoadOrderModuleList
;
293 for (entry
= mark
->Flink
; entry
!= mark
; entry
= entry
->Flink
)
295 mod
= CONTAINING_RECORD(entry
, LDR_MODULE
, InLoadOrderModuleList
);
296 if (!(mod
->Flags
& LDR_WINE_INTERNAL
)) continue;
297 exp
= RtlImageDirectoryEntryToData( mod
->BaseAddress
, TRUE
, IMAGE_DIRECTORY_ENTRY_EXPORT
, &size
);
299 debug
= (DEBUG_ENTRY_POINT
*)((char *)exp
+ size
);
300 if (debug
<= relay
&& relay
< debug
+ exp
->NumberOfFunctions
)
302 ordinal
= relay
- debug
;
307 /* Now find the function */
309 base
= (char *)mod
->BaseAddress
;
310 strcpy( buffer
, base
+ exp
->Name
);
311 p
= buffer
+ strlen(buffer
);
312 if (p
> buffer
+ 4 && !strcasecmp( p
- 4, ".dll" )) p
-= 4;
314 if ((name
= find_exported_name( base
, exp
, ordinal
+ exp
->Base
)))
315 sprintf( p
, ".%s", name
);
317 sprintf( p
, ".%ld", ordinal
+ exp
->Base
);
321 /***********************************************************************
324 static inline void RELAY_PrintArgs( int *args
, int nb_args
, unsigned int typemask
)
328 if ((typemask
& 3) && HIWORD(*args
))
331 DPRINTF( "%08x %s", *args
, debugstr_w((LPWSTR
)*args
) );
333 DPRINTF( "%08x %s", *args
, debugstr_a((LPCSTR
)*args
) );
335 else DPRINTF( "%08x", *args
);
336 if (nb_args
) DPRINTF( "," );
343 typedef LONGLONG (*LONGLONG_CPROC
)();
344 typedef LONGLONG (WINAPI
*LONGLONG_FARPROC
)();
347 /***********************************************************************
348 * call_cdecl_function
350 static LONGLONG
call_cdecl_function( LONGLONG_CPROC func
, int nb_args
, const int *args
)
355 case 0: ret
= func(); break;
356 case 1: ret
= func(args
[0]); break;
357 case 2: ret
= func(args
[0],args
[1]); break;
358 case 3: ret
= func(args
[0],args
[1],args
[2]); break;
359 case 4: ret
= func(args
[0],args
[1],args
[2],args
[3]); break;
360 case 5: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4]); break;
361 case 6: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],
363 case 7: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
365 case 8: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
366 args
[6],args
[7]); break;
367 case 9: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
368 args
[6],args
[7],args
[8]); break;
369 case 10: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
370 args
[6],args
[7],args
[8],args
[9]); break;
371 case 11: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
372 args
[6],args
[7],args
[8],args
[9],args
[10]); break;
373 case 12: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
374 args
[6],args
[7],args
[8],args
[9],args
[10],
376 case 13: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
377 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
379 case 14: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
380 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
381 args
[12],args
[13]); break;
382 case 15: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
383 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
384 args
[12],args
[13],args
[14]); break;
385 case 16: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
386 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
387 args
[12],args
[13],args
[14],args
[15]); break;
389 ERR( "Unsupported nb of args %d\n", nb_args
);
398 /***********************************************************************
399 * call_stdcall_function
401 static LONGLONG
call_stdcall_function( LONGLONG_FARPROC func
, int nb_args
, const int *args
)
406 case 0: ret
= func(); break;
407 case 1: ret
= func(args
[0]); break;
408 case 2: ret
= func(args
[0],args
[1]); break;
409 case 3: ret
= func(args
[0],args
[1],args
[2]); break;
410 case 4: ret
= func(args
[0],args
[1],args
[2],args
[3]); break;
411 case 5: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4]); break;
412 case 6: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],
414 case 7: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
416 case 8: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
417 args
[6],args
[7]); break;
418 case 9: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
419 args
[6],args
[7],args
[8]); break;
420 case 10: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
421 args
[6],args
[7],args
[8],args
[9]); break;
422 case 11: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
423 args
[6],args
[7],args
[8],args
[9],args
[10]); break;
424 case 12: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
425 args
[6],args
[7],args
[8],args
[9],args
[10],
427 case 13: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
428 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
430 case 14: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
431 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
432 args
[12],args
[13]); break;
433 case 15: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
434 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
435 args
[12],args
[13],args
[14]); break;
436 case 16: ret
= func(args
[0],args
[1],args
[2],args
[3],args
[4],args
[5],
437 args
[6],args
[7],args
[8],args
[9],args
[10],args
[11],
438 args
[12],args
[13],args
[14],args
[15]); break;
440 ERR( "Unsupported nb of args %d\n", nb_args
);
449 /***********************************************************************
452 * Stack layout on entry to this function:
457 * (esp) return addr to relay code
459 static LONGLONG
RELAY_CallFrom32( int ret_addr
, ... )
464 int *args
= &ret_addr
+ 1;
465 /* Relay addr is the return address for this function */
466 BYTE
*relay_addr
= (BYTE
*)__builtin_return_address(0);
467 DEBUG_ENTRY_POINT
*relay
= (DEBUG_ENTRY_POINT
*)(relay_addr
- 5);
468 WORD nb_args
= relay
->args
/ sizeof(int);
472 get_entry_point( buffer
, relay
);
474 DPRINTF( "%04lx:Call %s(", GetCurrentThreadId(), buffer
);
475 RELAY_PrintArgs( args
, nb_args
, relay
->argtypes
);
476 DPRINTF( ") ret=%08x\n", ret_addr
);
479 if (relay
->ret
== 0xc3) /* cdecl */
481 ret
= call_cdecl_function( (LONGLONG_CPROC
)relay
->orig
, nb_args
, args
);
485 ret
= call_stdcall_function( (LONGLONG_FARPROC
)relay
->orig
, nb_args
, args
);
490 BOOL ret64
= (relay
->argtypes
& 0x80000000) && (nb_args
< 16);
492 DPRINTF( "%04lx:Ret %s() retval=%08x%08x ret=%08x\n",
493 GetCurrentThreadId(),
494 buffer
, (UINT
)(ret
>> 32), (UINT
)ret
, ret_addr
);
496 DPRINTF( "%04lx:Ret %s() retval=%08x ret=%08x\n",
497 GetCurrentThreadId(),
498 buffer
, (UINT
)ret
, ret_addr
);
504 /***********************************************************************
505 * RELAY_CallFrom32Regs
507 * Stack layout (esp is context->Esp, not the current %esp):
511 * (esp) return addr to caller
512 * (esp-4) return addr to DEBUG_ENTRY_POINT
513 * (esp-8) ptr to relay entry code for RELAY_CallFrom32Regs
514 * ... >128 bytes space free to be modified (ensured by the assembly glue)
516 void WINAPI
RELAY_DoCallFrom32Regs( CONTEXT86
*context
)
523 BYTE
*relay_addr
= *((BYTE
**)context
->Esp
- 1);
524 DEBUG_ENTRY_POINT
*relay
= (DEBUG_ENTRY_POINT
*)(relay_addr
- 5);
525 WORD nb_args
= relay
->args
/ sizeof(int);
527 /* remove extra stuff from the stack */
528 context
->Eip
= stack32_pop(context
);
529 args
= (int *)context
->Esp
;
530 if (relay
->ret
== 0xc2) /* stdcall */
531 context
->Esp
+= nb_args
* sizeof(int);
533 entry_point
= (BYTE
*)relay
->orig
;
534 assert( *entry_point
== 0xe8 /* lcall */ );
538 get_entry_point( buffer
, relay
);
540 DPRINTF( "%04lx:Call %s(", GetCurrentThreadId(), buffer
);
541 RELAY_PrintArgs( args
, nb_args
, relay
->argtypes
);
542 DPRINTF( ") ret=%08lx fs=%04lx\n", context
->Eip
, context
->SegFs
);
544 DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
545 context
->Eax
, context
->Ebx
, context
->Ecx
,
546 context
->Edx
, context
->Esi
, context
->Edi
);
547 DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx gs=%04lx flags=%08lx\n",
548 context
->Ebp
, context
->Esp
, context
->SegDs
,
549 context
->SegEs
, context
->SegGs
, context
->EFlags
);
552 /* Now call the real function */
554 memcpy( args_copy
, args
, nb_args
* sizeof(args
[0]) );
555 args_copy
[nb_args
] = (int)context
; /* append context argument */
556 if (relay
->ret
== 0xc3) /* cdecl */
558 call_cdecl_function( *(LONGLONG_CPROC
*)(entry_point
+ 5), nb_args
+1, args_copy
);
562 call_stdcall_function( *(LONGLONG_FARPROC
*)(entry_point
+ 5), nb_args
+1, args_copy
);
567 DPRINTF( "%04lx:Ret %s() retval=%08lx ret=%08lx fs=%04lx\n",
568 GetCurrentThreadId(),
569 buffer
, context
->Eax
, context
->Eip
, context
->SegFs
);
571 DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
572 context
->Eax
, context
->Ebx
, context
->Ecx
,
573 context
->Edx
, context
->Esi
, context
->Edi
);
574 DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx gs=%04lx flags=%08lx\n",
575 context
->Ebp
, context
->Esp
, context
->SegDs
,
576 context
->SegEs
, context
->SegGs
, context
->EFlags
);
580 void WINAPI
RELAY_CallFrom32Regs(void);
581 __ASM_GLOBAL_FUNC( RELAY_CallFrom32Regs
,
582 "call " __ASM_NAME("__wine_call_from_32_regs") "\n\t"
583 ".long " __ASM_NAME("RELAY_DoCallFrom32Regs") ",0" );
586 /* check whether the function at addr starts with a call to __wine_call_from_32_regs */
587 static BOOL
is_register_entry_point( const BYTE
*addr
)
589 extern void __wine_call_from_32_regs();
593 if (*addr
!= 0xe8) return FALSE
; /* not a call */
594 /* check if call target is __wine_call_from_32_regs */
595 offset
= (int *)(addr
+ 1);
596 if (*offset
== (char *)__wine_call_from_32_regs
- (char *)(offset
+ 1)) return TRUE
;
597 /* now check if call target is an import table jump to __wine_call_from_32_regs */
598 addr
= (BYTE
*)(offset
+ 1) + *offset
;
599 if (addr
[0] != 0xff || addr
[1] != 0x25) return FALSE
; /* not an indirect jmp */
600 ptr
= *(void **)(addr
+ 2); /* get indirect jmp target address */
601 return (*(char **)ptr
== (char *)__wine_call_from_32_regs
);
605 /***********************************************************************
606 * RELAY_GetProcAddress
608 * Return the proc address to use for a given function.
610 FARPROC
RELAY_GetProcAddress( HMODULE module
, IMAGE_EXPORT_DIRECTORY
*exports
,
611 DWORD exp_size
, FARPROC proc
, const char *user
)
613 DEBUG_ENTRY_POINT
*debug
= (DEBUG_ENTRY_POINT
*)proc
;
614 DEBUG_ENTRY_POINT
*list
= (DEBUG_ENTRY_POINT
*)((char *)exports
+ exp_size
);
616 if (debug
< list
|| debug
>= list
+ exports
->NumberOfFunctions
) return proc
;
617 if (list
+ (debug
- list
) != debug
) return proc
; /* not a valid address */
618 if (check_relay_from_module( user
)) return proc
; /* we want to relay it */
619 if (!debug
->call
) return proc
; /* not a normal function */
620 if (debug
->call
!= 0xe8 && debug
->call
!= 0xe9) return proc
; /* not a debug thunk at all */
625 /***********************************************************************
628 * Setup relay debugging for a built-in dll.
630 void RELAY_SetupDLL( const char *module
)
632 IMAGE_EXPORT_DIRECTORY
*exports
;
633 DEBUG_ENTRY_POINT
*debug
;
637 char *p
, dllname
[80];
640 exports
= RtlImageDirectoryEntryToData( (HMODULE
)module
, TRUE
,
641 IMAGE_DIRECTORY_ENTRY_EXPORT
, &size
);
642 if (!exports
) return;
643 debug
= (DEBUG_ENTRY_POINT
*)((char *)exports
+ size
);
644 funcs
= (DWORD
*)(module
+ exports
->AddressOfFunctions
);
645 strcpy( dllname
, module
+ exports
->Name
);
646 p
= dllname
+ strlen(dllname
) - 4;
647 if (p
> dllname
&& !strcasecmp( p
, ".dll" )) *p
= 0;
649 for (i
= 0; i
< exports
->NumberOfFunctions
; i
++, funcs
++, debug
++)
653 if (!debug
->call
) continue; /* not a normal function */
654 if (debug
->call
!= 0xe8 && debug
->call
!= 0xe9) break; /* not a debug thunk at all */
656 if ((name
= find_exported_name( module
, exports
, i
+ exports
->Base
)))
657 on
= check_relay_include( dllname
, name
);
661 debug
->call
= 0xe8; /* call relative */
662 if (is_register_entry_point( debug
->orig
))
663 debug
->callfrom32
= (char *)RELAY_CallFrom32Regs
- (char *)&debug
->ret
;
665 debug
->callfrom32
= (char *)RELAY_CallFrom32
- (char *)&debug
->ret
;
669 debug
->call
= 0xe9; /* jmp relative */
670 debug
->callfrom32
= (char *)debug
->orig
- (char *)&debug
->ret
;
673 debug
->orig
= (FARPROC
)(module
+ (DWORD
)*funcs
);
674 *funcs
= (char *)debug
- module
;
680 FARPROC
RELAY_GetProcAddress( HMODULE module
, IMAGE_EXPORT_DIRECTORY
*exports
,
681 DWORD exp_size
, FARPROC proc
, const char *user
)
686 void RELAY_SetupDLL( const char *module
)
690 #endif /* __i386__ */