Report non-hercules video. Turned on int 2a.
[wine] / if1632 / relay.c
1 /*
2  * Copyright 1993 Robert J. Amstadt
3  * Copyright 1995 Alexandre Julliard
4  */
5
6 #include <assert.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include "wine/winbase16.h"
10 #include "winnt.h"
11 #include "global.h"
12 #include "heap.h"
13 #include "module.h"
14 #include "stackframe.h"
15 #include "builtin16.h"
16 #include "task.h"
17 #include "syslevel.h"
18 #include "debugstr.h"
19 #include "debugtools.h"
20 #include "main.h"
21
22 DEFAULT_DEBUG_CHANNEL(relay)
23
24
25 /***********************************************************************
26  *           RELAY_Init
27  */
28 BOOL RELAY_Init(void)
29 {
30     WORD codesel;
31
32       /* Allocate the code selector for CallTo16 routines */
33
34     extern void Call16_Ret_Start(), Call16_Ret_End();
35     extern void CallTo16_Ret();
36     extern void CALL32_CBClient_Ret();
37     extern void CALL32_CBClientEx_Ret();
38     extern DWORD CallTo16_RetAddr;
39     extern DWORD CALL32_CBClient_RetAddr;
40     extern DWORD CALL32_CBClientEx_RetAddr;
41
42     codesel = GLOBAL_CreateBlock( GMEM_FIXED, (void *)Call16_Ret_Start,
43                                   (int)Call16_Ret_End - (int)Call16_Ret_Start,
44                                   GetModuleHandle16( "KERNEL" ), 
45                                   TRUE, TRUE, FALSE, NULL );
46     if (!codesel) return FALSE;
47
48       /* Patch the return addresses for CallTo16 routines */
49
50     CallTo16_RetAddr = 
51         MAKELONG( (int)CallTo16_Ret -(int)Call16_Ret_Start, codesel );
52     CALL32_CBClient_RetAddr = 
53         MAKELONG( (int)CALL32_CBClient_Ret -(int)Call16_Ret_Start, codesel );
54     CALL32_CBClientEx_RetAddr = 
55         MAKELONG( (int)CALL32_CBClientEx_Ret -(int)Call16_Ret_Start, codesel );
56
57     /* Create built-in modules */
58     if (!BUILTIN_Init()) return FALSE;
59
60     /* Initialize thunking */
61     return THUNK_Init();
62 }
63
64
65 /* from relay32/relay386.c */
66 extern char **debug_relay_excludelist,**debug_relay_includelist;
67
68 /***********************************************************************
69  *           RELAY_DebugCallFrom16
70  */
71 void RELAY_DebugCallFrom16( CONTEXT86 *context )
72 {
73     STACK16FRAME *frame;
74     WORD ordinal;
75     char *args16, funstr[80];
76     const char *args;
77     int i, usecdecl, reg_func;
78
79     if (!TRACE_ON(relay)) return;
80
81     frame = CURRENT_STACK16;
82     args = BUILTIN_GetEntryPoint16( frame, funstr, &ordinal );
83     if (!args) return; /* happens for the two snoop register relays */
84     if (!RELAY_ShowDebugmsgRelay(funstr)) return;
85     DPRINTF( "Call %s(",funstr);
86     VA_START16( args16 );
87
88     usecdecl = ( *args == 'c' );
89     args += 2;
90     reg_func = (    memcmp( args, "regs_", 5 ) == 0
91                  || memcmp( args, "intr_", 5 ) == 0 );
92     args += 5;
93
94     if (usecdecl)
95     {
96         while (*args)
97         {
98             switch(*args)
99             {
100             case 'w':
101             case 's':
102                 DPRINTF( "0x%04x", *(WORD *)args16 );
103                 args16 += 2;
104                 break;
105             case 'l':
106                 DPRINTF( "0x%08x", *(int *)args16 );
107                 args16 += 4;
108                 break;
109             case 't':
110                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
111                 if (HIWORD(*(SEGPTR *)args16))
112                     debug_dumpstr( (LPSTR)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
113                 args16 += 4;
114                 break;
115             case 'p':
116                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
117                 args16 += 4;
118                 break;
119             case 'T':
120                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
121                 if (HIWORD( *(SEGPTR *)args16 ))
122                     debug_dumpstr( (LPSTR)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
123                 args16 += 4;
124                 break;
125             }
126             args++;
127             if (*args) DPRINTF( "," );
128         }
129     }
130     else  /* not cdecl */
131     {
132         /* Start with the last arg */
133         for (i = 0; args[i]; i++)
134         {
135             switch(args[i])
136             {
137             case 'w':
138             case 's':
139                 args16 += 2;
140                 break;
141             case 'l':
142             case 'p':
143             case 't':
144             case 'T':
145                 args16 += 4;
146                 break;
147             }
148         }
149
150         while (*args)
151         {
152             switch(*args)
153             {
154             case 'w':
155             case 's':
156                 args16 -= 2;
157                 DPRINTF( "0x%04x", *(WORD *)args16 );
158                 break;
159             case 'l':
160                 args16 -= 4;
161                 DPRINTF( "0x%08x", *(int *)args16 );
162                 break;
163             case 't':
164                 args16 -= 4;
165                 DPRINTF( "0x%08x", *(int *)args16 );
166                 if (HIWORD(*(SEGPTR *)args16))
167                     debug_dumpstr( (LPSTR)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
168                 break;
169             case 'p':
170                 args16 -= 4;
171                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
172                 break;
173             case 'T':
174                 args16 -= 4;
175                 DPRINTF( "%04x:%04x", *(WORD *)(args16+2), *(WORD *)args16 );
176                 if (HIWORD( *(SEGPTR *)args16 ))
177                     debug_dumpstr( (LPSTR)PTR_SEG_TO_LIN(*(SEGPTR *)args16 ));
178                 break;
179             }
180             args++;
181             if (*args) DPRINTF( "," );
182         }
183     }
184
185     DPRINTF( ") ret=%04x:%04x ds=%04x\n", frame->cs, frame->ip, frame->ds );
186     VA_END16( args16 );
187
188     if (reg_func)
189         DPRINTF("     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
190                 AX_reg(context), BX_reg(context), CX_reg(context),
191                 DX_reg(context), SI_reg(context), DI_reg(context),
192                 (WORD)ES_reg(context), EFL_reg(context) );
193
194     SYSLEVEL_CheckNotLevel( 2 );
195 }
196
197
198 /***********************************************************************
199  *           RELAY_DebugCallFrom16Ret
200  */
201 void RELAY_DebugCallFrom16Ret( CONTEXT86 *context, int ret_val )
202 {
203     STACK16FRAME *frame;
204     WORD ordinal;
205     char funstr[80];
206     const char *args;
207
208     if (!TRACE_ON(relay)) return;
209     frame = CURRENT_STACK16;
210     args = BUILTIN_GetEntryPoint16( frame, funstr, &ordinal );
211     if (!args) return;
212     if (!RELAY_ShowDebugmsgRelay(funstr)) return;
213     DPRINTF( "Ret  %s() ",funstr);
214
215     if ( memcmp( args+2, "long_", 5 ) == 0 )
216     {
217         DPRINTF( "retval=0x%08x ret=%04x:%04x ds=%04x\n",
218                  ret_val, frame->cs, frame->ip, frame->ds );
219     }
220     else if ( memcmp( args+2, "word_", 5 ) == 0 )
221     {
222         DPRINTF( "retval=0x%04x ret=%04x:%04x ds=%04x\n",
223                  ret_val & 0xffff, frame->cs, frame->ip, frame->ds );
224     }
225     else if (    memcmp( args+2, "regs_", 5 ) == 0 
226               || memcmp( args+2, "intr_", 5 ) == 0 )
227     {
228         DPRINTF("retval=none ret=%04x:%04x ds=%04x\n",
229                 (WORD)CS_reg(context), LOWORD(EIP_reg(context)), (WORD)DS_reg(context));
230         DPRINTF("     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x ES=%04x EFL=%08lx\n",
231                 AX_reg(context), BX_reg(context), CX_reg(context),
232                 DX_reg(context), SI_reg(context), DI_reg(context),
233                 (WORD)ES_reg(context), EFL_reg(context) );
234     }
235
236     SYSLEVEL_CheckNotLevel( 2 );
237 }
238
239
240 /***********************************************************************
241  *           RELAY_Unimplemented16
242  *
243  * This function is called for unimplemented 16-bit entry points (declared
244  * as 'stub' in the spec file).
245  */
246 void RELAY_Unimplemented16(void)
247 {
248     WORD ordinal;
249     char name[80];
250     STACK16FRAME *frame = CURRENT_STACK16;
251     BUILTIN_GetEntryPoint16( frame, name, &ordinal );
252     MESSAGE("No handler for Win16 routine %s (called from %04x:%04x)\n",
253             name, frame->cs, frame->ip );
254     ExitProcess(1);
255 }
256
257
258 /***********************************************************************
259  *           RELAY_DebugCallTo16
260  *
261  * 'target' contains either the function to call (normal CallTo16)
262  * or a pointer to the CONTEXT86 struct (register CallTo16).
263  * 'nb_args' is the number of argument bytes on the 16-bit stack; 
264  * 'reg_func' specifies whether we have a register CallTo16 or not.
265  */
266 void RELAY_DebugCallTo16( LPVOID target, int nb_args, BOOL reg_func )
267 {
268     WORD *stack16;
269     TEB *teb;
270
271     if (!TRACE_ON(relay)) return;
272     teb = NtCurrentTeb();
273     stack16 = (WORD *)THREAD_STACK16(teb);
274
275     nb_args /= sizeof(WORD);
276
277     if ( reg_func )
278     {
279         CONTEXT86 *context = (CONTEXT86 *)target;
280
281         DPRINTF("CallTo16(func=%04lx:%04x,ds=%04lx",
282                 CS_reg(context), LOWORD(EIP_reg(context)), DS_reg(context) );
283         while (nb_args--) DPRINTF( ",0x%04x", *--stack16 );
284         DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(teb->cur_stack),
285                 OFFSETOF(teb->cur_stack) );
286         DPRINTF("     AX=%04x BX=%04x CX=%04x DX=%04x SI=%04x DI=%04x BP=%04x ES=%04x FS=%04x\n",
287                 AX_reg(context), BX_reg(context), CX_reg(context),
288                 DX_reg(context), SI_reg(context), DI_reg(context),
289                 BP_reg(context), (WORD)ES_reg(context), (WORD)FS_reg(context) );
290     }
291     else
292     {
293         DPRINTF("CallTo16(func=%04x:%04x,ds=%04x",
294                 HIWORD(target), LOWORD(target), SELECTOROF(teb->cur_stack) );
295         while (nb_args--) DPRINTF( ",0x%04x", *--stack16 );
296         DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(teb->cur_stack),
297                 OFFSETOF(teb->cur_stack) );
298     }
299
300     SYSLEVEL_CheckNotLevel( 2 );
301 }
302
303
304 /***********************************************************************
305  *           RELAY_DebugCallTo16Ret
306  */
307 void RELAY_DebugCallTo16Ret( int ret_val )
308 {
309     if (!TRACE_ON(relay)) return;
310
311     DPRINTF("CallTo16() ss:sp=%04x:%04x retval=0x%08x\n", 
312             SELECTOROF(NtCurrentTeb()->cur_stack),
313             OFFSETOF(NtCurrentTeb()->cur_stack), ret_val);
314     SYSLEVEL_CheckNotLevel( 2 );
315 }
316
317
318 /**********************************************************************
319  *           Catch    (KERNEL.55)
320  *
321  * Real prototype is:
322  *   INT16 WINAPI Catch( LPCATCHBUF lpbuf );
323  */
324 void WINAPI Catch16( LPCATCHBUF lpbuf, CONTEXT86 *context )
325 {
326     /* Note: we don't save the current ss, as the catch buffer is */
327     /* only 9 words long. Hopefully no one will have the silly    */
328     /* idea to change the current stack before calling Throw()... */
329
330     /* Windows uses:
331      * lpbuf[0] = ip
332      * lpbuf[1] = cs
333      * lpbuf[2] = sp
334      * lpbuf[3] = bp
335      * lpbuf[4] = si
336      * lpbuf[5] = di
337      * lpbuf[6] = ds
338      * lpbuf[7] = unused
339      * lpbuf[8] = ss
340      */
341
342     lpbuf[0] = LOWORD(EIP_reg(context));
343     lpbuf[1] = CS_reg(context);
344     /* Windows pushes 4 more words before saving sp */
345     lpbuf[2] = LOWORD(ESP_reg(context)) - 4 * sizeof(WORD);
346     lpbuf[3] = LOWORD(EBP_reg(context));
347     lpbuf[4] = LOWORD(ESI_reg(context));
348     lpbuf[5] = LOWORD(EDI_reg(context));
349     lpbuf[6] = DS_reg(context);
350     lpbuf[7] = 0;
351     lpbuf[8] = SS_reg(context);
352     AX_reg(context) = 0;  /* Return 0 */
353 }
354
355
356 /**********************************************************************
357  *           Throw    (KERNEL.56)
358  *
359  * Real prototype is:
360  *   INT16 WINAPI Throw( LPCATCHBUF lpbuf, INT16 retval );
361  */
362 void WINAPI Throw16( LPCATCHBUF lpbuf, INT16 retval, CONTEXT86 *context )
363 {
364     STACK16FRAME *pFrame;
365     STACK32FRAME *frame32;
366     TEB *teb = NtCurrentTeb();
367
368     AX_reg(context) = retval;
369
370     /* Find the frame32 corresponding to the frame16 we are jumping to */
371     pFrame = THREAD_STACK16(teb);
372     frame32 = pFrame->frame32;
373     while (frame32 && frame32->frame16)
374     {
375         if (OFFSETOF(frame32->frame16) < OFFSETOF(teb->cur_stack))
376             break;  /* Something strange is going on */
377         if (OFFSETOF(frame32->frame16) > lpbuf[2])
378         {
379             /* We found the right frame */
380             pFrame->frame32 = frame32;
381             break;
382         }
383         frame32 = ((STACK16FRAME *)PTR_SEG_TO_LIN(frame32->frame16))->frame32;
384     }
385
386     EIP_reg(context) = lpbuf[0];
387     CS_reg(context)  = lpbuf[1];
388     ESP_reg(context) = lpbuf[2] + 4 * sizeof(WORD) - sizeof(WORD) /*extra arg*/;
389     EBP_reg(context) = lpbuf[3];
390     ESI_reg(context) = lpbuf[4];
391     EDI_reg(context) = lpbuf[5];
392     DS_reg(context)  = lpbuf[6];
393
394     if (lpbuf[8] != SS_reg(context))
395         ERR("Switching stack segment with Throw() not supported; expect crash now\n" );
396 }
397