if1632/relay.c

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