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