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