wined3d: Get rid of the TMP register in fragment shaders.
[wine] / dlls / ntdll / relay.c
1 /*
2  * Win32 relay and snoop functions
3  *
4  * Copyright 1997 Alexandre Julliard
5  * Copyright 1998 Marcus Meissner
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <stdio.h>
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34 #include "wine/exception.h"
35 #include "ntdll_misc.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(relay);
40
41 #if defined(__i386__) || defined(__x86_64__)
42
43 struct relay_descr  /* descriptor for a module */
44 {
45     void               *magic;               /* signature */
46     void               *relay_call;          /* functions to call from relay thunks */
47     void               *relay_call_regs;
48     void               *private;             /* reserved for the relay code private data */
49     const char         *entry_point_base;    /* base address of entry point thunks */
50     const unsigned int *entry_point_offsets; /* offsets of entry points thunks */
51     const unsigned int *arg_types;           /* table of argument types for all entry points */
52 };
53
54 #define RELAY_DESCR_MAGIC  ((void *)0xdeb90001)
55
56 /* private data built at dll load time */
57
58 struct relay_entry_point
59 {
60     void       *orig_func;    /* original entry point function */
61     const char *name;         /* function name (if any) */
62 };
63
64 struct relay_private_data
65 {
66     HMODULE                  module;            /* module handle of this dll */
67     unsigned int             base;              /* ordinal base */
68     char                     dllname[40];       /* dll name (without .dll extension) */
69     struct relay_entry_point entry_points[1];   /* list of dll entry points */
70 };
71
72 static const WCHAR **debug_relay_excludelist;
73 static const WCHAR **debug_relay_includelist;
74 static const WCHAR **debug_snoop_excludelist;
75 static const WCHAR **debug_snoop_includelist;
76 static const WCHAR **debug_from_relay_excludelist;
77 static const WCHAR **debug_from_relay_includelist;
78 static const WCHAR **debug_from_snoop_excludelist;
79 static const WCHAR **debug_from_snoop_includelist;
80
81 static BOOL init_done;
82
83 /* compare an ASCII and a Unicode string without depending on the current codepage */
84 static inline int strcmpAW( const char *strA, const WCHAR *strW )
85 {
86     while (*strA && ((unsigned char)*strA == *strW)) { strA++; strW++; }
87     return (unsigned char)*strA - *strW;
88 }
89
90 /* compare an ASCII and a Unicode string without depending on the current codepage */
91 static inline int strncmpiAW( const char *strA, const WCHAR *strW, int n )
92 {
93     int ret = 0;
94     for ( ; n > 0; n--, strA++, strW++)
95         if ((ret = toupperW((unsigned char)*strA) - toupperW(*strW)) || !*strA) break;
96     return ret;
97 }
98
99 /***********************************************************************
100  *           build_list
101  *
102  * Build a function list from a ';'-separated string.
103  */
104 static const WCHAR **build_list( const WCHAR *buffer )
105 {
106     int count = 1;
107     const WCHAR *p = buffer;
108     const WCHAR **ret;
109
110     while ((p = strchrW( p, ';' )))
111     {
112         count++;
113         p++;
114     }
115     /* allocate count+1 pointers, plus the space for a copy of the string */
116     if ((ret = RtlAllocateHeap( GetProcessHeap(), 0,
117                                 (count+1) * sizeof(WCHAR*) + (strlenW(buffer)+1) * sizeof(WCHAR) )))
118     {
119         WCHAR *str = (WCHAR *)(ret + count + 1);
120         WCHAR *p = str;
121
122         strcpyW( str, buffer );
123         count = 0;
124         for (;;)
125         {
126             ret[count++] = p;
127             if (!(p = strchrW( p, ';' ))) break;
128             *p++ = 0;
129         }
130         ret[count++] = NULL;
131     }
132     return ret;
133 }
134
135 /***********************************************************************
136  *           load_list_value
137  *
138  * Load a function list from a registry value.
139  */
140 static const WCHAR **load_list( HKEY hkey, const WCHAR *value )
141 {
142     char initial_buffer[4096];
143     char *buffer = initial_buffer;
144     DWORD count;
145     NTSTATUS status;
146     UNICODE_STRING name;
147     const WCHAR **list = NULL;
148
149     RtlInitUnicodeString( &name, value );
150     status = NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, sizeof(buffer), &count );
151     if (status == STATUS_BUFFER_OVERFLOW)
152     {
153         buffer = RtlAllocateHeap( GetProcessHeap(), 0, count );
154         status = NtQueryValueKey( hkey, &name, KeyValuePartialInformation, buffer, count, &count );
155     }
156     if (status == STATUS_SUCCESS)
157     {
158         WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)buffer)->Data;
159         list = build_list( str );
160         if (list) TRACE( "%s = %s\n", debugstr_w(value), debugstr_w(str) );
161     }
162
163     if (buffer != initial_buffer) RtlFreeHeap( GetProcessHeap(), 0, buffer );
164     return list;
165 }
166
167 /***********************************************************************
168  *           init_debug_lists
169  *
170  * Build the relay include/exclude function lists.
171  */
172 static void init_debug_lists(void)
173 {
174     OBJECT_ATTRIBUTES attr;
175     UNICODE_STRING name;
176     HANDLE root, hkey;
177     static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\',
178                                     'W','i','n','e','\\',
179                                     'D','e','b','u','g',0};
180     static const WCHAR RelayIncludeW[] = {'R','e','l','a','y','I','n','c','l','u','d','e',0};
181     static const WCHAR RelayExcludeW[] = {'R','e','l','a','y','E','x','c','l','u','d','e',0};
182     static const WCHAR SnoopIncludeW[] = {'S','n','o','o','p','I','n','c','l','u','d','e',0};
183     static const WCHAR SnoopExcludeW[] = {'S','n','o','o','p','E','x','c','l','u','d','e',0};
184     static const WCHAR RelayFromIncludeW[] = {'R','e','l','a','y','F','r','o','m','I','n','c','l','u','d','e',0};
185     static const WCHAR RelayFromExcludeW[] = {'R','e','l','a','y','F','r','o','m','E','x','c','l','u','d','e',0};
186     static const WCHAR SnoopFromIncludeW[] = {'S','n','o','o','p','F','r','o','m','I','n','c','l','u','d','e',0};
187     static const WCHAR SnoopFromExcludeW[] = {'S','n','o','o','p','F','r','o','m','E','x','c','l','u','d','e',0};
188
189     if (init_done) return;
190     init_done = TRUE;
191
192     RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
193     attr.Length = sizeof(attr);
194     attr.RootDirectory = root;
195     attr.ObjectName = &name;
196     attr.Attributes = 0;
197     attr.SecurityDescriptor = NULL;
198     attr.SecurityQualityOfService = NULL;
199     RtlInitUnicodeString( &name, configW );
200
201     /* @@ Wine registry key: HKCU\Software\Wine\Debug */
202     if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0;
203     NtClose( root );
204     if (!hkey) return;
205
206     debug_relay_includelist = load_list( hkey, RelayIncludeW );
207     debug_relay_excludelist = load_list( hkey, RelayExcludeW );
208     debug_snoop_includelist = load_list( hkey, SnoopIncludeW );
209     debug_snoop_excludelist = load_list( hkey, SnoopExcludeW );
210     debug_from_relay_includelist = load_list( hkey, RelayFromIncludeW );
211     debug_from_relay_excludelist = load_list( hkey, RelayFromExcludeW );
212     debug_from_snoop_includelist = load_list( hkey, SnoopFromIncludeW );
213     debug_from_snoop_excludelist = load_list( hkey, SnoopFromExcludeW );
214
215     NtClose( hkey );
216 }
217
218
219 /***********************************************************************
220  *           check_list
221  *
222  * Check if a given module and function is in the list.
223  */
224 static BOOL check_list( const char *module, int ordinal, const char *func, const WCHAR *const *list )
225 {
226     char ord_str[10];
227
228     sprintf( ord_str, "%d", ordinal );
229     for(; *list; list++)
230     {
231         const WCHAR *p = strrchrW( *list, '.' );
232         if (p && p > *list)  /* check module and function */
233         {
234             int len = p - *list;
235             if (strncmpiAW( module, *list, len-1 ) || module[len]) continue;
236             if (p[1] == '*' && !p[2]) return TRUE;
237             if (!strcmpAW( ord_str, p + 1 )) return TRUE;
238             if (func && !strcmpAW( func, p + 1 )) return TRUE;
239         }
240         else  /* function only */
241         {
242             if (func && !strcmpAW( func, *list )) return TRUE;
243         }
244     }
245     return FALSE;
246 }
247
248
249 /***********************************************************************
250  *           check_relay_include
251  *
252  * Check if a given function must be included in the relay output.
253  */
254 static BOOL check_relay_include( const char *module, int ordinal, const char *func )
255 {
256     if (debug_relay_excludelist && check_list( module, ordinal, func, debug_relay_excludelist ))
257         return FALSE;
258     if (debug_relay_includelist && !check_list( module, ordinal, func, debug_relay_includelist ))
259         return FALSE;
260     return TRUE;
261 }
262
263 /***********************************************************************
264  *           check_from_module
265  *
266  * Check if calls from a given module must be included in the relay/snoop output,
267  * given the exclusion and inclusion lists.
268  */
269 static BOOL check_from_module( const WCHAR **includelist, const WCHAR **excludelist, const WCHAR *module )
270 {
271     static const WCHAR dllW[] = {'.','d','l','l',0 };
272     const WCHAR **listitem;
273     BOOL show;
274
275     if (!module) return TRUE;
276     if (!includelist && !excludelist) return TRUE;
277     if (excludelist)
278     {
279         show = TRUE;
280         listitem = excludelist;
281     }
282     else
283     {
284         show = FALSE;
285         listitem = includelist;
286     }
287     for(; *listitem; listitem++)
288     {
289         int len;
290
291         if (!strcmpiW( *listitem, module )) return !show;
292         len = strlenW( *listitem );
293         if (!strncmpiW( *listitem, module, len ) && !strcmpiW( module + len, dllW ))
294             return !show;
295     }
296     return show;
297 }
298
299 /***********************************************************************
300  *           RELAY_PrintArgs
301  */
302 static inline void RELAY_PrintArgs( const INT_PTR *args, int nb_args, unsigned int typemask )
303 {
304     while (nb_args--)
305     {
306         if ((typemask & 3) && HIWORD(*args))
307         {
308             if (typemask & 2)
309                 DPRINTF( "%08lx %s", *args, debugstr_w((LPCWSTR)*args) );
310             else
311                 DPRINTF( "%08lx %s", *args, debugstr_a((LPCSTR)*args) );
312         }
313         else DPRINTF( "%08lx", *args );
314         if (nb_args) DPRINTF( "," );
315         args++;
316         typemask >>= 2;
317     }
318 }
319
320 extern LONGLONG CDECL call_entry_point( void *func, int nb_args, const INT_PTR *args );
321 #ifdef __i386__
322 __ASM_GLOBAL_FUNC( call_entry_point,
323                    "\tpushl %ebp\n"
324                    "\tmovl %esp,%ebp\n"
325                    "\tpushl %esi\n"
326                    "\tpushl %edi\n"
327                    "\tmovl 12(%ebp),%edx\n"
328                    "\tshll $2,%edx\n"
329                    "\tjz 1f\n"
330                    "\tsubl %edx,%esp\n"
331                    "\tandl $~15,%esp\n"
332                    "\tmovl 12(%ebp),%ecx\n"
333                    "\tmovl 16(%ebp),%esi\n"
334                    "\tmovl %esp,%edi\n"
335                    "\tcld\n"
336                    "\trep; movsl\n"
337                    "1:\tcall *8(%ebp)\n"
338                    "\tleal -8(%ebp),%esp\n"
339                    "\tpopl %edi\n"
340                    "\tpopl %esi\n"
341                    "\tpopl %ebp\n"
342                    "\tret" )
343 #else
344 __ASM_GLOBAL_FUNC( call_entry_point,
345                    "\tpushq %rbp\n"
346                    "\tmovq %rsp,%rbp\n"
347                    "\tpushq %rsi\n"
348                    "\tpushq %rdi\n"
349                    "\tmovq %rcx,%rax\n"
350                    "\tmovq $4,%rcx\n"
351                    "\tcmp %rcx,%rdx\n"
352                    "\tcmovgq %rdx,%rcx\n"
353                    "\tleaq 0(,%rcx,8),%rdx\n"
354                    "\tsubq %rdx,%rsp\n"
355                    "\tandq $~15,%rsp\n"
356                    "\tmovq %rsp,%rdi\n"
357                    "\tmovq %r8,%rsi\n"
358                    "\trep; movsq\n"
359                    "\tmovq 0(%rsp),%rcx\n"
360                    "\tmovq 8(%rsp),%rdx\n"
361                    "\tmovq 16(%rsp),%r8\n"
362                    "\tmovq 24(%rsp),%r9\n"
363                    "\tcallq *%rax\n"
364                    "\tleaq -16(%rbp),%rsp\n"
365                    "\tpopq %rdi\n"
366                    "\tpopq %rsi\n"
367                    "\tpopq %rbp\n"
368                    "\tret\n" )
369 #endif
370
371
372 /***********************************************************************
373  *           relay_call
374  *
375  * stack points to the return address, i.e. the first argument is stack[1].
376  */
377 static LONGLONG WINAPI relay_call( struct relay_descr *descr, unsigned int idx, const INT_PTR *stack )
378 {
379     LONGLONG ret;
380     WORD ordinal = LOWORD(idx);
381     BYTE nb_args = LOBYTE(HIWORD(idx));
382     BYTE flags   = HIBYTE(HIWORD(idx));
383     struct relay_private_data *data = descr->private;
384     struct relay_entry_point *entry_point = data->entry_points + ordinal;
385
386     if (!TRACE_ON(relay))
387         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1 );
388     else
389     {
390         if (entry_point->name)
391             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
392         else
393             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
394         RELAY_PrintArgs( stack + 1, nb_args, descr->arg_types[ordinal] );
395         DPRINTF( ") ret=%08lx\n", stack[0] );
396
397         ret = call_entry_point( entry_point->orig_func, nb_args, stack + 1 );
398
399         if (entry_point->name)
400             DPRINTF( "%04x:Ret  %s.%s()", GetCurrentThreadId(), data->dllname, entry_point->name );
401         else
402             DPRINTF( "%04x:Ret  %s.%u()", GetCurrentThreadId(), data->dllname, data->base + ordinal );
403
404         if (flags & 1)  /* 64-bit return value */
405             DPRINTF( " retval=%08x%08x ret=%08lx\n",
406                      (UINT)(ret >> 32), (UINT)ret, stack[0] );
407         else
408             DPRINTF( " retval=%08lx ret=%08lx\n", (UINT_PTR)ret, stack[0] );
409     }
410     return ret;
411 }
412
413
414 /***********************************************************************
415  *           relay_call_regs
416  */
417 #ifdef __i386__
418 void WINAPI __regs_relay_call_regs( struct relay_descr *descr, unsigned int idx,
419                                     unsigned int orig_eax, unsigned int ret_addr,
420                                     CONTEXT86 *context )
421 {
422     WORD ordinal = LOWORD(idx);
423     BYTE nb_args = LOBYTE(HIWORD(idx));
424     struct relay_private_data *data = descr->private;
425     struct relay_entry_point *entry_point = data->entry_points + ordinal;
426     BYTE *orig_func = entry_point->orig_func;
427     INT_PTR *args = (INT_PTR *)context->Esp;
428     INT_PTR args_copy[32];
429
430     /* restore the context to what it was before the relay thunk */
431     context->Eax = orig_eax;
432     context->Eip = ret_addr;
433     context->Esp += nb_args * sizeof(int);
434
435     if (TRACE_ON(relay))
436     {
437         if (entry_point->name)
438             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
439         else
440             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
441         RELAY_PrintArgs( args, nb_args, descr->arg_types[ordinal] );
442         DPRINTF( ") ret=%08x\n", ret_addr );
443
444         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
445                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
446                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
447                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
448                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
449
450         assert( orig_func[0] == 0x68 /* pushl func */ );
451         assert( orig_func[5] == 0x6a /* pushl args */ );
452         assert( orig_func[7] == 0xe8 /* call */ );
453     }
454
455     /* now call the real function */
456
457     memcpy( args_copy, args, nb_args * sizeof(args[0]) );
458     args_copy[nb_args++] = (INT_PTR)context;  /* append context argument */
459
460     call_entry_point( orig_func + 12 + *(int *)(orig_func + 1), nb_args, args_copy );
461
462
463     if (TRACE_ON(relay))
464     {
465         if (entry_point->name)
466             DPRINTF( "%04x:Ret  %s.%s() retval=%08x ret=%08x\n",
467                      GetCurrentThreadId(), data->dllname, entry_point->name,
468                      context->Eax, context->Eip );
469         else
470             DPRINTF( "%04x:Ret  %s.%u() retval=%08x ret=%08x\n",
471                      GetCurrentThreadId(), data->dllname, data->base + ordinal,
472                      context->Eax, context->Eip );
473         DPRINTF( "%04x:  eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x "
474                  "ebp=%08x esp=%08x ds=%04x es=%04x fs=%04x gs=%04x flags=%08x\n",
475                  GetCurrentThreadId(), context->Eax, context->Ebx, context->Ecx,
476                  context->Edx, context->Esi, context->Edi, context->Ebp, context->Esp,
477                  context->SegDs, context->SegEs, context->SegFs, context->SegGs, context->EFlags );
478     }
479 }
480 extern void WINAPI relay_call_regs(void);
481 DEFINE_REGS_ENTRYPOINT( relay_call_regs, 4 )
482
483 #else  /* __i386__ */
484
485 void WINAPI __regs_relay_call_regs( struct relay_descr *descr, INT_PTR idx,
486                                     INT_PTR *stack, CONTEXT *context )
487 {
488     WORD ordinal = LOWORD(idx);
489     BYTE nb_args = LOBYTE(HIWORD(idx));
490     struct relay_private_data *data = descr->private;
491     struct relay_entry_point *entry_point = data->entry_points + ordinal;
492     BYTE *orig_func = entry_point->orig_func;
493     INT_PTR *args = stack + 1;
494     INT_PTR args_copy[32];
495
496     /* restore the context to what it was before the relay thunk */
497     context->Rip = stack[0];
498     context->Rsp = (INT_PTR)args;
499
500     if (TRACE_ON(relay))
501     {
502         if (entry_point->name)
503             DPRINTF( "%04x:Call %s.%s(", GetCurrentThreadId(), data->dllname, entry_point->name );
504         else
505             DPRINTF( "%04x:Call %s.%u(", GetCurrentThreadId(), data->dllname, data->base + ordinal );
506         RELAY_PrintArgs( args, nb_args, descr->arg_types[ordinal] );
507         DPRINTF( ") ret=%08lx\n", context->Rip );
508
509         DPRINTF( "%04x: rax=%016lx rbx=%016lx rcx=%016lx rdx=%016lx rsi=%016lx rdi=%016lx rbp=%016lx rsp=%016lx\n",
510                  GetCurrentThreadId(), context->Rax, context->Rbx, context->Rcx, context->Rdx,
511                  context->Rsi, context->Rdi, context->Rbp, context->Rsp );
512         DPRINTF( "%04x:  r8=%016lx  r9=%016lx r10=%016lx r11=%016lx r12=%016lx r13=%016lx r14=%016lx r15=%016lx\n",
513                  GetCurrentThreadId(), context->R8, context->R9, context->R10, context->R11,
514                  context->R12, context->R13, context->R14, context->R15 );
515
516         assert( orig_func[17] == 0x48 /* leaq */ );
517         assert( orig_func[18] == 0x8d );
518         assert( orig_func[19] == 0x15 );
519         assert( orig_func[24] == 0xe8 /* call */ );
520     }
521
522     /* now call the real function */
523
524     memcpy( args_copy, args, nb_args * sizeof(args[0]) );
525     args_copy[nb_args++] = (INT_PTR)context;  /* append context argument */
526
527     call_entry_point( orig_func + 24 + *(int *)(orig_func + 20), nb_args, args_copy );
528
529
530     if (TRACE_ON(relay))
531     {
532         if (entry_point->name)
533             DPRINTF( "%04x:Ret  %s.%s() retval=%08lx ret=%08lx\n",
534                      GetCurrentThreadId(), data->dllname, entry_point->name,
535                      context->Rax, context->Rip );
536         else
537             DPRINTF( "%04x:Ret  %s.%u() retval=%08lx ret=%08lx\n",
538                      GetCurrentThreadId(), data->dllname, data->base + ordinal,
539                      context->Rax, context->Rip );
540         DPRINTF( "%04x:  rax=%016lx rbx=%016lx rcx=%016lx rdx=%016lx rsi=%016lx rdi=%016lx rbp=%016lx rsp=%016lx\n",
541                  GetCurrentThreadId(), context->Rax, context->Rbx, context->Rcx, context->Rdx,
542                  context->Rsi, context->Rdi, context->Rbp, context->Rsp );
543         DPRINTF( "%04x:  r8=%016lx  r9=%016lx r10=%016lx r11=%016lx r12=%016lx r13=%016lx r14=%016lx r15=%016lx\n",
544                  GetCurrentThreadId(), context->R8, context->R9, context->R10, context->R11,
545                  context->R12, context->R13, context->R14, context->R15 );
546     }
547 }
548 extern void WINAPI relay_call_regs(void);
549 DEFINE_REGS_ENTRYPOINT( relay_call_regs, 3 )
550
551 #endif  /* __i386__ */
552
553
554 /***********************************************************************
555  *           RELAY_GetProcAddress
556  *
557  * Return the proc address to use for a given function.
558  */
559 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
560                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
561 {
562     struct relay_private_data *data;
563     const struct relay_descr *descr = (const struct relay_descr *)((const char *)exports + exp_size);
564
565     if (descr->magic != RELAY_DESCR_MAGIC || !(data = descr->private)) return proc;  /* no relay data */
566     if (!data->entry_points[ordinal].orig_func) return proc;  /* not a relayed function */
567     if (check_from_module( debug_from_relay_includelist, debug_from_relay_excludelist, user ))
568         return proc;  /* we want to relay it */
569     return data->entry_points[ordinal].orig_func;
570 }
571
572
573 /***********************************************************************
574  *           RELAY_SetupDLL
575  *
576  * Setup relay debugging for a built-in dll.
577  */
578 void RELAY_SetupDLL( HMODULE module )
579 {
580     IMAGE_EXPORT_DIRECTORY *exports;
581     DWORD *funcs;
582     unsigned int i, len;
583     DWORD size, entry_point_rva;
584     struct relay_descr *descr;
585     struct relay_private_data *data;
586     const WORD *ordptr;
587
588     if (!init_done) init_debug_lists();
589
590     exports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size );
591     if (!exports) return;
592
593     descr = (struct relay_descr *)((char *)exports + size);
594     if (descr->magic != RELAY_DESCR_MAGIC) return;
595
596     if (!(data = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) +
597                                   (exports->NumberOfFunctions-1) * sizeof(data->entry_points) )))
598         return;
599
600     descr->relay_call = relay_call;
601     descr->relay_call_regs = relay_call_regs;
602     descr->private = data;
603
604     data->module = module;
605     data->base   = exports->Base;
606     len = strlen( (char *)module + exports->Name );
607     if (len > 4 && !strcasecmp( (char *)module + exports->Name + len - 4, ".dll" )) len -= 4;
608     len = min( len, sizeof(data->dllname) - 1 );
609     memcpy( data->dllname, (char *)module + exports->Name, len );
610     data->dllname[len] = 0;
611
612     /* fetch name pointer for all entry points and store them in the private structure */
613
614     ordptr = (const WORD *)((char *)module + exports->AddressOfNameOrdinals);
615     for (i = 0; i < exports->NumberOfNames; i++, ordptr++)
616     {
617         DWORD name_rva = ((DWORD*)((char *)module + exports->AddressOfNames))[i];
618         data->entry_points[*ordptr].name = (const char *)module + name_rva;
619     }
620
621     /* patch the functions in the export table to point to the relay thunks */
622
623     funcs = (DWORD *)((char *)module + exports->AddressOfFunctions);
624     entry_point_rva = descr->entry_point_base - (const char *)module;
625     for (i = 0; i < exports->NumberOfFunctions; i++, funcs++)
626     {
627         if (!descr->entry_point_offsets[i]) continue;   /* not a normal function */
628         if (!check_relay_include( data->dllname, i + exports->Base, data->entry_points[i].name ))
629             continue;  /* don't include this entry point */
630
631         data->entry_points[i].orig_func = (char *)module + *funcs;
632         *funcs = entry_point_rva + descr->entry_point_offsets[i];
633     }
634 }
635
636 #else  /* __i386__ || __x86_64__ */
637
638 FARPROC RELAY_GetProcAddress( HMODULE module, const IMAGE_EXPORT_DIRECTORY *exports,
639                               DWORD exp_size, FARPROC proc, DWORD ordinal, const WCHAR *user )
640 {
641     return proc;
642 }
643
644 void RELAY_SetupDLL( HMODULE module )
645 {
646 }
647
648 #endif  /* __i386__ || __x86_64__ */
649
650
651 /***********************************************************************/
652 /* snoop support */
653 /***********************************************************************/
654
655 #ifdef __i386__
656
657 WINE_DECLARE_DEBUG_CHANNEL(seh);
658 WINE_DECLARE_DEBUG_CHANNEL(snoop);
659
660 #include "pshpack1.h"
661
662 typedef struct
663 {
664         /* code part */
665         BYTE            lcall;          /* 0xe8 call snoopentry (relative) */
666         /* NOTE: If you move snoopentry OR nrofargs fix the relative offset
667          * calculation!
668          */
669         DWORD           snoopentry;     /* SNOOP_Entry relative */
670         /* unreached */
671         int             nrofargs;
672         FARPROC origfun;
673         const char *name;
674 } SNOOP_FUN;
675
676 typedef struct tagSNOOP_DLL {
677         HMODULE hmod;
678         SNOOP_FUN       *funs;
679         DWORD           ordbase;
680         DWORD           nrofordinals;
681         struct tagSNOOP_DLL     *next;
682         char name[1];
683 } SNOOP_DLL;
684
685 typedef struct
686 {
687         /* code part */
688         BYTE            lcall;          /* 0xe8 call snoopret relative*/
689         /* NOTE: If you move snoopret OR origreturn fix the relative offset
690          * calculation!
691          */
692         DWORD           snoopret;       /* SNOOP_Ret relative */
693         /* unreached */
694         FARPROC origreturn;
695         SNOOP_DLL       *dll;
696         DWORD           ordinal;
697         DWORD           origESP;
698         DWORD           *args;          /* saved args across a stdcall */
699 } SNOOP_RETURNENTRY;
700
701 typedef struct tagSNOOP_RETURNENTRIES {
702         SNOOP_RETURNENTRY entry[4092/sizeof(SNOOP_RETURNENTRY)];
703         struct tagSNOOP_RETURNENTRIES   *next;
704 } SNOOP_RETURNENTRIES;
705
706 #include "poppack.h"
707
708 extern void WINAPI SNOOP_Entry(void);
709 extern void WINAPI SNOOP_Return(void);
710
711 static SNOOP_DLL *firstdll;
712 static SNOOP_RETURNENTRIES *firstrets;
713
714
715 /***********************************************************************
716  *          SNOOP_ShowDebugmsgSnoop
717  *
718  * Simple function to decide if a particular debugging message is
719  * wanted.
720  */
721 static BOOL SNOOP_ShowDebugmsgSnoop(const char *module, int ordinal, const char *func)
722 {
723     if (debug_snoop_excludelist && check_list( module, ordinal, func, debug_snoop_excludelist ))
724         return FALSE;
725     if (debug_snoop_includelist && !check_list( module, ordinal, func, debug_snoop_includelist ))
726         return FALSE;
727     return TRUE;
728 }
729
730
731 /***********************************************************************
732  *           SNOOP_SetupDLL
733  *
734  * Setup snoop debugging for a native dll.
735  */
736 void SNOOP_SetupDLL(HMODULE hmod)
737 {
738     SNOOP_DLL **dll = &firstdll;
739     char *p, *name;
740     void *addr;
741     SIZE_T size;
742     ULONG size32;
743     IMAGE_EXPORT_DIRECTORY *exports;
744
745     if (!init_done) init_debug_lists();
746
747     exports = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_EXPORT, &size32 );
748     if (!exports || !exports->NumberOfFunctions) return;
749     name = (char *)hmod + exports->Name;
750     size = size32;
751
752     TRACE_(snoop)("hmod=%p, name=%s\n", hmod, name);
753
754     while (*dll) {
755         if ((*dll)->hmod == hmod)
756         {
757             /* another dll, loaded at the same address */
758             addr = (*dll)->funs;
759             size = (*dll)->nrofordinals * sizeof(SNOOP_FUN);
760             NtFreeVirtualMemory(NtCurrentProcess(), &addr, &size, MEM_RELEASE);
761             break;
762         }
763         dll = &((*dll)->next);
764     }
765     if (*dll)
766         *dll = RtlReAllocateHeap(GetProcessHeap(),
767                              HEAP_ZERO_MEMORY, *dll,
768                              sizeof(SNOOP_DLL) + strlen(name));
769     else
770         *dll = RtlAllocateHeap(GetProcessHeap(),
771                              HEAP_ZERO_MEMORY,
772                              sizeof(SNOOP_DLL) + strlen(name));
773     (*dll)->hmod        = hmod;
774     (*dll)->ordbase = exports->Base;
775     (*dll)->nrofordinals = exports->NumberOfFunctions;
776     strcpy( (*dll)->name, name );
777     p = (*dll)->name + strlen((*dll)->name) - 4;
778     if (p > (*dll)->name && !strcasecmp( p, ".dll" )) *p = 0;
779
780     size = exports->NumberOfFunctions * sizeof(SNOOP_FUN);
781     addr = NULL;
782     NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size,
783                             MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
784     if (!addr) {
785         RtlFreeHeap(GetProcessHeap(),0,*dll);
786         FIXME("out of memory\n");
787         return;
788     }
789     (*dll)->funs = addr;
790     memset((*dll)->funs,0,size);
791 }
792
793
794 /***********************************************************************
795  *           SNOOP_GetProcAddress
796  *
797  * Return the proc address to use for a given function.
798  */
799 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports,
800                               DWORD exp_size, FARPROC origfun, DWORD ordinal,
801                               const WCHAR *user)
802 {
803     unsigned int i;
804     const char *ename;
805     const WORD *ordinals;
806     const DWORD *names;
807     SNOOP_DLL *dll = firstdll;
808     SNOOP_FUN *fun;
809     const IMAGE_SECTION_HEADER *sec;
810
811     if (!TRACE_ON(snoop)) return origfun;
812     if (!check_from_module( debug_from_snoop_includelist, debug_from_snoop_excludelist, user ))
813         return origfun; /* the calling module was explicitly excluded */
814
815     if (!*(LPBYTE)origfun) /* 0x00 is an impossible opcode, possible dataref. */
816         return origfun;
817
818     sec = RtlImageRvaToSection( RtlImageNtHeader(hmod), hmod, (char *)origfun - (char *)hmod );
819
820     if (!sec || !(sec->Characteristics & IMAGE_SCN_CNT_CODE))
821         return origfun;  /* most likely a data reference */
822
823     while (dll) {
824         if (hmod == dll->hmod)
825             break;
826         dll = dll->next;
827     }
828     if (!dll)   /* probably internal */
829         return origfun;
830
831     /* try to find a name for it */
832     ename = NULL;
833     names = (const DWORD *)((const char *)hmod + exports->AddressOfNames);
834     ordinals = (const WORD *)((const char *)hmod + exports->AddressOfNameOrdinals);
835     if (names) for (i = 0; i < exports->NumberOfNames; i++)
836     {
837         if (ordinals[i] == ordinal)
838         {
839             ename = (const char *)hmod + names[i];
840             break;
841         }
842     }
843     if (!SNOOP_ShowDebugmsgSnoop(dll->name,ordinal,ename))
844         return origfun;
845     assert(ordinal < dll->nrofordinals);
846     fun = dll->funs + ordinal;
847     if (!fun->name)
848     {
849         fun->name       = ename;
850         fun->lcall      = 0xe8;
851         /* NOTE: origreturn struct member MUST come directly after snoopentry */
852         fun->snoopentry = (char*)SNOOP_Entry-((char*)(&fun->nrofargs));
853         fun->origfun    = origfun;
854         fun->nrofargs   = -1;
855     }
856     return (FARPROC)&(fun->lcall);
857 }
858
859 static void SNOOP_PrintArg(DWORD x)
860 {
861     int i,nostring;
862
863     DPRINTF("%08x",x);
864     if (!HIWORD(x) || TRACE_ON(seh)) return; /* trivial reject to avoid faults */
865     __TRY
866     {
867         LPBYTE s=(LPBYTE)x;
868         i=0;nostring=0;
869         while (i<80) {
870             if (s[i]==0) break;
871             if (s[i]<0x20) {nostring=1;break;}
872             if (s[i]>=0x80) {nostring=1;break;}
873             i++;
874         }
875         if (!nostring && i > 5)
876             DPRINTF(" %s",debugstr_an((LPSTR)x,i));
877         else  /* try unicode */
878         {
879             LPWSTR s=(LPWSTR)x;
880             i=0;nostring=0;
881             while (i<80) {
882                 if (s[i]==0) break;
883                 if (s[i]<0x20) {nostring=1;break;}
884                 if (s[i]>0x100) {nostring=1;break;}
885                 i++;
886             }
887             if (!nostring && i > 5) DPRINTF(" %s",debugstr_wn((LPWSTR)x,i));
888         }
889     }
890     __EXCEPT_PAGE_FAULT
891     {
892     }
893     __ENDTRY
894 }
895
896 #define CALLER1REF (*(DWORD*)context->Esp)
897
898 void WINAPI __regs_SNOOP_Entry( CONTEXT86 *context )
899 {
900         DWORD           ordinal=0,entry = context->Eip - 5;
901         SNOOP_DLL       *dll = firstdll;
902         SNOOP_FUN       *fun = NULL;
903         SNOOP_RETURNENTRIES     **rets = &firstrets;
904         SNOOP_RETURNENTRY       *ret;
905         int             i=0, max;
906
907         while (dll) {
908                 if (    ((char*)entry>=(char*)dll->funs)        &&
909                         ((char*)entry<=(char*)(dll->funs+dll->nrofordinals))
910                 ) {
911                         fun = (SNOOP_FUN*)entry;
912                         ordinal = fun-dll->funs;
913                         break;
914                 }
915                 dll=dll->next;
916         }
917         if (!dll) {
918                 FIXME("entrypoint 0x%08x not found\n",entry);
919                 return; /* oops */
920         }
921         /* guess cdecl ... */
922         if (fun->nrofargs<0) {
923                 /* Typical cdecl return frame is:
924                  *     add esp, xxxxxxxx
925                  * which has (for xxxxxxxx up to 255 the opcode "83 C4 xx".
926                  * (after that 81 C2 xx xx xx xx)
927                  */
928                 LPBYTE  reteip = (LPBYTE)CALLER1REF;
929
930                 if (reteip) {
931                         if ((reteip[0]==0x83)&&(reteip[1]==0xc4))
932                                 fun->nrofargs=reteip[2]/4;
933                 }
934         }
935
936
937         while (*rets) {
938                 for (i=0;i<sizeof((*rets)->entry)/sizeof((*rets)->entry[0]);i++)
939                         if (!(*rets)->entry[i].origreturn)
940                                 break;
941                 if (i!=sizeof((*rets)->entry)/sizeof((*rets)->entry[0]))
942                         break;
943                 rets = &((*rets)->next);
944         }
945         if (!*rets) {
946                 SIZE_T size = 4096;
947                 VOID* addr = NULL;
948
949                 NtAllocateVirtualMemory(NtCurrentProcess(), &addr, 0, &size, 
950                                         MEM_COMMIT | MEM_RESERVE,
951                                         PAGE_EXECUTE_READWRITE);
952                 if (!addr) return;
953                 *rets = addr;
954                 memset(*rets,0,4096);
955                 i = 0;  /* entry 0 is free */
956         }
957         ret = &((*rets)->entry[i]);
958         ret->lcall      = 0xe8;
959         /* NOTE: origreturn struct member MUST come directly after snoopret */
960         ret->snoopret   = ((char*)SNOOP_Return)-(char*)(&ret->origreturn);
961         ret->origreturn = (FARPROC)CALLER1REF;
962         CALLER1REF      = (DWORD)&ret->lcall;
963         ret->dll        = dll;
964         ret->args       = NULL;
965         ret->ordinal    = ordinal;
966         ret->origESP    = context->Esp;
967
968         context->Eip = (DWORD)fun->origfun;
969
970         if (fun->name) DPRINTF("%04x:CALL %s.%s(",GetCurrentThreadId(),dll->name,fun->name);
971         else DPRINTF("%04x:CALL %s.%d(",GetCurrentThreadId(),dll->name,dll->ordbase+ordinal);
972         if (fun->nrofargs>0) {
973                 max = fun->nrofargs; if (max>16) max=16;
974                 for (i=0;i<max;i++)
975                 {
976                     SNOOP_PrintArg(*(DWORD*)(context->Esp + 4 + sizeof(DWORD)*i));
977                     if (i<fun->nrofargs-1) DPRINTF(",");
978                 }
979                 if (max!=fun->nrofargs)
980                         DPRINTF(" ...");
981         } else if (fun->nrofargs<0) {
982                 DPRINTF("<unknown, check return>");
983                 ret->args = RtlAllocateHeap(GetProcessHeap(),
984                                             0,16*sizeof(DWORD));
985                 memcpy(ret->args,(LPBYTE)(context->Esp + 4),sizeof(DWORD)*16);
986         }
987         DPRINTF(") ret=%08x\n",(DWORD)ret->origreturn);
988 }
989
990
991 void WINAPI __regs_SNOOP_Return( CONTEXT86 *context )
992 {
993         SNOOP_RETURNENTRY       *ret = (SNOOP_RETURNENTRY*)(context->Eip - 5);
994         SNOOP_FUN *fun = &ret->dll->funs[ret->ordinal];
995
996         /* We haven't found out the nrofargs yet. If we called a cdecl
997          * function it is too late anyway and we can just set '0' (which
998          * will be the difference between orig and current ESP
999          * If stdcall -> everything ok.
1000          */
1001         if (ret->dll->funs[ret->ordinal].nrofargs<0)
1002                 ret->dll->funs[ret->ordinal].nrofargs=(context->Esp - ret->origESP-4)/4;
1003         context->Eip = (DWORD)ret->origreturn;
1004         if (ret->args) {
1005                 int     i,max;
1006
1007                 if (fun->name)
1008                     DPRINTF("%04x:RET  %s.%s(", GetCurrentThreadId(), ret->dll->name, fun->name);
1009                 else
1010                     DPRINTF("%04x:RET  %s.%d(", GetCurrentThreadId(),
1011                             ret->dll->name,ret->dll->ordbase+ret->ordinal);
1012
1013                 max = fun->nrofargs;
1014                 if (max>16) max=16;
1015
1016                 for (i=0;i<max;i++)
1017                 {
1018                     SNOOP_PrintArg(ret->args[i]);
1019                     if (i<max-1) DPRINTF(",");
1020                 }
1021                 DPRINTF(") retval=%08x ret=%08x\n",
1022                         context->Eax,(DWORD)ret->origreturn );
1023                 RtlFreeHeap(GetProcessHeap(),0,ret->args);
1024                 ret->args = NULL;
1025         }
1026         else
1027         {
1028             if (fun->name)
1029                 DPRINTF("%04x:RET  %s.%s() retval=%08x ret=%08x\n",
1030                         GetCurrentThreadId(),
1031                         ret->dll->name, fun->name, context->Eax, (DWORD)ret->origreturn);
1032             else
1033                 DPRINTF("%04x:RET  %s.%d() retval=%08x ret=%08x\n",
1034                         GetCurrentThreadId(),
1035                         ret->dll->name,ret->dll->ordbase+ret->ordinal,
1036                         context->Eax, (DWORD)ret->origreturn);
1037         }
1038         ret->origreturn = NULL; /* mark as empty */
1039 }
1040
1041 /* assembly wrappers that save the context */
1042 DEFINE_REGS_ENTRYPOINT( SNOOP_Entry, 0 )
1043 DEFINE_REGS_ENTRYPOINT( SNOOP_Return, 0 )
1044
1045 #else  /* __i386__ */
1046
1047 FARPROC SNOOP_GetProcAddress( HMODULE hmod, const IMAGE_EXPORT_DIRECTORY *exports, DWORD exp_size,
1048                               FARPROC origfun, DWORD ordinal, const WCHAR *user )
1049 {
1050     return origfun;
1051 }
1052
1053 void SNOOP_SetupDLL( HMODULE hmod )
1054 {
1055     FIXME("snooping works only on i386 for now.\n");
1056 }
1057
1058 #endif /* __i386__ */