if1632/relay.c

   1 /*
   2  * Copyright 1993 Robert J. Amstadt
   3  * Copyright 1995 Alexandre Julliard
   4  */
   5
   6 #include <stdio.h>
   7 #include "windows.h"
   8 #include "winnt.h"
   9 #include "global.h"
  10 #include "module.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     return TRUE;
  48 }
  49
  50
  51 /***********************************************************************
  52  *           RELAY_DebugCallFrom16
  53  */
  54 void RELAY_DebugCallFrom16( int func_type, char *args,
  55                             void *entry_point, CONTEXT *context )
  56 {
  57     STACK16FRAME *frame;
  58     WORD ordinal;
  59     char *args16;
  60     int i;
  61
  62     if (!debugging_relay) return;
  63
  64     frame = CURRENT_STACK16;
  65     printf( "Call %s(", BUILTIN_GetEntryPoint16( frame->entry_cs,
  66                                                  frame->entry_ip,
  67                                                  &ordinal ));
  68     args16 = (char *)frame->args;
  69     for (i = 0; i < strlen(args); i++)
  70     {
  71         switch(args[i])
  72         {
  73         case 'w':
  74         case 's':
  75             args16 += 2;
  76             break;
  77         case 'l':
  78         case 'p':
  79             args16 += 4;
  80             break;
  81         }
  82     }
  83
  84     while (*args)
  85     {
  86         switch(*args)
  87         {
  88         case 'w':
  89         case 's':
  90             args16 -= 2;
  91             printf( "0x%04x", *(WORD *)args16 );
  92             break;
  93         case 'l':
  94             args16 -= 4;
  95             printf( "0x%08x", *(int *)args16 );
  96             break;
  97         case 'p':
  98             args16 -= 4;
  99             printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 100             break;
 101         }
 102         args++;
 103         if (*args) printf( "," );
 104     }
 105     printf( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
 106
 107     if (func_type == 2)  /* register function */
 108         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 109                 AX_reg(context), BX_reg(context), CX_reg(context),
 110                 DX_reg(context), SI_reg(context), DI_reg(context),
 111                 (WORD)ES_reg(context), EFL_reg(context) );
 112 }
 113
 114
 115 /***********************************************************************
 116  *           RELAY_DebugCallFrom16Ret
 117  */
 118 void RELAY_DebugCallFrom16Ret( int func_type, int ret_val, CONTEXT *context)
 119 {
 120     STACK16FRAME *frame;
 121     WORD ordinal;
 122
 123     if (!debugging_relay) return;
 124     frame = CURRENT_STACK16;
 125     printf( "Ret  %s() ", BUILTIN_GetEntryPoint16( frame->entry_cs,
 126                                                    frame->entry_ip,
 127                                                    &ordinal ));
 128     switch(func_type)
 129     {
 130     case 0: /* long */
 131         printf( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
 132                 ret_val, frame->cs, frame->ip, frame->ds );
 133         break;
 134     case 1: /* word */
 135         printf( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
 136                 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
 137         break;
 138     case 2: /* regs */
 139         printf( "retval=none ret=%04x:%04x ds=%04x\n",
 140                 frame->cs, frame->ip, frame->ds );
 141         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 142                 AX_reg(context), BX_reg(context), CX_reg(context),
 143                 DX_reg(context), SI_reg(context), DI_reg(context),
 144                 (WORD)ES_reg(context), EFL_reg(context) );
 145         break;
 146     }
 147 }
 148
 149
 150 /***********************************************************************
 151  *           RELAY_Unimplemented16
 152  *
 153  * This function is called for unimplemented 16-bit entry points (declared
 154  * as 'stub' in the spec file).
 155  */
 156 void RELAY_Unimplemented16(void)
 157 {
 158     WORD ordinal;
 159     STACK16FRAME *frame = CURRENT_STACK16;
 160     fprintf(stderr,"No handler for Win16 routine %s (called from %04x:%04x)\n",
 161             BUILTIN_GetEntryPoint16(frame->entry_cs,frame->entry_ip,&ordinal),
 162             frame->cs, frame->ip );
 163     TASK_KillCurrentTask(1);
 164 }
 165
 166
 167 /***********************************************************************
 168  *           RELAY_Unimplemented32
 169  *
 170  * This function is called for unimplemented 32-bit entry points (declared
 171  * as 'stub' in the spec file).
 172  * (The args are the same than for RELAY_DebugCallFrom32).
 173  */
 174 void RELAY_Unimplemented32( int nb_args, void *relay_addr,
 175                             void *entry_point, int ebp, int ret_addr )
 176 {
 177     fprintf( stderr, "No handler for Win32 routine %s (called from %08x)\n",
 178              BUILTIN_GetEntryPoint32( relay_addr ), ret_addr );
 179     TASK_KillCurrentTask(1);
 180 }
 181
 182
 183 /***********************************************************************
 184  *           RELAY_DebugCallTo16
 185  *
 186  * 'stack' points to the called function address on the 32-bit stack.
 187  * Stack layout:
 188  *  ...        ...
 189  * (stack+8)   arg2
 190  * (stack+4)   arg1
 191  * (stack)     func to call
 192  */
 193 void RELAY_DebugCallTo16( int* stack, int nb_args )
 194 {
 195     if (!debugging_relay) return;
 196
 197     if (nb_args == -1)  /* Register function */
 198     {
 199         CONTEXT *context = *(CONTEXT **)stack;
 200         printf( "CallTo16(func=%04lx:%04x,ds=%04lx)\n",
 201                 CS_reg(context), IP_reg(context), DS_reg(context) );
 202         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x\n",
 203                 AX_reg(context), BX_reg(context), CX_reg(context),
 204                 DX_reg(context), SI_reg(context), DI_reg(context),
 205                 BP_reg(context), (WORD)ES_reg(context) );
 206     }
 207     else
 208     {
 209         printf( "CallTo16(func=%04x:%04x,ds=%04x",
 210                 HIWORD(stack[0]), LOWORD(stack[0]), CURRENT_DS );
 211         stack++;
 212         while (nb_args--) printf( ",0x%04x", *stack++ );
 213         printf( ")\n" );
 214     }
 215 }
 216
 217
 218 /***********************************************************************
 219  *           RELAY_DebugCallFrom32
 220  *
 221  * 'stack' points to the saved ebp on the stack.
 222  * Stack layout:
 223  *  ...        ...
 224  * (stack+12)  arg2
 225  * (stack+8)   arg1
 226  * (stack+4)   ret addr
 227  * (stack)     ebp
 228  * (stack-4)   entry point
 229  * (stack-8)   relay addr
 230  */
 231 void RELAY_DebugCallFrom32( int *stack, int nb_args )
 232 {
 233     int *parg, i;
 234
 235     if (!debugging_relay) return;
 236     printf( "Call %s(", BUILTIN_GetEntryPoint32( (void *)stack[-2] ));
 237     for (i = nb_args & 0x7fffffff, parg = &stack[2]; i; parg++, i--)
 238     {
 239         printf( "%08x", *parg );
 240         if (i > 1) printf( "," );
 241     }
 242     printf( ") ret=%08x\n", stack[1] );
 243     if (nb_args & 0x80000000)  /* Register function */
 244     {
 245         CONTEXT *context = (CONTEXT *)((BYTE *)stack - sizeof(CONTEXT) - 8);
 246         printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
 247                 context->Eax, context->Ebx, context->Ecx, context->Edx,
 248                 context->Esi, context->Edi );
 249         printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
 250                 context->Ebp, context->Esp, context->Eip, context->SegDs,
 251                 context->SegEs, context->SegFs, context->SegGs,
 252                 context->EFlags );
 253     }
 254 }
 255
 256
 257 /***********************************************************************
 258  *           RELAY_DebugCallFrom32Ret
 259  *
 260  * 'stack' points to the saved ebp on the stack.
 261  * Stack layout:
 262  *  ...        ...
 263  * (stack+12)  arg2
 264  * (stack+8)   arg1
 265  * (stack+4)   ret addr
 266  * (stack)     ebp
 267  * (stack-4)   entry point
 268  * (stack-8)   relay addr
 269  */
 270 void RELAY_DebugCallFrom32Ret( int *stack, int nb_args, int ret_val )
 271 {
 272     if (!debugging_relay) return;
 273     printf( "Ret  %s() retval=%08x ret=%08x\n",
 274             BUILTIN_GetEntryPoint32( (void *)stack[-2] ), ret_val, stack[1] );
 275     if (nb_args & 0x80000000)  /* Register function */
 276     {
 277         CONTEXT *context = (CONTEXT *)((BYTE *)stack - sizeof(CONTEXT) - 8);
 278         printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
 279                 context->Eax, context->Ebx, context->Ecx, context->Edx,
 280                 context->Esi, context->Edi );
 281         printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
 282                 context->Ebp, context->Esp, context->Eip, context->SegDs,
 283                 context->SegEs, context->SegFs, context->SegGs,
 284                 context->EFlags );
 285     }
 286 }
 287
 288
 289 /***********************************************************************
 290  *           RELAY_DebugCallTo32
 291  */
 292 void RELAY_DebugCallTo32( unsigned int func, int nbargs, unsigned int arg1  )
 293 {
 294     unsigned int *argptr;
 295
 296     if (!debugging_relay) return;
 297
 298     printf( "CallTo32(func=%08x", func );
 299     for (argptr = &arg1; nbargs; nbargs--, argptr++)
 300         printf( ",%08x", *argptr );
 301     printf( ")\n" );
 302 }
 303
 304
 305 /**********************************************************************
 306  *           Catch    (KERNEL.55)
 307  */
 308 INT16 Catch( LPCATCHBUF lpbuf )
 309 {
 310     STACK16FRAME *pFrame = CURRENT_STACK16;
 311
 312     /* Note: we don't save the current ss, as the catch buffer is */
 313     /* only 9 words long. Hopefully no one will have the silly    */
 314     /* idea to change the current stack before calling Throw()... */
 315
 316     /* Windows uses:
 317      * lpbuf[0] = ip
 318      * lpbuf[1] = cs
 319      * lpbuf[2] = sp
 320      * lpbuf[3] = bp
 321      * lpbuf[4] = si
 322      * lpbuf[5] = di
 323      * lpbuf[6] = ds
 324      * lpbuf[7] = unused
 325      * lpbuf[8] = ss
 326      */
 327     /* FIXME: we need to save %si and %di */
 328
 329     lpbuf[0] = IF1632_Saved16_sp;
 330     lpbuf[1] = LOWORD(IF1632_Saved32_esp);
 331     lpbuf[2] = HIWORD(IF1632_Saved32_esp);
 332     lpbuf[3] = pFrame->saved_ss;
 333     lpbuf[4] = pFrame->saved_sp;
 334     lpbuf[5] = pFrame->ds;
 335     lpbuf[6] = pFrame->bp;
 336     lpbuf[7] = pFrame->ip;
 337     lpbuf[8] = pFrame->cs;
 338     return 0;
 339 }
 340
 341
 342 /**********************************************************************
 343  *           Throw    (KERNEL.56)
 344  */
 345 INT16 Throw( LPCATCHBUF lpbuf, INT16 retval )
 346 {
 347     STACK16FRAME *pFrame;
 348     WORD es = CURRENT_STACK16->es;
 349
 350     IF1632_Saved16_sp  = lpbuf[0] - sizeof(WORD);
 351     IF1632_Saved32_esp = MAKELONG( lpbuf[1], lpbuf[2] );
 352     pFrame = CURRENT_STACK16;
 353     pFrame->saved_ss   = lpbuf[3];
 354     pFrame->saved_sp   = lpbuf[4];
 355     pFrame->ds         = lpbuf[5];
 356     pFrame->bp         = lpbuf[6];
 357     pFrame->ip         = lpbuf[7];
 358     pFrame->cs         = lpbuf[8];
 359     pFrame->es         = es;
 360     if (debugging_relay)  /* Make sure we have a valid entry point address */
 361     {
 362         static FARPROC16 entryPoint = NULL;
 363
 364         if (!entryPoint)  /* Get entry point for Throw() */
 365             entryPoint = MODULE_GetEntryPoint( GetModuleHandle16("KERNEL"),
 366                                                56 );
 367         pFrame->entry_cs = SELECTOROF(entryPoint);
 368         pFrame->entry_ip = OFFSETOF(entryPoint);
 369     }
 370     return retval;
 371 }