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 "callback.h"
  14 #include "xmalloc.h"
  15 #include "stddebug.h"
  16 /* #define DEBUG_RELAY */
  17 #include "debug.h"
  18
  19 #if 0
  20 /* Make make_debug think these were really used */
  21 dprintf_relay
  22 #endif
  23
  24
  25 /***********************************************************************
  26  *           RELAY_Init
  27  */
  28 BOOL32 RELAY_Init(void)
  29 {
  30     WORD codesel;
  31     extern BOOL32 THUNK_Init(void);
  32
  33       /* Allocate the code selector for CallTo16 routines */
  34
  35     extern void CALLTO16_Start(), CALLTO16_End();
  36     extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
  37     extern DWORD CALLTO16_RetAddr_word, CALLTO16_RetAddr_long;
  38
  39     codesel = GLOBAL_CreateBlock( GMEM_FIXED, (void *)CALLTO16_Start,
  40                                    (int)CALLTO16_End - (int)CALLTO16_Start,
  41                                    0, TRUE, TRUE, FALSE, NULL );
  42     if (!codesel) return FALSE;
  43
  44       /* Patch the return addresses for CallTo16 routines */
  45
  46     CALLTO16_RetAddr_word=MAKELONG( (int)CALLTO16_Ret_word-(int)CALLTO16_Start,
  47                                     codesel );
  48     CALLTO16_RetAddr_long=MAKELONG( (int)CALLTO16_Ret_long-(int)CALLTO16_Start,
  49                                     codesel );
  50
  51     /* Initialize thunking */
  52
  53     return THUNK_Init();
  54 }
  55
  56
  57 /***********************************************************************
  58  *           RELAY_DebugCallFrom16
  59  */
  60 void RELAY_DebugCallFrom16( int func_type, char *args,
  61                             void *entry_point, CONTEXT *context )
  62 {
  63     STACK16FRAME *frame;
  64     WORD ordinal;
  65     char *args16;
  66     int i;
  67
  68     if (!debugging_relay) return;
  69
  70     frame = CURRENT_STACK16;
  71     printf( "Call %s(", BUILTIN_GetEntryPoint16( frame->entry_cs,
  72                                                  frame->entry_ip,
  73                                                  &ordinal ));
  74     args16 = (char *)frame->args;
  75     for (i = 0; i < strlen(args); i++)
  76     {
  77         switch(args[i])
  78         {
  79         case 'w':
  80         case 's':
  81             args16 += 2;
  82             break;
  83         case 'l':
  84         case 'p':
  85         case 't':
  86             args16 += 4;
  87             break;
  88         }
  89     }
  90
  91     while (*args)
  92     {
  93         switch(*args)
  94         {
  95         case 'w':
  96         case 's':
  97             args16 -= 2;
  98             printf( "0x%04x", *(WORD *)args16 );
  99             break;
 100         case 'l':
 101             args16 -= 4;
 102             printf( "0x%08x", *(int *)args16 );
 103             break;
 104         case 't':
 105             args16 -= 4;
 106             if (HIWORD(*(int *)args16))
 107                 printf( "0x%08x \"%s\"", *(int *)args16,
 108                         (char *)PTR_SEG_TO_LIN(*(int *)args16) );
 109             else
 110                 printf( "0x%08x", *(int *)args16 );
 111             break;
 112         case 'p':
 113             args16 -= 4;
 114             printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 115             break;
 116         }
 117         args++;
 118         if (*args) printf( "," );
 119     }
 120     printf( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
 121
 122     if (func_type == 2)  /* register function */
 123         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 124                 AX_reg(context), BX_reg(context), CX_reg(context),
 125                 DX_reg(context), SI_reg(context), DI_reg(context),
 126                 (WORD)ES_reg(context), EFL_reg(context) );
 127 }
 128
 129
 130 /***********************************************************************
 131  *           RELAY_DebugCallFrom16Ret
 132  */
 133 void RELAY_DebugCallFrom16Ret( int func_type, int ret_val, CONTEXT *context)
 134 {
 135     STACK16FRAME *frame;
 136     WORD ordinal;
 137
 138     if (!debugging_relay) return;
 139     frame = CURRENT_STACK16;
 140     printf( "Ret  %s() ", BUILTIN_GetEntryPoint16( frame->entry_cs,
 141                                                    frame->entry_ip,
 142                                                    &ordinal ));
 143     switch(func_type)
 144     {
 145     case 0: /* long */
 146         printf( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
 147                 ret_val, frame->cs, frame->ip, frame->ds );
 148         break;
 149     case 1: /* word */
 150         printf( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
 151                 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
 152         break;
 153     case 2: /* regs */
 154         printf( "retval=none ret=%04x:%04x ds=%04x\n",
 155                 frame->cs, frame->ip, frame->ds );
 156         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 157                 AX_reg(context), BX_reg(context), CX_reg(context),
 158                 DX_reg(context), SI_reg(context), DI_reg(context),
 159                 (WORD)ES_reg(context), EFL_reg(context) );
 160         break;
 161     }
 162 }
 163
 164
 165 /***********************************************************************
 166  *           RELAY_Unimplemented16
 167  *
 168  * This function is called for unimplemented 16-bit entry points (declared
 169  * as 'stub' in the spec file).
 170  */
 171 void RELAY_Unimplemented16(void)
 172 {
 173     WORD ordinal;
 174     STACK16FRAME *frame = CURRENT_STACK16;
 175     fprintf(stderr,"No handler for Win16 routine %s (called from %04x:%04x)\n",
 176             BUILTIN_GetEntryPoint16(frame->entry_cs,frame->entry_ip,&ordinal),
 177             frame->cs, frame->ip );
 178     TASK_KillCurrentTask(1);
 179 }
 180
 181
 182 /***********************************************************************
 183  *           RELAY_Unimplemented32
 184  *
 185  * This function is called for unimplemented 32-bit entry points (declared
 186  * as 'stub' in the spec file).
 187  * (The args are the same than for RELAY_DebugCallFrom32).
 188  */
 189 void RELAY_Unimplemented32( int nb_args, void *relay_addr,
 190                             void *entry_point, int ebp, int ret_addr )
 191 {
 192     fprintf( stderr, "No handler for Win32 routine %s (called from %08x)\n",
 193              BUILTIN_GetEntryPoint32( relay_addr ), ret_addr );
 194     TASK_KillCurrentTask(1);
 195 }
 196
 197
 198 /***********************************************************************
 199  *           RELAY_DebugCallTo16
 200  *
 201  * 'stack' points to the called function address on the 32-bit stack.
 202  * Stack layout:
 203  *  ...        ...
 204  * (stack+8)   arg2
 205  * (stack+4)   arg1
 206  * (stack)     func to call
 207  */
 208 void RELAY_DebugCallTo16( int* stack, int nb_args )
 209 {
 210     if (!debugging_relay) return;
 211
 212     if (nb_args == -1)  /* Register function */
 213     {
 214         CONTEXT *context = *(CONTEXT **)stack;
 215         printf( "CallTo16(func=%04lx:%04x,ds=%04lx)\n",
 216                 CS_reg(context), IP_reg(context), DS_reg(context) );
 217         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x\n",
 218                 AX_reg(context), BX_reg(context), CX_reg(context),
 219                 DX_reg(context), SI_reg(context), DI_reg(context),
 220                 BP_reg(context), (WORD)ES_reg(context) );
 221     }
 222     else
 223     {
 224         printf( "CallTo16(func=%04x:%04x,ds=%04x",
 225                 HIWORD(stack[0]), LOWORD(stack[0]), CURRENT_DS );
 226         stack++;
 227         while (nb_args--) printf( ",0x%04x", *stack++ );
 228         printf( ")\n" );
 229     }
 230 }
 231
 232
 233 /***********************************************************************
 234  *           RELAY_DebugCallFrom32
 235  *
 236  * 'stack' points to the saved ebp on the stack.
 237  * Stack layout:
 238  *  ...        ...
 239  * (stack+12)  arg2
 240  * (stack+8)   arg1
 241  * (stack+4)   ret addr
 242  * (stack)     ebp
 243  * (stack-4)   entry point
 244  * (stack-8)   relay addr
 245  */
 246 void RELAY_DebugCallFrom32( int *stack, int nb_args )
 247 {
 248     int *parg, i;
 249
 250     if (!debugging_relay) return;
 251     printf( "Call %s(", BUILTIN_GetEntryPoint32( (void *)stack[-2] ));
 252     for (i = nb_args & 0x7fffffff, parg = &stack[2]; i; parg++, i--)
 253     {
 254         printf( "%08x", *parg );
 255         if (i > 1) printf( "," );
 256     }
 257     printf( ") ret=%08x\n", stack[1] );
 258     if (nb_args & 0x80000000)  /* Register function */
 259     {
 260         CONTEXT *context = (CONTEXT *)((BYTE *)stack - sizeof(CONTEXT) - 8);
 261         printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
 262                 context->Eax, context->Ebx, context->Ecx, context->Edx,
 263                 context->Esi, context->Edi );
 264         printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
 265                 context->Ebp, context->Esp, context->Eip, context->SegDs,
 266                 context->SegEs, context->SegFs, context->SegGs,
 267                 context->EFlags );
 268     }
 269 }
 270
 271
 272 /***********************************************************************
 273  *           RELAY_DebugCallFrom32Ret
 274  *
 275  * 'stack' points to the saved ebp on the stack.
 276  * Stack layout:
 277  *  ...        ...
 278  * (stack+12)  arg2
 279  * (stack+8)   arg1
 280  * (stack+4)   ret addr
 281  * (stack)     ebp
 282  * (stack-4)   entry point
 283  * (stack-8)   relay addr
 284  */
 285 void RELAY_DebugCallFrom32Ret( int *stack, int nb_args, int ret_val )
 286 {
 287     if (!debugging_relay) return;
 288     printf( "Ret  %s() retval=%08x ret=%08x\n",
 289             BUILTIN_GetEntryPoint32( (void *)stack[-2] ), ret_val, stack[1] );
 290     if (nb_args & 0x80000000)  /* Register function */
 291     {
 292         CONTEXT *context = (CONTEXT *)((BYTE *)stack - sizeof(CONTEXT) - 8);
 293         printf( " EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx ESI=%08lx EDI=%08lx\n",
 294                 context->Eax, context->Ebx, context->Ecx, context->Edx,
 295                 context->Esi, context->Edi );
 296         printf( " EBP=%08lx ESP=%08lx EIP=%08lx DS=%04lx ES=%04lx FS=%04lx GS=%04lx EFL=%08lx\n",
 297                 context->Ebp, context->Esp, context->Eip, context->SegDs,
 298                 context->SegEs, context->SegFs, context->SegGs,
 299                 context->EFlags );
 300     }
 301 }
 302
 303
 304 /***********************************************************************
 305  *           RELAY_DebugCallTo32
 306  */
 307 void RELAY_DebugCallTo32( unsigned int func, int nbargs, unsigned int arg1  )
 308 {
 309     unsigned int *argptr;
 310
 311     if (!debugging_relay) return;
 312
 313     printf( "CallTo32(func=%08x", func );
 314     for (argptr = &arg1; nbargs; nbargs--, argptr++)
 315         printf( ",%08x", *argptr );
 316     printf( ")\n" );
 317 }
 318
 319
 320 /**********************************************************************
 321  *           Catch    (KERNEL.55)
 322  */
 323 INT16 Catch( LPCATCHBUF lpbuf )
 324 {
 325     STACK16FRAME *pFrame = CURRENT_STACK16;
 326
 327     /* Note: we don't save the current ss, as the catch buffer is */
 328     /* only 9 words long. Hopefully no one will have the silly    */
 329     /* idea to change the current stack before calling Throw()... */
 330
 331     /* Windows uses:
 332      * lpbuf[0] = ip
 333      * lpbuf[1] = cs
 334      * lpbuf[2] = sp
 335      * lpbuf[3] = bp
 336      * lpbuf[4] = si
 337      * lpbuf[5] = di
 338      * lpbuf[6] = ds
 339      * lpbuf[7] = unused
 340      * lpbuf[8] = ss
 341      */
 342     /* FIXME: we need to save %si and %di */
 343
 344     lpbuf[0] = IF1632_Saved16_sp;
 345     lpbuf[1] = LOWORD(IF1632_Saved32_esp);
 346     lpbuf[2] = HIWORD(IF1632_Saved32_esp);
 347     lpbuf[3] = pFrame->saved_ss;
 348     lpbuf[4] = pFrame->saved_sp;
 349     lpbuf[5] = pFrame->ds;
 350     lpbuf[6] = pFrame->bp;
 351     lpbuf[7] = pFrame->ip;
 352     lpbuf[8] = pFrame->cs;
 353     return 0;
 354 }
 355
 356
 357 /**********************************************************************
 358  *           Throw    (KERNEL.56)
 359  */
 360 INT16 Throw( LPCATCHBUF lpbuf, INT16 retval )
 361 {
 362     STACK16FRAME *pFrame;
 363     WORD es = CURRENT_STACK16->es;
 364
 365     IF1632_Saved16_sp  = lpbuf[0] - sizeof(WORD);
 366     IF1632_Saved32_esp = MAKELONG( lpbuf[1], lpbuf[2] );
 367     pFrame = CURRENT_STACK16;
 368     pFrame->saved_ss   = lpbuf[3];
 369     pFrame->saved_sp   = lpbuf[4];
 370     pFrame->ds         = lpbuf[5];
 371     pFrame->bp         = lpbuf[6];
 372     pFrame->ip         = lpbuf[7];
 373     pFrame->cs         = lpbuf[8];
 374     pFrame->es         = es;
 375     if (debugging_relay)  /* Make sure we have a valid entry point address */
 376     {
 377         static FARPROC16 entryPoint = NULL;
 378
 379         if (!entryPoint)  /* Get entry point for Throw() */
 380             entryPoint = MODULE_GetEntryPoint( GetModuleHandle16("KERNEL"),
 381                                                56 );
 382         pFrame->entry_cs = SELECTOROF(entryPoint);
 383         pFrame->entry_ip = OFFSETOF(entryPoint);
 384     }
 385     return retval;
 386 }
 387
 388 /**********************************************************************
 389  *           CallProc32W    (KERNEL.56)
 390  */
 391 DWORD
 392 WIN16_CallProc32W() {
 393         DWORD *win_stack = (DWORD *)CURRENT_STACK16->args;
 394         DWORD   nrofargs = win_stack[0];
 395         DWORD   argconvmask = win_stack[1];
 396         FARPROC32       proc32 = (FARPROC32)win_stack[2];
 397         DWORD   *args,ret;
 398         STACK16FRAME stf16;
 399         int     i;
 400
 401         fprintf(stderr,"CallProc32W(%ld,%ld,%p,args[",nrofargs,argconvmask,proc32);
 402         args = (DWORD*)xmalloc(sizeof(DWORD)*nrofargs);
 403         for (i=nrofargs;i--;) {
 404                 if (argconvmask & (1<<i)) {
 405                         args[nrofargs-i] = (DWORD)PTR_SEG_TO_LIN(win_stack[3+i]);
 406                         fprintf(stderr,"%08lx(%p),",win_stack[3+i],PTR_SEG_TO_LIN(win_stack[3+i]));
 407                 } else {
 408                         args[nrofargs-i] = win_stack[3+i];
 409                         fprintf(stderr,"%ld,",win_stack[3+i]);
 410                 }
 411         }
 412         fprintf(stderr,"]) - ");
 413         switch (nrofargs) {
 414         case 0: ret = CallTo32_0(proc32);
 415                 break;
 416         case 1: ret = CallTo32_1(proc32,args[0]);
 417                 break;
 418         case 2: ret = CallTo32_2(proc32,args[0],args[1]);
 419                 break;
 420         case 3: ret = CallTo32_3(proc32,args[0],args[1],args[2]);
 421                 break;
 422         case 4: ret = CallTo32_4(proc32,args[0],args[1],args[2],args[3]);
 423                 break;
 424         case 5: ret = CallTo32_5(proc32,args[0],args[1],args[2],args[3],args[4]);
 425                 break;
 426         default:
 427                 /* FIXME: should go up to 32  arguments */
 428                 fprintf(stderr,"CallProc32W: unsupported number of arguments %ld, please report.\n",nrofargs);
 429                 ret = 0;
 430                 break;
 431         }
 432         /* POP nrofargs DWORD arguments and 3 DWORD parameters */
 433         /* FIXME: this is a BAD hack, but I don't see any other way to
 434          * pop a variable number of arguments.  -MM
 435          * The -2 in the size is for not copying WORD args[0] (which would
 436          * overwrite the top WORD on the return stack)
 437          */
 438         memcpy(&stf16,CURRENT_STACK16,sizeof(stf16)-2);
 439         IF1632_Saved16_sp += (3+nrofargs)*sizeof(DWORD);
 440         memcpy(CURRENT_STACK16,&stf16,sizeof(stf16)-2);
 441
 442         fprintf(stderr,"returns %08lx\n",ret);
 443         free(args);
 444         return ret;
 445 }