if1632/relay.c

   1 /*
   2  * Copyright 1993 Robert J. Amstadt
   3  * Copyright 1995 Alexandre Julliard
   4  */
   5
   6 #include <assert.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include "windows.h"
  10 #include "winnt.h"
  11 #include "global.h"
  12 #include "heap.h"
  13 #include "module.h"
  14 #include "stackframe.h"
  15 #include "task.h"
  16 #include "debug.h"
  17
  18 #if 0
  19 /* Make make_debug think these were really used */
  20 TRACE(relay, "test - dummy");
  21 #endif
  22
  23
  24 /***********************************************************************
  25  *           RELAY_Init
  26  */
  27 BOOL32 RELAY_Init(void)
  28 {
  29     WORD codesel;
  30     extern BOOL32 THUNK_Init(void);
  31
  32       /* Allocate the code selector for CallTo16 routines */
  33
  34     extern void CALLTO16_Start(), CALLTO16_End();
  35     extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
  36     extern DWORD CALLTO16_RetAddr_word;
  37     extern DWORD 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     /* Create built-in modules */
  52     if (!BUILTIN_Init()) return FALSE;
  53
  54     /* Initialize thunking */
  55     return THUNK_Init();
  56 }
  57
  58
  59
  60 static void RELAY_dumpstr( unsigned char *s )
  61 {
  62     fputc( '\"', stdout );
  63     for ( ; *s; s++)
  64     {
  65         if (*s < ' ') printf( "\\0x%02x", *s );
  66         else if (*s == '\\') fputs( "\\\\", stdout );
  67         else fputc( *s, stdout );
  68     }
  69     fputc( '\"', stdout );
  70 }
  71
  72
  73 /***********************************************************************
  74  *           RELAY_DebugCallFrom16
  75  */
  76 void RELAY_DebugCallFrom16( int func_type, char *args,
  77                             void *entry_point, CONTEXT *context )
  78 {
  79     STACK16FRAME *frame;
  80     WORD ordinal;
  81     char *args16;
  82     int i;
  83
  84     if (!TRACE_ON(relay)) return;
  85
  86     frame = CURRENT_STACK16;
  87     printf( "Call %s(", BUILTIN_GetEntryPoint16( frame->entry_cs,
  88                                                  frame->entry_ip,
  89                                                  &ordinal ));
  90     VA_START16( args16 );
  91
  92     if (func_type & 4)  /* cdecl */
  93     {
  94         while (*args)
  95         {
  96             switch(*args)
  97             {
  98             case 'w':
  99             case 's':
 100                 printf( "0x%04x", *(WORD *)args16 );
 101                 args16 += 2;
 102                 break;
 103             case 'l':
 104                 printf( "0x%08x", *(int *)args16 );
 105                 args16 += 4;
 106                 break;
 107             case 't':
 108                 printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 109                 if (HIWORD(*(SEGPTR *)args16))
 110                     RELAY_dumpstr( (LPBYTE)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
 111                 args16 += 4;
 112                 break;
 113             case 'p':
 114                 printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 115                 args16 += 4;
 116                 break;
 117             case 'T':
 118                 printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 119                 if (HIWORD( *(SEGPTR *)args16 ))
 120                     RELAY_dumpstr( (LPBYTE)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
 121                 args16 += 4;
 122                 break;
 123             }
 124             args++;
 125             if (*args) printf( "," );
 126         }
 127     }
 128     else  /* not cdecl */
 129     {
 130         /* Start with the last arg */
 131         for (i = 0; args[i]; i++)
 132         {
 133             switch(args[i])
 134             {
 135             case 'w':
 136             case 's':
 137                 args16 += 2;
 138                 break;
 139             case 'l':
 140             case 'p':
 141             case 't':
 142             case 'T':
 143                 args16 += 4;
 144                 break;
 145             }
 146         }
 147
 148         while (*args)
 149         {
 150             switch(*args)
 151             {
 152             case 'w':
 153             case 's':
 154                 args16 -= 2;
 155                 printf( "0x%04x", *(WORD *)args16 );
 156                 break;
 157             case 'l':
 158                 args16 -= 4;
 159                 printf( "0x%08x", *(int *)args16 );
 160                 break;
 161             case 't':
 162                 args16 -= 4;
 163                 printf( "0x%08x", *(int *)args16 );
 164                 if (HIWORD(*(SEGPTR *)args16))
 165                     RELAY_dumpstr( (LPBYTE)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
 166                 break;
 167             case 'p':
 168                 args16 -= 4;
 169                 printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 170                 break;
 171             case 'T':
 172                 args16 -= 4;
 173                 printf( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
 174                 if (HIWORD( *(SEGPTR *)args16 ))
 175                     RELAY_dumpstr( (LPBYTE)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
 176                 break;
 177             }
 178             args++;
 179             if (*args) printf( "," );
 180         }
 181     }
 182
 183     printf( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
 184     VA_END16( args16 );
 185
 186     if (func_type & 2)  /* register function */
 187         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 188                 AX_reg(context), BX_reg(context), CX_reg(context),
 189                 DX_reg(context), SI_reg(context), DI_reg(context),
 190                 (WORD)ES_reg(context), EFL_reg(context) );
 191 }
 192
 193
 194 /***********************************************************************
 195  *           RELAY_DebugCallFrom16Ret
 196  */
 197 void RELAY_DebugCallFrom16Ret( int func_type, int ret_val, CONTEXT *context)
 198 {
 199     STACK16FRAME *frame;
 200     WORD ordinal;
 201
 202     if (!TRACE_ON(relay)) return;
 203     frame = CURRENT_STACK16;
 204     printf( "Ret  %s() ", BUILTIN_GetEntryPoint16( frame->entry_cs,
 205                                                    frame->entry_ip,
 206                                                    &ordinal ));
 207     switch(func_type)
 208     {
 209     case 0: /* long */
 210         printf( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
 211                 ret_val, frame->cs, frame->ip, frame->ds );
 212         break;
 213     case 1: /* word */
 214         printf( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
 215                 ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
 216         break;
 217     case 2: /* regs */
 218         printf( "retval=none ret=%04x:%04x ds=%04x\n",
 219                 (WORD)CS_reg(context), IP_reg(context), (WORD)DS_reg(context));
 220         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
 221                 AX_reg(context), BX_reg(context), CX_reg(context),
 222                 DX_reg(context), SI_reg(context), DI_reg(context),
 223                 (WORD)ES_reg(context), EFL_reg(context) );
 224         break;
 225     }
 226 }
 227
 228
 229 /***********************************************************************
 230  *           RELAY_Unimplemented16
 231  *
 232  * This function is called for unimplemented 16-bit entry points (declared
 233  * as 'stub' in the spec file).
 234  */
 235 void RELAY_Unimplemented16(void)
 236 {
 237     WORD ordinal;
 238     STACK16FRAME *frame = CURRENT_STACK16;
 239     fprintf(stderr,"No handler for Win16 routine %s (called from %04x:%04x)\n",
 240             BUILTIN_GetEntryPoint16(frame->entry_cs,frame->entry_ip,&ordinal),
 241             frame->cs, frame->ip );
 242     TASK_KillCurrentTask(1);
 243 }
 244
 245
 246 /***********************************************************************
 247  *           RELAY_DebugCallTo16
 248  *
 249  * 'stack' points to the called function address on the 32-bit stack.
 250  * Stack layout:
 251  *  ...        ...
 252  * (stack+8)   arg2
 253  * (stack+4)   arg1
 254  * (stack)     func to call
 255  */
 256 void RELAY_DebugCallTo16( int* stack, int nb_args )
 257 {
 258     THDB *thdb;
 259
 260     if (!TRACE_ON(relay)) return;
 261     thdb = THREAD_Current();
 262
 263     if (nb_args == -1)  /* Register function */
 264     {
 265         CONTEXT *context = (CONTEXT *)stack[0];
 266         WORD *stack16 = (WORD *)THREAD_STACK16(thdb);
 267         printf( "CallTo16(func=%04lx:%04x,ds=%04lx",
 268                 CS_reg(context), IP_reg(context), DS_reg(context) );
 269         nb_args = stack[1] / sizeof(WORD);
 270         while (nb_args--) printf( ",0x%04x", *(--stack16) );
 271         printf( ") ss:sp=%04x:%04x\n", SELECTOROF(thdb->cur_stack),
 272                 OFFSETOF(thdb->cur_stack) );
 273         printf( "     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x\n",
 274                 AX_reg(context), BX_reg(context), CX_reg(context),
 275                 DX_reg(context), SI_reg(context), DI_reg(context),
 276                 BP_reg(context), (WORD)ES_reg(context) );
 277     }
 278     else
 279     {
 280         printf( "CallTo16(func=%04x:%04x,ds=%04x",
 281                 HIWORD(stack[0]), LOWORD(stack[0]),
 282                 SELECTOROF(thdb->cur_stack) );
 283         stack++;
 284         while (nb_args--) printf( ",0x%04x", *stack++ );
 285         printf( ") ss:sp=%04x:%04x\n", SELECTOROF(thdb->cur_stack),
 286                 OFFSETOF(thdb->cur_stack) );
 287     }
 288 }
 289
 290
 291 /**********************************************************************
 292  *           Catch    (KERNEL.55)
 293  *
 294  * Real prototype is:
 295  *   INT16 WINAPI Catch( LPCATCHBUF lpbuf );
 296  */
 297 void WINAPI Catch( CONTEXT *context )
 298 {
 299     VA_LIST16 valist;
 300     SEGPTR buf;
 301     LPCATCHBUF lpbuf;
 302
 303     VA_START16( valist );
 304     buf   = VA_ARG16( valist, SEGPTR );
 305     lpbuf = (LPCATCHBUF)PTR_SEG_TO_LIN( buf );
 306     VA_END16( valist );
 307
 308     /* Note: we don't save the current ss, as the catch buffer is */
 309     /* only 9 words long. Hopefully no one will have the silly    */
 310     /* idea to change the current stack before calling Throw()... */
 311
 312     /* Windows uses:
 313      * lpbuf[0] = ip
 314      * lpbuf[1] = cs
 315      * lpbuf[2] = sp
 316      * lpbuf[3] = bp
 317      * lpbuf[4] = si
 318      * lpbuf[5] = di
 319      * lpbuf[6] = ds
 320      * lpbuf[7] = unused
 321      * lpbuf[8] = ss
 322      */
 323
 324     lpbuf[0] = IP_reg(context);
 325     lpbuf[1] = CS_reg(context);
 326     /* Windows pushes 4 more words before saving sp */
 327     lpbuf[2] = SP_reg(context) - 4 * sizeof(WORD);
 328     lpbuf[3] = BP_reg(context);
 329     lpbuf[4] = SI_reg(context);
 330     lpbuf[5] = DI_reg(context);
 331     lpbuf[6] = DS_reg(context);
 332     lpbuf[7] = 0;
 333     lpbuf[8] = SS_reg(context);
 334     AX_reg(context) = 0;  /* Return 0 */
 335 }
 336
 337
 338 /**********************************************************************
 339  *           Throw    (KERNEL.56)
 340  *
 341  * Real prototype is:
 342  *   INT16 WINAPI Throw( LPCATCHBUF lpbuf, INT16 retval );
 343  */
 344 void WINAPI Throw( CONTEXT *context )
 345 {
 346     VA_LIST16 valist;
 347     SEGPTR buf;
 348     LPCATCHBUF lpbuf;
 349     STACK16FRAME *pFrame;
 350     STACK32FRAME *frame32;
 351     THDB *thdb = THREAD_Current();
 352
 353     VA_START16( valist );
 354     AX_reg(context) = VA_ARG16( valist, WORD );  /* retval */
 355     buf    = VA_ARG16( valist, SEGPTR );
 356     lpbuf  = (LPCATCHBUF)PTR_SEG_TO_LIN( buf );
 357     VA_END16( valist );
 358
 359     /* Find the frame32 corresponding to the frame16 we are jumping to */
 360     pFrame = THREAD_STACK16( thdb );
 361     frame32 = THREAD_STACK16( thdb )->frame32;
 362     while (frame32 && frame32->frame16)
 363     {
 364         if (OFFSETOF(frame32->frame16) < OFFSETOF(thdb->cur_stack))
 365             break;  /* Something strange is going on */
 366         if (OFFSETOF(frame32->frame16) > lpbuf[2])
 367         {
 368             /* We found the right frame */
 369             pFrame->frame32 = frame32;
 370             break;
 371         }
 372         frame32 = ((STACK16FRAME *)PTR_SEG_TO_LIN(frame32->frame16))->frame32;
 373     }
 374
 375     IP_reg(context) = lpbuf[0];
 376     CS_reg(context) = lpbuf[1];
 377     SP_reg(context) = lpbuf[2] + 4 * sizeof(WORD) + sizeof(WORD) /*extra arg*/;
 378     BP_reg(context) = lpbuf[3];
 379     SI_reg(context) = lpbuf[4];
 380     DI_reg(context) = lpbuf[5];
 381     DS_reg(context) = lpbuf[6];
 382
 383     if (lpbuf[8] != SS_reg(context))
 384         fprintf( stderr, "Switching stack segment with Throw() not supported; expect crash now\n" );
 385
 386     if (TRACE_ON(relay))  /* Make sure we have a valid entry point address */
 387     {
 388         static FARPROC16 entryPoint = NULL;
 389
 390         if (!entryPoint)  /* Get entry point for Throw() */
 391             entryPoint = MODULE_GetEntryPoint( GetModuleHandle16("KERNEL"),
 392                                                56 );
 393         pFrame->entry_cs = SELECTOROF(entryPoint);
 394         pFrame->entry_ip = OFFSETOF(entryPoint);
 395     }
 396 }
 397
 398
 399 /**********************************************************************
 400  *           RELAY_CallProc32W
 401  *
 402  * Helper for CallProc[Ex]32W
 403  */
 404 static DWORD RELAY_CallProc32W(int Ex)
 405 {
 406         DWORD nrofargs, argconvmask;
 407         FARPROC32 proc32;
 408         DWORD *args, ret;
 409         VA_LIST16 valist;
 410         int i;
 411         dbg_decl_str(relay, 1024);
 412
 413         VA_START16( valist );
 414         nrofargs    = VA_ARG16( valist, DWORD );
 415         argconvmask = VA_ARG16( valist, DWORD );
 416         proc32      = VA_ARG16( valist, FARPROC32 );
 417         dsprintf(relay, "CallProc32W(%ld,%ld,%p, Ex%d args[",nrofargs,argconvmask,proc32,Ex);
 418         args = (DWORD*)HEAP_xalloc( GetProcessHeap(), 0,
 419                                     sizeof(DWORD)*nrofargs );
 420         for (i=0;i<nrofargs;i++) {
 421                 if (argconvmask & (1<<i))
 422                 {
 423                     SEGPTR ptr = VA_ARG16( valist, SEGPTR );
 424                     args[nrofargs-i-1] = (DWORD)PTR_SEG_TO_LIN(ptr);
 425                     dsprintf(relay,"%08lx(%p),",ptr,PTR_SEG_TO_LIN(ptr));
 426                 }
 427                 else
 428                 {
 429                     args[nrofargs-i-1] = VA_ARG16( valist, DWORD );
 430                     dsprintf(relay,"%ld,",args[nrofargs-i-1]);
 431                 }
 432         }
 433         dsprintf(relay,"])");
 434         VA_END16( valist );
 435
 436         switch (nrofargs) {
 437         case 0: ret = proc32();
 438                 break;
 439         case 1: ret = proc32(args[0]);
 440                 break;
 441         case 2: ret = proc32(args[0],args[1]);
 442                 break;
 443         case 3: ret = proc32(args[0],args[1],args[2]);
 444                 break;
 445         case 4: ret = proc32(args[0],args[1],args[2],args[3]);
 446                 break;
 447         case 5: ret = proc32(args[0],args[1],args[2],args[3],args[4]);
 448                 break;
 449         case 6: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5]);
 450                 break;
 451         case 7: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
 452                 break;
 453         case 8: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
 454                 break;
 455         case 9: ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
 456                 break;
 457         case 10:        ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
 458                 break;
 459         case 11:        ret = proc32(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
 460                 break;
 461         default:
 462                 /* FIXME: should go up to 32  arguments */
 463                 fprintf(stderr,"CallProc32W: unsupported number of arguments %ld, please report.\n",nrofargs);
 464                 ret = 0;
 465                 break;
 466         }
 467         /* POP nrofargs DWORD arguments and 3 DWORD parameters */
 468         if (!Ex) STACK16_POP( THREAD_Current(),
 469                               (3 + nrofargs) * sizeof(DWORD) );
 470
 471         TRACE(relay,"%s - returns %08lx\n",dbg_str(relay),ret);
 472         HeapFree( GetProcessHeap(), 0, args );
 473         return ret;
 474 }
 475
 476
 477 /**********************************************************************
 478  *           CallProc32W    (KERNEL.517)
 479  */
 480 DWORD WINAPI WIN16_CallProc32W()
 481 {
 482         return RELAY_CallProc32W(0);
 483 }
 484
 485
 486 /**********************************************************************
 487 *           CallProcEx32W()   (KERNEL.518)
 488 *
 489 *      C - style linkage to CallProc32W - caller pops stack.
 490 */
 491 DWORD WINAPI WIN16_CallProcEx32W()
 492 {
 493         return RELAY_CallProc32W(TRUE);
 494 }