if1632/relay.c

   1 /*
   2  * Copyright 1993 Robert J. Amstadt
   3  * Copyright 1995 Alexandre Julliard
   4  */
   5
   6 #include <stdio.h>
   7
   8 #include "global.h"
   9 #include "module.h"
  10 #include "registers.h"
  11 #include "stackframe.h"
  12 #include "stddebug.h"
  13 /* #define DEBUG_RELAY */
  14 #include "debug.h"
  15
  16 #if 0
  17 /* Make make_debug think these were really used */
  18 dprintf_relay
  19 #endif
  20
  21   /* Saved 16-bit stack for current process (Win16 only) */
  22 WORD IF1632_Saved16_ss = 0;
  23 WORD IF1632_Saved16_sp = 0;
  24
  25   /* Saved 32-bit stack for current process (Win16 only) */
  26 DWORD IF1632_Saved32_esp = 0;
  27 SEGPTR IF1632_Stack32_base = 0;
  28
  29   /* Original Unix stack */
  30 DWORD IF1632_Original32_esp;
  31
  32
  33 /***********************************************************************
  34  *           RELAY_Init
  35  */
  36 BOOL RELAY_Init(void)
  37 {
  38     WORD codesel;
  39
  40       /* Allocate the code selector for CallTo16 routines */
  41
  42     extern void CALLTO16_Start(), CALLTO16_End();
  43     extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
  44     extern DWORD CALLTO16_RetAddr_word, CALLTO16_RetAddr_long;
  45
  46     codesel = GLOBAL_CreateBlock( GMEM_FIXED, (void *)CALLTO16_Start,
  47                                    (int)CALLTO16_End - (int)CALLTO16_Start,
  48                                    0, TRUE, TRUE, FALSE, NULL );
  49     if (!codesel) return FALSE;
  50
  51       /* Patch the return addresses for CallTo16 routines */
  52
  53     CALLTO16_RetAddr_word=MAKELONG( (int)CALLTO16_Ret_word-(int)CALLTO16_Start,
  54                                     codesel );
  55     CALLTO16_RetAddr_long=MAKELONG( (int)CALLTO16_Ret_long-(int)CALLTO16_Start,
  56                                     codesel );
  57
  58     return TRUE;
  59 }
  60
  61
  62 /***********************************************************************
  63  *           RELAY_DebugCallFrom16
  64  */
  65 void RELAY_DebugCallFrom16( int func_type, char *args,
  66                             void *entry_point, int args32 )
  67 {
  68     STACK16FRAME *frame;
  69     NE_MODULE *pModule;
  70     WORD ordinal;
  71     char *args16, *name;
  72     int i;
  73
  74     if (!debugging_relay) return;
  75
  76     frame = CURRENT_STACK16;
  77     pModule = BUILTIN_GetEntryPoint( frame->entry_cs, frame->entry_ip,
  78                                      &ordinal, &name );
  79     printf( "Call %.*s.%d: %.*s(",
  80             *((BYTE *)pModule + pModule->name_table),
  81             (char *)pModule + pModule->name_table + 1,
  82             ordinal, *name, name + 1 );
  83
  84     args16 = (char *)frame->args;
  85     for (i = 0; i < strlen(args); i++)
  86     {
  87         switch(args[i])
  88         {
  89         case 'w':
  90         case 's':
  91             args16 += 2;
  92             break;
  93         case 'l':
  94         case 'p':
  95             args16 += 4;
  96             break;
  97         }
  98     }
  99
 100     while (*args)
 101     {
 102         switch(*args)
 103         {
 104         case 'w':
 105         case 's':
 106             args16 -= 2;
 107             printf( "0x%04x", *(WORD *)args16 );
 108             break;
 109         case 'l':
 110             args16 -= 4;
 111             printf( "0x%08x", *(int *)args16 );
 112             break;
 113         case 'p':
 114             args16 -= 4;
 115             printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 116             break;
 117         }
 118         args++;
 119         if (*args) printf( "," );
 120     }
 121     printf( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
 122
 123     if (func_type == 2)  /* register function */
 124     {
 125         struct sigcontext_struct *context = (struct sigcontext_struct *)&args32;
 126         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 127                 AX_reg(context), BX_reg(context), CX_reg(context),
 128                 DX_reg(context), SI_reg(context), DI_reg(context),
 129                 ES_reg(context), EFL_reg(context) );
 130     }
 131 }
 132
 133
 134 /***********************************************************************
 135  *           RELAY_DebugCallFrom16Ret
 136  */
 137 void RELAY_DebugCallFrom16Ret( int func_type, int ret_val, int args32 )
 138 {
 139     STACK16FRAME *frame;
 140     NE_MODULE *pModule;
 141     WORD ordinal;
 142     char *name;
 143
 144     if (*(DWORD *)PTR_SEG_TO_LIN(IF1632_Stack32_base) != 0xDEADBEEF)
 145     {
 146         fprintf(stderr, "Wine wrote past the end of the 32 bit stack. Please report this.\n");
 147         exit(1);  /* There's probably no point in going on */
 148     }
 149     if (!debugging_relay) return;
 150
 151     frame   = CURRENT_STACK16;
 152     pModule = BUILTIN_GetEntryPoint( frame->entry_cs, frame->entry_ip,
 153                                      &ordinal, &name );
 154     printf( "Ret  %.*s.%d: %.*s() ",
 155             *((BYTE *)pModule + pModule->name_table),
 156             (char *)pModule + pModule->name_table + 1,
 157             ordinal, *name, name + 1 );
 158
 159     switch(func_type)
 160     {
 161     case 0: /* long */
 162         printf( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
 163                 ret_val, frame->cs, frame->ip, frame->ds );
 164         break;
 165     case 1: /* word */
 166         printf( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
 167                 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
 168         break;
 169     case 2: /* regs */
 170         printf( "retval=none ret=%04x:%04x ds=%04x\n",
 171                 frame->cs, frame->ip, frame->ds );
 172         {
 173             struct sigcontext_struct *context = (struct sigcontext_struct *)&args32;
 174             printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 175                     AX_reg(context), BX_reg(context), CX_reg(context),
 176                     DX_reg(context), SI_reg(context), DI_reg(context),
 177                     ES_reg(context), EFL_reg(context) );
 178         }
 179         break;
 180     }
 181 }
 182
 183
 184 /***********************************************************************
 185  *           RELAY_Unimplemented16
 186  *
 187  * This function is called for unimplemented 16-bit entry points (declared
 188  * as 'stub' in the spec file).
 189  */
 190 void RELAY_Unimplemented16(void)
 191 {
 192     WORD ordinal;
 193     char *name;
 194     STACK16FRAME *frame = CURRENT_STACK16;
 195     NE_MODULE *pModule  = BUILTIN_GetEntryPoint( frame->entry_cs,
 196                                                  frame->entry_ip,
 197                                                  &ordinal, &name );
 198     fprintf( stderr, "No handler for routine %.*s.%d (%.*s)\n",
 199              *((BYTE *)pModule + pModule->name_table),
 200              (char *)pModule + pModule->name_table + 1,
 201              ordinal, *name, name + 1 );
 202     exit(1);
 203 }
 204
 205
 206 /***********************************************************************
 207  *           RELAY_Unimplemented32
 208  *
 209  * This function is called for unimplemented 32-bit entry points (declared
 210  * as 'stub' in the spec file).
 211  * (The args are the same than for RELAY_DebugCallFrom32).
 212  */
 213 void RELAY_Unimplemented32( int nb_args, void *entry_point,
 214                             const char *func_name )
 215 {
 216     fprintf( stderr, "No handler for Win32 routine %s\n", func_name );
 217     exit(1);
 218 }
 219
 220
 221 /***********************************************************************
 222  *           RELAY_DebugCallTo16
 223  *
 224  * 'stack' points to the called function address on the 32-bit stack.
 225  * Stack layout:
 226  *  ...        ...
 227  * (stack+12)  arg2
 228  * (stack+8)   arg1
 229  * (stack+4)   16-bit ds
 230  * (stack)     func to call
 231  */
 232 void RELAY_DebugCallTo16( int* stack, int nbargs )
 233 {
 234     if (!debugging_relay) return;
 235
 236     printf( "CallTo16(func=%04x:%04x,ds=%04x",
 237             HIWORD(stack[0]), LOWORD(stack[0]), LOWORD(stack[1]) );
 238     stack += 2;
 239     while (nbargs--) printf( ",0x%04x", *stack++ );
 240     printf( ")\n" );
 241 }
 242
 243
 244 /***********************************************************************
 245  *           RELAY_DebugCallFrom32
 246  */
 247 void RELAY_DebugCallFrom32( int nb_args, void *entry_point,
 248                             const char *func_name, int ebp, int ret_addr,
 249                             int arg1 )
 250 {
 251     int  *parg;
 252     if (!debugging_relay) return;
 253     printf( "Call %s(", func_name );
 254     for (parg = &arg1; nb_args; parg++, nb_args--)
 255     {
 256         printf( "%08x", *parg );
 257         if (nb_args > 1) printf( "," );
 258     }
 259     printf( ") ret=%08x\n", ret_addr );
 260 }
 261
 262
 263 /***********************************************************************
 264  *           RELAY_DebugCallFrom32Ret
 265  */
 266 void RELAY_DebugCallFrom32Ret( int ret_val, void *entry_point,
 267                                const char *func_name, int ebp, int ret_addr )
 268 {
 269     if (!debugging_relay) return;
 270     printf( "Ret  %s() retval=0x%08x ret=%08x\n",
 271             func_name, ret_val, ret_addr );
 272 }
 273
 274
 275 /***********************************************************************
 276  *           RELAY_DebugCallTo32
 277  */
 278 void RELAY_DebugCallTo32( unsigned int func, int nbargs, unsigned int arg1  )
 279 {
 280     unsigned int *argptr;
 281
 282     if (!debugging_relay) return;
 283
 284     printf( "CallTo32(func=%08x", func );
 285     for (argptr = &arg1; nbargs; nbargs--, argptr++)
 286         printf( ",%08x", *argptr );
 287     printf( ")\n" );
 288 }
 289
 290
 291 /**********************************************************************
 292  *           Catch    (KERNEL.55)
 293  */
 294 INT Catch( LPCATCHBUF lpbuf )
 295 {
 296     STACK16FRAME *pFrame = CURRENT_STACK16;
 297
 298     /* Note: we don't save the current ss, as the catch buffer is */
 299     /* only 9 words long. Hopefully no one will have the silly    */
 300     /* idea to change the current stack before calling Throw()... */
 301
 302     lpbuf[0] = IF1632_Saved16_sp;
 303     lpbuf[1] = LOWORD(IF1632_Saved32_esp);
 304     lpbuf[2] = HIWORD(IF1632_Saved32_esp);
 305     lpbuf[3] = pFrame->saved_ss;
 306     lpbuf[4] = pFrame->saved_sp;
 307     lpbuf[5] = pFrame->ds;
 308     lpbuf[6] = pFrame->bp;
 309     lpbuf[7] = pFrame->ip;
 310     lpbuf[8] = pFrame->cs;
 311     return 0;
 312 }
 313
 314
 315 /**********************************************************************
 316  *           Throw    (KERNEL.56)
 317  */
 318 int Throw( LPCATCHBUF lpbuf, int retval )
 319 {
 320     STACK16FRAME *pFrame;
 321
 322     IF1632_Saved16_sp  = lpbuf[0] - sizeof(WORD);
 323     IF1632_Saved32_esp = MAKELONG( lpbuf[1], lpbuf[2] );
 324     pFrame = CURRENT_STACK16;
 325     pFrame->saved_ss   = lpbuf[3];
 326     pFrame->saved_sp   = lpbuf[4];
 327     pFrame->ds         = lpbuf[5];
 328     pFrame->bp         = lpbuf[6];
 329     pFrame->ip         = lpbuf[7];
 330     pFrame->cs         = lpbuf[8];
 331     pFrame->es         = 0;
 332     return retval;
 333 }