relay32/relay386.c

   1 /*
   2  * 386-specific Win32 relay functions
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  */
   6
   7
   8 #include <assert.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include "winnt.h"
  12 #include "selectors.h"
  13 #include "stackframe.h"
  14 #include "syslevel.h"
  15 #include "main.h"
  16 #include "module.h"
  17 #include "process.h"
  18 #include "debugtools.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(relay);
  21
  22 char **debug_relay_excludelist = NULL, **debug_relay_includelist = NULL;
  23
  24 /***********************************************************************
  25  *           RELAY_ShowDebugmsgRelay
  26  *
  27  * Simple function to decide if a particular debugging message is
  28  * wanted.  Called from RELAY_CallFrom32 and from in if1632/relay.c
  29  */
  30 int RELAY_ShowDebugmsgRelay(const char *func) {
  31
  32   if(debug_relay_excludelist || debug_relay_includelist) {
  33     const char *term = strchr(func, ':');
  34     char **listitem;
  35     int len, len2, itemlen, show;
  36
  37     if(debug_relay_excludelist) {
  38       show = 1;
  39       listitem = debug_relay_excludelist;
  40     } else {
  41       show = 0;
  42       listitem = debug_relay_includelist;
  43     }
  44     assert(term);
  45     assert(strlen(term) > 2);
  46     len = term - func;
  47     len2 = strchr(func, '.') - func;
  48     assert(len2 && len2 > 0 && len2 < 64);
  49     term += 2;
  50     for(; *listitem; listitem++) {
  51       itemlen = strlen(*listitem);
  52       if((itemlen == len && !strncasecmp(*listitem, func, len)) ||
  53          (itemlen == len2 && !strncasecmp(*listitem, func, len2)) ||
  54          !strcasecmp(*listitem, term)) {
  55         show = !show;
  56        break;
  57       }
  58     }
  59     return show;
  60   }
  61   return 1;
  62 }
  63
  64
  65 #ifdef __i386__
  66
  67 typedef struct
  68 {
  69     BYTE          call;                    /* 0xe8 call callfrom32 (relative) */
  70     DWORD         callfrom32 WINE_PACKED;  /* RELAY_CallFrom32 relative addr */
  71     BYTE          ret;                     /* 0xc2 ret $n  or  0xc3 ret */
  72     WORD          args;                    /* nb of args to remove from the stack */
  73     void         *orig;                    /* original entry point */
  74     DWORD         argtypes;                /* argument types */
  75 } DEBUG_ENTRY_POINT;
  76
  77
  78 /***********************************************************************
  79  *           find_exported_name
  80  *
  81  * Find the name of an exported function.
  82  */
  83 static const char *find_exported_name( const char *module,
  84                                        IMAGE_EXPORT_DIRECTORY *exp, int ordinal )
  85 {
  86     int i;
  87     const char *ret = NULL;
  88
  89     WORD *ordptr = (WORD *)(module + exp->AddressOfNameOrdinals);
  90     for (i = 0; i < exp->NumberOfNames; i++, ordptr++)
  91         if (*ordptr + exp->Base == ordinal) break;
  92     if (i < exp->NumberOfNames)
  93         ret = module + ((DWORD*)(module + exp->AddressOfNames))[i];
  94     return ret;
  95 }
  96
  97
  98 /***********************************************************************
  99  *           get_entry_point
 100  *
 101  * Get the name of the DLL entry point corresponding to a relay address.
 102  */
 103 static void get_entry_point( char *buffer, DEBUG_ENTRY_POINT *relay )
 104 {
 105     IMAGE_DATA_DIRECTORY *dir;
 106     IMAGE_EXPORT_DIRECTORY *exp = NULL;
 107     DEBUG_ENTRY_POINT *debug;
 108     char *base = NULL;
 109     const char *name;
 110     int ordinal = 0;
 111     WINE_MODREF *wm;
 112
 113     /* First find the module */
 114
 115     for (wm = PROCESS_Current()->modref_list; wm; wm = wm->next)
 116     {
 117         if (!(wm->flags & WINE_MODREF_INTERNAL)) continue;
 118         base = (char *)wm->module;
 119         dir = &PE_HEADER(base)->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
 120         if (!dir->Size) continue;
 121         exp = (IMAGE_EXPORT_DIRECTORY *)(base + dir->VirtualAddress);
 122         debug = (DEBUG_ENTRY_POINT *)((char *)exp + dir->Size);
 123         if (debug <= relay && relay < debug + exp->NumberOfFunctions)
 124         {
 125             ordinal = relay - debug;
 126             break;
 127         }
 128     }
 129
 130     /* Now find the function */
 131
 132     name = find_exported_name( base, exp, ordinal + exp->Base );
 133     sprintf( buffer, "%s.%ld: %s", base + exp->Name, ordinal + exp->Base, name ? name : "@" );
 134 }
 135
 136
 137 /***********************************************************************
 138  *           RELAY_PrintArgs
 139  */
 140 static inline void RELAY_PrintArgs( int *args, int nb_args, unsigned int typemask )
 141 {
 142     while (nb_args--)
 143     {
 144         if ((typemask & 3) && HIWORD(*args))
 145         {
 146             if (typemask & 2)
 147                 DPRINTF( "%08x %s", *args, debugstr_w((LPWSTR)*args) );
 148             else
 149                 DPRINTF( "%08x %s", *args, debugstr_a((LPCSTR)*args) );
 150         }
 151         else DPRINTF( "%08x", *args );
 152         if (nb_args) DPRINTF( "," );
 153         args++;
 154         typemask >>= 2;
 155     }
 156 }
 157
 158
 159 typedef LONGLONG WINAPI (*LONGLONG_FARPROC)();
 160
 161 /***********************************************************************
 162  *           RELAY_CallFrom32
 163  *
 164  * Stack layout on entry to this function:
 165  *  ...      ...
 166  * (esp+12)  arg2
 167  * (esp+8)   arg1
 168  * (esp+4)   ret_addr
 169  * (esp)     return addr to relay code
 170  */
 171 static LONGLONG RELAY_CallFrom32( int ret_addr, ... )
 172 {
 173     LONGLONG ret;
 174     char buffer[80];
 175     BOOL ret64;
 176
 177     int *args = &ret_addr + 1;
 178     /* Relay addr is the return address for this function */
 179     BYTE *relay_addr = (BYTE *)__builtin_return_address(0);
 180     DEBUG_ENTRY_POINT *relay = (DEBUG_ENTRY_POINT *)(relay_addr - 5);
 181     WORD nb_args = relay->args / sizeof(int);
 182
 183     get_entry_point( buffer, relay );
 184
 185     DPRINTF( "Call %s(", buffer );
 186     RELAY_PrintArgs( args, nb_args, relay->argtypes );
 187     DPRINTF( ") ret=%08x fs=%04x\n", ret_addr, __get_fs() );
 188     ret64 = (relay->argtypes & 0x80000000) && (nb_args < 16);
 189
 190     /* the user driver functions may be called with the window lock held */
 191     if (memcmp( buffer, "x11drv.", 7 ) && memcmp( buffer, "ttydrv.", 7 ))
 192       SYSLEVEL_CheckNotLevel( 2 );
 193
 194     if (relay->ret == 0xc3) /* cdecl */
 195     {
 196         LONGLONG (*cfunc)() = relay->orig;
 197         switch(nb_args)
 198         {
 199         case 0: ret = cfunc(); break;
 200         case 1: ret = cfunc(args[0]); break;
 201         case 2: ret = cfunc(args[0],args[1]); break;
 202         case 3: ret = cfunc(args[0],args[1],args[2]); break;
 203         case 4: ret = cfunc(args[0],args[1],args[2],args[3]); break;
 204         case 5: ret = cfunc(args[0],args[1],args[2],args[3],args[4]); break;
 205         case 6: ret = cfunc(args[0],args[1],args[2],args[3],args[4],
 206                             args[5]); break;
 207         case 7: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 208                             args[6]); break;
 209         case 8: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 210                             args[6],args[7]); break;
 211         case 9: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 212                             args[6],args[7],args[8]); break;
 213         case 10: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 214                              args[6],args[7],args[8],args[9]); break;
 215         case 11: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 216                              args[6],args[7],args[8],args[9],args[10]); break;
 217         case 12: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 218                              args[6],args[7],args[8],args[9],args[10],
 219                              args[11]); break;
 220         case 13: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 221                              args[6],args[7],args[8],args[9],args[10],args[11],
 222                              args[12]); break;
 223         case 14: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 224                              args[6],args[7],args[8],args[9],args[10],args[11],
 225                              args[12],args[13]); break;
 226         case 15: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 227                              args[6],args[7],args[8],args[9],args[10],args[11],
 228                              args[12],args[13],args[14]); break;
 229         case 16: ret = cfunc(args[0],args[1],args[2],args[3],args[4],args[5],
 230                              args[6],args[7],args[8],args[9],args[10],args[11],
 231                              args[12],args[13],args[14],args[15]); break;
 232         default:
 233             ERR( "Unsupported nb of args %d\n", nb_args );
 234             assert(FALSE);
 235         }
 236     }
 237     else  /* stdcall */
 238     {
 239         LONGLONG_FARPROC func = relay->orig;
 240         switch(nb_args)
 241         {
 242         case 0: ret = func(); break;
 243         case 1: ret = func(args[0]); break;
 244         case 2: ret = func(args[0],args[1]); break;
 245         case 3: ret = func(args[0],args[1],args[2]); break;
 246         case 4: ret = func(args[0],args[1],args[2],args[3]); break;
 247         case 5: ret = func(args[0],args[1],args[2],args[3],args[4]); break;
 248         case 6: ret = func(args[0],args[1],args[2],args[3],args[4],
 249                            args[5]); break;
 250         case 7: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 251                            args[6]); break;
 252         case 8: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 253                            args[6],args[7]); break;
 254         case 9: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 255                            args[6],args[7],args[8]); break;
 256         case 10: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 257                             args[6],args[7],args[8],args[9]); break;
 258         case 11: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 259                             args[6],args[7],args[8],args[9],args[10]); break;
 260         case 12: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 261                             args[6],args[7],args[8],args[9],args[10],
 262                             args[11]); break;
 263         case 13: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 264                             args[6],args[7],args[8],args[9],args[10],args[11],
 265                             args[12]); break;
 266         case 14: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 267                             args[6],args[7],args[8],args[9],args[10],args[11],
 268                             args[12],args[13]); break;
 269         case 15: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 270                             args[6],args[7],args[8],args[9],args[10],args[11],
 271                             args[12],args[13],args[14]); break;
 272         case 16: ret = func(args[0],args[1],args[2],args[3],args[4],args[5],
 273                             args[6],args[7],args[8],args[9],args[10],args[11],
 274                             args[12],args[13],args[14],args[15]); break;
 275         default:
 276             ERR( "Unsupported nb of args %d\n", nb_args );
 277             assert(FALSE);
 278         }
 279     }
 280     if (ret64)
 281         DPRINTF( "Ret  %s() retval=%08x%08x ret=%08x fs=%04x\n",
 282                  buffer, (UINT)(ret >> 32), (UINT)ret, ret_addr, __get_fs() );
 283     else
 284         DPRINTF( "Ret  %s() retval=%08x ret=%08x fs=%04x\n",
 285                  buffer, (UINT)ret, ret_addr, __get_fs() );
 286
 287     if (memcmp( buffer, "x11drv.", 7 ) && memcmp( buffer, "ttydrv.", 7 ))
 288       SYSLEVEL_CheckNotLevel( 2 );
 289
 290     return ret;
 291 }
 292
 293
 294 /***********************************************************************
 295  *           RELAY_CallFrom32Regs
 296  *
 297  * Stack layout (esp is context->Esp, not the current %esp):
 298  *
 299  * ...
 300  * (esp+4) first arg
 301  * (esp)   return addr to caller
 302  * (esp-4) return addr to DEBUG_ENTRY_POINT
 303  * (esp-8) ptr to relay entry code for RELAY_CallFrom32Regs
 304  *  ...    >128 bytes space free to be modified (ensured by the assembly glue)
 305  */
 306
 307 void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context );
 308 DEFINE_REGS_ENTRYPOINT_0( RELAY_CallFrom32Regs, RELAY_DoCallFrom32Regs )
 309 void WINAPI RELAY_DoCallFrom32Regs( CONTEXT86 *context )
 310 {
 311     char buffer[80];
 312     int* args;
 313     FARPROC func;
 314     BYTE *entry_point;
 315
 316     BYTE *relay_addr = *((BYTE **)context->Esp - 1);
 317     DEBUG_ENTRY_POINT *relay = (DEBUG_ENTRY_POINT *)(relay_addr - 5);
 318     WORD nb_args = (relay->args & ~0x8000) / sizeof(int);
 319
 320     /* remove extra stuff from the stack */
 321     context->Eip = stack32_pop(context);
 322     args = (int *)context->Esp;
 323     context->Esp += 4 * nb_args;
 324
 325     assert(TRACE_ON(relay));
 326
 327     entry_point = (BYTE *)relay->orig;
 328     assert( *entry_point == 0xe8 /* lcall */ );
 329     func = *(FARPROC *)(entry_point + 5);
 330
 331     get_entry_point( buffer, relay );
 332
 333     DPRINTF( "Call %s(", buffer );
 334     RELAY_PrintArgs( args, nb_args, relay->argtypes );
 335     DPRINTF( ") ret=%08lx fs=%04lx\n", context->Eip, context->SegFs );
 336
 337     DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
 338             context->Eax, context->Ebx, context->Ecx,
 339             context->Edx, context->Esi, context->Edi );
 340     DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx gs=%04lx flags=%08lx\n",
 341             context->Ebp, context->Esp, context->SegDs,
 342             context->SegEs, context->SegGs, context->EFlags );
 343
 344     SYSLEVEL_CheckNotLevel( 2 );
 345
 346     /* Now call the real function */
 347     switch(nb_args)
 348     {
 349     case 0: func(context); break;
 350     case 1: func(args[0],context); break;
 351     case 2: func(args[0],args[1],context); break;
 352     case 3: func(args[0],args[1],args[2],context); break;
 353     case 4: func(args[0],args[1],args[2],args[3],context); break;
 354     case 5: func(args[0],args[1],args[2],args[3],args[4],context); break;
 355     case 6: func(args[0],args[1],args[2],args[3],args[4],args[5],context); break;
 356     case 7: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],context); break;
 357     case 8: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],context); break;
 358     case 9: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 359                  context); break;
 360     case 10: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 361                   args[9],context); break;
 362     case 11: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 363                   args[9],args[10],context); break;
 364     case 12: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 365                   args[9],args[10],args[11],context); break;
 366     case 13: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 367                   args[9],args[10],args[11],args[12],context); break;
 368     case 14: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 369                   args[9],args[10],args[11],args[12],args[13],context); break;
 370     case 15: func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],
 371                   args[9],args[10],args[11],args[12],args[13],args[14],context); break;
 372     case 16: func(args[0],args[1],args[2],args[3],args[4],args[5], args[6],args[7],args[8],
 373                   args[9],args[10],args[11],args[12],args[13],args[14],args[15],context); break;
 374     default:
 375         ERR( "Unsupported nb of args %d\n", nb_args );
 376         assert(FALSE);
 377     }
 378
 379     DPRINTF( "Ret  %s() retval=%08lx ret=%08lx fs=%04lx\n",
 380              buffer, context->Eax, context->Eip, context->SegFs );
 381
 382     DPRINTF(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
 383             context->Eax, context->Ebx, context->Ecx,
 384             context->Edx, context->Esi, context->Edi );
 385     DPRINTF(" ebp=%08lx esp=%08lx ds=%04lx es=%04lx gs=%04lx flags=%08lx\n",
 386             context->Ebp, context->Esp, context->SegDs,
 387             context->SegEs, context->SegGs, context->EFlags );
 388
 389     SYSLEVEL_CheckNotLevel( 2 );
 390 }
 391
 392
 393 /***********************************************************************
 394  *           RELAY_SetupDLL
 395  *
 396  * Setup relay debugging for a built-in dll.
 397  */
 398 void RELAY_SetupDLL( const char *module )
 399 {
 400     IMAGE_DATA_DIRECTORY *dir;
 401     IMAGE_EXPORT_DIRECTORY *exports;
 402     DEBUG_ENTRY_POINT *debug;
 403     DWORD *funcs;
 404     int i;
 405     const char *name, *dllname;
 406
 407     dir = &PE_HEADER(module)->OptionalHeader.DataDirectory[IMAGE_FILE_EXPORT_DIRECTORY];
 408     if (!dir->Size) return;
 409     exports = (IMAGE_EXPORT_DIRECTORY *)(module + dir->VirtualAddress);
 410     debug = (DEBUG_ENTRY_POINT *)((char *)exports + dir->Size);
 411     funcs = (DWORD *)(module + exports->AddressOfFunctions);
 412     dllname = module + exports->Name;
 413
 414     for (i = 0; i < exports->NumberOfFunctions; i++, funcs++, debug++)
 415     {
 416         int on = 1;
 417
 418         if (!debug->call) continue;  /* not a normal function */
 419
 420         if ((name = find_exported_name( module, exports, i + exports->Base )))
 421         {
 422             char buffer[200];
 423             sprintf( buffer, "%s.%d: %s", dllname, i, name );
 424             on = RELAY_ShowDebugmsgRelay(buffer);
 425         }
 426
 427         if (on)
 428         {
 429             debug->call = 0xe8;  /* call relative */
 430             if (debug->args & 0x8000)  /* register func */
 431                 debug->callfrom32 = (char *)RELAY_CallFrom32Regs - (char *)&debug->ret;
 432             else
 433                 debug->callfrom32 = (char *)RELAY_CallFrom32 - (char *)&debug->ret;
 434         }
 435         else
 436         {
 437             debug->call = 0xe9;  /* jmp relative */
 438             debug->callfrom32 = (char *)debug->orig - (char *)&debug->ret;
 439         }
 440
 441         debug->orig = (FARPROC)(module + (DWORD)*funcs);
 442         *funcs = (char *)debug - module;
 443     }
 444 }
 445
 446 #else  /* __i386__ */
 447
 448 void RELAY_SetupDLL( const char *module )
 449 {
 450 }
 451
 452 #endif /* __i386__ */