wined3d: Explicitly pass the register type and index to pshader_get_register_name().
[wine] / dlls / winedos / himem.c
1 /*
2  * DOS upper memory management.
3  *
4  * Copyright 2002 Jukka Heinonen
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "dosexe.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(dosmem);
25
26 /*
27  * Wine DOS memory layout above 640k:
28  *
29  *   a0000 - affff : VGA graphics         (vga.c)
30  *   b0000 - bffff : Monochrome text      (unused)
31  *   b8000 - bffff : VGA text             (vga.c)
32  *   c0000 - cffff : EMS frame            (int67.c)
33  *   d0000 - effff : Free memory for UMBs (himem.c)
34  *   f0000 - fffff : BIOS stuff           (msdos/dosmem.c)
35  *  100000 -10ffff : High memory area     (unused)
36  */
37
38 /*
39  * Table of real mode segments and protected mode selectors 
40  * for code stubs and other miscellaneous storage.
41  */
42 struct DPMI_segments *DOSVM_dpmi_segments = NULL;
43
44 /*
45  * First and last address available for upper memory blocks.
46  */
47 #define DOSVM_UMB_BOTTOM 0xd0000
48 #define DOSVM_UMB_TOP    0xeffff
49
50 /*
51  * First free address for upper memory blocks.
52  */
53 static DWORD DOSVM_umb_free = DOSVM_UMB_BOTTOM;
54
55
56 /***********************************************************************
57  *           DOSVM_AllocUMB
58  *
59  * Allocate upper memory block (UMB) from upper memory.
60  * Returned pointer is aligned to 16-byte (paragraph) boundary.
61  *
62  * This routine is only for allocating static storage for 
63  * Wine internal uses. Allocated memory can be accessed from
64  * real mode, memory is taken from area already mapped and reserved
65  * by Wine and the allocation has very little memory and speed
66  * overhead. Use of this routine also preserves precious DOS
67  * conventional memory.
68  */
69 static LPVOID DOSVM_AllocUMB( DWORD size )
70 {
71   LPVOID ptr = (LPVOID)DOSVM_umb_free;
72   
73   size = ((size + 15) >> 4) << 4;
74   
75   if(DOSVM_umb_free + size - 1 > DOSVM_UMB_TOP) {
76     ERR("Out of upper memory area.\n");
77     return 0;
78   }
79
80   DOSVM_umb_free += size;
81   return ptr;
82 }
83
84
85 /**********************************************************************
86  *          alloc_selector
87  *
88  * Allocate a selector corresponding to a real mode address.
89  * size must be < 64k.
90  */
91 static WORD alloc_selector( void *base, DWORD size, unsigned char flags )
92 {
93     WORD sel = wine_ldt_alloc_entries( 1 );
94
95     if (sel)
96     {
97         LDT_ENTRY entry;
98         wine_ldt_set_base( &entry, base );
99         wine_ldt_set_limit( &entry, size - 1 );
100         wine_ldt_set_flags( &entry, flags );
101         wine_ldt_set_entry( sel, &entry );
102     }
103     return sel;
104 }
105
106
107 /***********************************************************************
108  *           DOSVM_AllocCodeUMB
109  *
110  * Allocate upper memory block for storing code stubs.
111  * Initializes real mode segment and 16-bit protected mode selector 
112  * for the allocated code block.
113  *
114  * FIXME: should allocate a single PM selector for the whole UMB range.
115  */
116 static LPVOID DOSVM_AllocCodeUMB( DWORD size, WORD *segment, WORD *selector )
117 {
118   LPVOID ptr = DOSVM_AllocUMB( size );
119   
120   if (segment)
121     *segment = (DWORD)ptr >> 4;
122
123   if (selector)
124     *selector = alloc_selector( ptr, size, WINE_LDT_FLAGS_CODE );
125
126   return ptr;
127 }
128
129
130 /***********************************************************************
131  *           DOSVM_AllocDataUMB
132  *
133  * Allocate upper memory block for storing data.
134  * Initializes real mode segment and 16-bit protected mode selector 
135  * for the allocated data block.
136  */
137 LPVOID DOSVM_AllocDataUMB( DWORD size, WORD *segment, WORD *selector )
138 {
139   LPVOID ptr = DOSVM_AllocUMB( size );
140   
141   if (segment)
142     *segment = (DWORD)ptr >> 4;
143
144   if (selector)
145     *selector = alloc_selector( ptr, size, WINE_LDT_FLAGS_DATA );
146
147   return ptr;
148 }
149
150
151 /***********************************************************************
152  *           DOSVM_InitSegments
153  *
154  * Initializes DOSVM_dpmi_segments. Allocates required memory and
155  * sets up segments and selectors for accessing the memory.
156  */
157 void DOSVM_InitSegments( void )
158 {
159     LPSTR ptr;
160     int   i;
161
162     static const char wrap_code[]={
163      0xCD,0x31, /* int $0x31 */
164      0xCB       /* lret */
165     };
166
167     static const char enter_xms[]=
168     {
169         /* XMS hookable entry point */
170         0xEB,0x03,           /* jmp entry */
171         0x90,0x90,0x90,      /* nop;nop;nop */
172                              /* entry: */
173         /* real entry point */
174         /* for simplicity, we'll just use the same hook as DPMI below */
175         0xCD,0x31,           /* int $0x31 */
176         0xCB                 /* lret */
177     };
178
179     static const char enter_pm[]=
180     {
181         0x50,                /* pushw %ax */
182         0x52,                /* pushw %dx */
183         0x55,                /* pushw %bp */
184         0x89,0xE5,           /* movw %sp,%bp */
185         /* get return CS */
186         0x8B,0x56,0x08,      /* movw 8(%bp),%dx */
187         /* just call int 31 here to get into protected mode... */
188         /* it'll check whether it was called from dpmi_seg... */
189         0xCD,0x31,           /* int $0x31 */
190         /* we are now in the context of a 16-bit relay call */
191         /* need to fixup our stack;
192          * 16-bit relay return address will be lost, 
193          * but we won't worry quite yet 
194          */
195         0x8E,0xD0,           /* movw %ax,%ss */
196         0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
197         /* set return CS */
198         0x89,0x56,0x08,      /* movw %dx,8(%bp) */
199         0x5D,                /* popw %bp */
200         0x5A,                /* popw %dx */
201         0x58,                /* popw %ax */
202         0xfb,                /* sti, enable and check virtual interrupts */
203         0xCB                 /* lret */
204     };
205
206     static const char relay[]=
207     {
208         0xca, 0x04, 0x00, /* 16-bit far return and pop 4 bytes (relay void* arg) */
209         0xcd, 0x31,       /* int 31 */
210         0xfb, 0x66, 0xcb  /* sti and 32-bit far return */
211     };
212
213     /*
214      * Allocate pointer array.
215      */
216     DOSVM_dpmi_segments = DOSVM_AllocUMB( sizeof(struct DPMI_segments) );
217
218     /*
219      * RM / offset 0: Exit from real mode.
220      * RM / offset 2: Points to lret opcode.
221      */
222     ptr = DOSVM_AllocCodeUMB( sizeof(wrap_code),
223                               &DOSVM_dpmi_segments->wrap_seg, 0 );
224     memcpy( ptr, wrap_code, sizeof(wrap_code) );
225
226     /*
227      * RM / offset 0: XMS driver entry.
228      */
229     ptr = DOSVM_AllocCodeUMB( sizeof(enter_xms), 
230                               &DOSVM_dpmi_segments->xms_seg, 0 );
231     memcpy( ptr, enter_xms, sizeof(enter_xms) );
232
233     /*
234      * RM / offset 0: Switch to DPMI.
235      * PM / offset 8: DPMI raw mode switch.
236      */
237     ptr = DOSVM_AllocCodeUMB( sizeof(enter_pm), 
238                               &DOSVM_dpmi_segments->dpmi_seg,
239                               &DOSVM_dpmi_segments->dpmi_sel );
240     memcpy( ptr, enter_pm, sizeof(enter_pm) );
241
242     /*
243      * PM / offset N*6: Interrupt N in DPMI32.
244      */
245     ptr = DOSVM_AllocCodeUMB( 6 * 256,
246                               0, &DOSVM_dpmi_segments->int48_sel );
247     for(i=0; i<256; i++) {
248         /*
249          * Each 32-bit interrupt handler is 6 bytes:
250          * 0xCD,<i>            = int <i> (nested 16-bit interrupt)
251          * 0x66,0xCA,0x04,0x00 = ret 4   (32-bit far return and pop 4 bytes / eflags)
252          */
253         ptr[i * 6 + 0] = 0xCD;
254         ptr[i * 6 + 1] = i;
255         ptr[i * 6 + 2] = 0x66;
256         ptr[i * 6 + 3] = 0xCA;
257         ptr[i * 6 + 4] = 0x04;
258         ptr[i * 6 + 5] = 0x00;
259     }
260
261     /*
262      * PM / offset N*5: Interrupt N in 16-bit protected mode.
263      */
264     ptr = DOSVM_AllocCodeUMB( 5 * 256,
265                               0, &DOSVM_dpmi_segments->int16_sel );
266     for(i=0; i<256; i++) {
267         /*
268          * Each 16-bit interrupt handler is 5 bytes:
269          * 0xCD,<i>       = int <i> (interrupt)
270          * 0xCA,0x02,0x00 = ret 2   (16-bit far return and pop 2 bytes / eflags)
271          */
272         ptr[i * 5 + 0] = 0xCD;
273         ptr[i * 5 + 1] = i;
274         ptr[i * 5 + 2] = 0xCA;
275         ptr[i * 5 + 3] = 0x02;
276         ptr[i * 5 + 4] = 0x00;
277     }
278
279     /*
280      * PM / offset 0: Stub where __wine_call_from_16_regs returns.
281      * PM / offset 3: Stub which swaps back to 32-bit application code/stack.
282      * PM / offset 5: Stub which enables interrupts
283      */
284     ptr = DOSVM_AllocCodeUMB( sizeof(relay), 
285                               0,  &DOSVM_dpmi_segments->relay_code_sel);
286     memcpy( ptr, relay, sizeof(relay) );
287
288     /*
289      * Space for 16-bit stack used by relay code.
290      */
291     ptr = DOSVM_AllocDataUMB( DOSVM_RELAY_DATA_SIZE, 
292                               0, &DOSVM_dpmi_segments->relay_data_sel);
293     memset( ptr, 0, DOSVM_RELAY_DATA_SIZE );
294
295     /*
296      * As we store code in UMB we should make sure it is executable
297      */
298     VirtualProtect((void *)DOSVM_UMB_BOTTOM, DOSVM_UMB_TOP - DOSVM_UMB_BOTTOM, PAGE_EXECUTE_READWRITE, NULL);
299 }