?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move the FPS computation from the D3D code to the common code.
[wine/multimedia.git] / dlls / kernel / ne_segment.c
blobfe02b46a00d03014fc6ed5fc588316eda85fcec6
1 /*
2 * NE segment loading
3 *
4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <sys/types.h>
29 #include <fcntl.h>
30 #ifdef HAVE_UNISTD_H
31 # include <unistd.h>
32 #endif
33 #include <ctype.h>
34 #include <string.h>
35
36 #include "wine/winbase16.h"
37 #include "wownt32.h"
38 #include "wine/library.h"
39 #include "kernel_private.h"
40 #include "module.h"
41 #include "stackframe.h"
42 #include "builtin16.h"
43 #include "toolhelp.h"
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(fixup);
47 WINE_DECLARE_DEBUG_CHANNEL(dll);
48 WINE_DECLARE_DEBUG_CHANNEL(module);
49
50 /*
51 * Relocation table entry
52 */
53 struct relocation_entry_s
54 {
55 BYTE address_type; /* Relocation address type */
56 BYTE relocation_type; /* Relocation type */
57 WORD offset; /* Offset in segment to fixup */
58 WORD target1; /* Target specification */
59 WORD target2; /* Target specification */
60 };
61
62 /*
63 * Relocation address types
64 */
65 #define NE_RADDR_LOWBYTE 0
66 #define NE_RADDR_SELECTOR 2
67 #define NE_RADDR_POINTER32 3
68 #define NE_RADDR_OFFSET16 5
69 #define NE_RADDR_POINTER48 11
70 #define NE_RADDR_OFFSET32 13
71
72 /*
73 * Relocation types
74 */
75 #define NE_RELTYPE_INTERNAL 0
76 #define NE_RELTYPE_ORDINAL 1
77 #define NE_RELTYPE_NAME 2
78 #define NE_RELTYPE_OSFIXUP 3
79 #define NE_RELFLAG_ADDITIVE 4
80
81 /* Self-loading modules contain this structure in their first segment */
82 typedef struct
83 {
84 WORD version; /* Must be "A0" (0x3041) */
85 WORD reserved;
86 FARPROC16 BootApp; /* startup procedure */
87 FARPROC16 LoadAppSeg; /* procedure to load a segment */
88 FARPROC16 reserved2;
89 FARPROC16 MyAlloc; /* memory allocation procedure,
90 * wine must write this field */
91 FARPROC16 EntryAddrProc;
92 FARPROC16 ExitProc; /* exit procedure */
93 WORD reserved3[4];
94 FARPROC16 SetOwner; /* Set Owner procedure, exported by wine */
95 } SELFLOADHEADER;
96
97 #define SEL(x) ((x)|1)
98
99 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum);
100
101
102 /***********************************************************************
103 * NE_GetRelocAddrName
104 */
105 static const char *NE_GetRelocAddrName( BYTE addr_type, int additive )
106 {
107 switch(addr_type & 0x7f)
108 {
109 case NE_RADDR_LOWBYTE: return additive ? "BYTE add" : "BYTE";
110 case NE_RADDR_OFFSET16: return additive ? "OFFSET16 add" : "OFFSET16";
111 case NE_RADDR_POINTER32: return additive ? "POINTER32 add" : "POINTER32";
112 case NE_RADDR_SELECTOR: return additive ? "SELECTOR add" : "SELECTOR";
113 case NE_RADDR_POINTER48: return additive ? "POINTER48 add" : "POINTER48";
114 case NE_RADDR_OFFSET32: return additive ? "OFFSET32 add" : "OFFSET32";
115 }
116 return "???";
117 }
118
119
120 /***********************************************************************
121 * NE_LoadSegment
122 */
123 BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
124 {
125 SEGTABLEENTRY *pSegTable, *pSeg;
126 HMODULE16 *pModuleTable;
127 WORD count, i, offset, next_offset;
128 HMODULE16 module;
129 FARPROC16 address = 0;
130 HANDLE hf;
131 DWORD res;
132 struct relocation_entry_s *rep, *reloc_entries;
133 BYTE *func_name;
134 int size;
135 char* mem;
136
137 char buffer[256];
138 int ordinal, additive;
139 unsigned short *sp;
140
141 pSegTable = NE_SEG_TABLE( pModule );
142 pSeg = pSegTable + segnum - 1;
143
144 if (pSeg->flags & NE_SEGFLAGS_LOADED)
145 {
146 /* self-loader ? -> already loaded it */
147 if (pModule->flags & NE_FFLAGS_SELFLOAD)
148 return TRUE;
149
150 /* leave, except for DGROUP, as this may be the second instance */
151 if (segnum != pModule->dgroup)
152 return TRUE;
153 }
154
155 if (!pSeg->filepos) return TRUE; /* No file image, just return */
156
157 pModuleTable = (HMODULE16 *)((char *)pModule + pModule->modref_table);
158
159 hf = NE_OpenFile( pModule );
160 TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
161 segnum, pSeg->hSeg, pSeg->flags );
162 SetFilePointer( hf, pSeg->filepos << pModule->alignment, NULL, SEEK_SET );
163 if (pSeg->size) size = pSeg->size;
164 else size = pSeg->minsize ? pSeg->minsize : 0x10000;
165 mem = GlobalLock16(pSeg->hSeg);
166 if (pModule->flags & NE_FFLAGS_SELFLOAD && segnum > 1)
167 {
168 /* Implement self-loading segments */
169 SELFLOADHEADER *selfloadheader;
170 DWORD oldstack;
171 HANDLE hFile32;
172 HFILE16 hFile16;
173 WORD args[3];
174 DWORD ret;
175
176 selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
177 oldstack = NtCurrentTeb()->cur_stack;
178 NtCurrentTeb()->cur_stack = MAKESEGPTR(pModule->self_loading_sel,
179 0xff00 - sizeof(STACK16FRAME));
180
181 TRACE_(dll)("CallLoadAppSegProc(hmodule=0x%04x,hf=%p,segnum=%d\n",
182 pModule->self,hf,segnum );
183 DuplicateHandle( GetCurrentProcess(), hf, GetCurrentProcess(), &hFile32,
184 0, FALSE, DUPLICATE_SAME_ACCESS );
185 hFile16 = Win32HandleToDosFileHandle( hFile32 );
186 args[2] = pModule->self;
187 args[1] = hFile16;
188 args[0] = segnum;
189 WOWCallback16Ex( (DWORD)selfloadheader->LoadAppSeg, WCB16_PASCAL, sizeof(args), args, &ret );
190 pSeg->hSeg = LOWORD(ret);
191 TRACE_(dll)("Ret CallLoadAppSegProc: hSeg = 0x%04x\n", pSeg->hSeg);
192 _lclose16( hFile16 );
193 NtCurrentTeb()->cur_stack = oldstack;
194 }
195 else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
196 ReadFile(hf, mem, size, &res, NULL);
197 else {
198 /*
199 The following bit of code for "iterated segments" was written without
200 any documentation on the format of these segments. It seems to work,
201 but may be missing something. If you have any doc please either send
202 it to me or fix the code yourself. gfm@werple.mira.net.au
203 */
204 char* buff = HeapAlloc(GetProcessHeap(), 0, size);
205 char* curr = buff;
206
207 if(buff == NULL) {
208 WARN_(dll)("Memory exhausted!\n");
209 goto fail;
210 }
211
212 ReadFile(hf, buff, size, &res, NULL);
213 while(curr < buff + size) {
214 unsigned int rept = *((short*) curr)++;
215 unsigned int len = *((short*) curr)++;
216 for(; rept > 0; rept--) {
217 char* bytes = curr;
218 unsigned int byte;
219 for(byte = 0; byte < len; byte++)
220 *mem++ = *bytes++;
221 }
222 curr += len;
223 }
224 HeapFree(GetProcessHeap(), 0, buff);
225 }
226
227 pSeg->flags |= NE_SEGFLAGS_LOADED;
228
229 /* Perform exported function prolog fixups */
230 NE_FixupSegmentPrologs( pModule, segnum );
231
232 if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
233 goto succeed; /* No relocation data, we are done */
234
235 ReadFile(hf, &count, sizeof(count), &res, NULL);
236 if (!count) goto succeed;
237
238 TRACE("Fixups for %.*s, segment %d, hSeg %04x\n",
239 *((BYTE *)pModule + pModule->name_table),
240 (char *)pModule + pModule->name_table + 1,
241 segnum, pSeg->hSeg );
242
243 reloc_entries = (struct relocation_entry_s *)HeapAlloc(GetProcessHeap(), 0, count * sizeof(struct relocation_entry_s));
244 if(reloc_entries == NULL) {
245 WARN("Not enough memory for relocation entries!\n");
246 goto fail;
247 }
248 if (!ReadFile( hf, reloc_entries, count * sizeof(struct relocation_entry_s), &res, NULL) ||
249 (res != count * sizeof(struct relocation_entry_s)))
250 {
251 WARN("Unable to read relocation information\n" );
252 goto fail;
253 }
254
255 /*
256 * Go through the relocation table one entry at a time.
257 */
258 rep = reloc_entries;
259 for (i = 0; i < count; i++, rep++)
260 {
261 /*
262 * Get the target address corresponding to this entry.
263 */
264
265 /* If additive, there is no target chain list. Instead, add source
266 and target */
267 additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
268 rep->relocation_type &= 0x3;
269
270 switch (rep->relocation_type)
271 {
272 case NE_RELTYPE_ORDINAL:
273 module = pModuleTable[rep->target1-1];
274 ordinal = rep->target2;
275 address = NE_GetEntryPoint( module, ordinal );
276 if (!address)
277 {
278 NE_MODULE *pTarget = NE_GetPtr( module );
279 if (!pTarget)
280 WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
281 module, rep->target1,
282 *((BYTE *)pModule + pModule->name_table),
283 *((BYTE *)pModule + pModule->name_table),
284 (char *)pModule + pModule->name_table + 1 );
285 else
286 {
287 ERR("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
288 *((BYTE *)pTarget + pTarget->name_table),
289 (char *)pTarget + pTarget->name_table + 1,
290 ordinal );
291 address = (FARPROC16)0xdeadbeef;
292 }
293 }
294 if (TRACE_ON(fixup))
295 {
296 NE_MODULE *pTarget = NE_GetPtr( module );
297 TRACE("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
298 *((BYTE *)pTarget + pTarget->name_table),
299 (char *)pTarget + pTarget->name_table + 1,
300 ordinal, HIWORD(address), LOWORD(address),
301 NE_GetRelocAddrName( rep->address_type, additive ) );
302 }
303 break;
304
305 case NE_RELTYPE_NAME:
306 module = pModuleTable[rep->target1-1];
307 func_name = (char *)pModule + pModule->import_table + rep->target2;
308 memcpy( buffer, func_name+1, *func_name );
309 buffer[*func_name] = '\0';
310 func_name = buffer;
311 ordinal = NE_GetOrdinal( module, func_name );
312 address = NE_GetEntryPoint( module, ordinal );
313
314 if (ERR_ON(fixup) && !address)
315 {
316 NE_MODULE *pTarget = NE_GetPtr( module );
317 ERR("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
318 *((BYTE *)pTarget + pTarget->name_table),
319 (char *)pTarget + pTarget->name_table + 1, func_name );
320 }
321 if (!address) address = (FARPROC16) 0xdeadbeef;
322 if (TRACE_ON(fixup))
323 {
324 NE_MODULE *pTarget = NE_GetPtr( module );
325 TRACE("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
326 *((BYTE *)pTarget + pTarget->name_table),
327 (char *)pTarget + pTarget->name_table + 1,
328 func_name, HIWORD(address), LOWORD(address),
329 NE_GetRelocAddrName( rep->address_type, additive ) );
330 }
331 break;
332
333 case NE_RELTYPE_INTERNAL:
334 if ((rep->target1 & 0xff) == 0xff)
335 {
336 address = NE_GetEntryPoint( pModule->self, rep->target2 );
337 }
338 else
339 {
340 address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
341 }
342
343 TRACE("%d: %04x:%04x %s\n",
344 i + 1, HIWORD(address), LOWORD(address),
345 NE_GetRelocAddrName( rep->address_type, additive ) );
346 break;
347
348 case NE_RELTYPE_OSFIXUP:
349 /* Relocation type 7:
350 *
351 * These appear to be used as fixups for the Windows
352 * floating point emulator. Let's just ignore them and
353 * try to use the hardware floating point. Linux should
354 * successfully emulate the coprocessor if it doesn't
355 * exist.
356 */
357 TRACE("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
358 i + 1, rep->relocation_type, rep->offset,
359 rep->target1, rep->target2,
360 NE_GetRelocAddrName( rep->address_type, additive ) );
361 continue;
362 }
363
364 offset = rep->offset;
365
366 /* Apparently, high bit of address_type is sometimes set; */
367 /* we ignore it for now */
368 if (rep->address_type > NE_RADDR_OFFSET32)
369 {
370 char module[10];
371 GetModuleName16( pModule->self, module, sizeof(module) );
372 ERR("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
373 module, rep->address_type );
374 }
375
376 if (additive)
377 {
378 sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
379 TRACE(" %04x:%04x\n", offset, *sp );
380 switch (rep->address_type & 0x7f)
381 {
382 case NE_RADDR_LOWBYTE:
383 *(BYTE *)sp += LOBYTE((int)address);
384 break;
385 case NE_RADDR_OFFSET16:
386 *sp += LOWORD(address);
387 break;
388 case NE_RADDR_POINTER32:
389 *sp += LOWORD(address);
390 *(sp+1) = HIWORD(address);
391 break;
392 case NE_RADDR_SELECTOR:
393 /* Borland creates additive records with offset zero. Strange, but OK */
394 if (*sp)
395 ERR("Additive selector to %04x.Please report\n",*sp);
396 else
397 *sp = HIWORD(address);
398 break;
399 default:
400 goto unknown;
401 }
402 }
403 else /* non-additive fixup */
404 {
405 do
406 {
407 sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
408 next_offset = *sp;
409 TRACE(" %04x:%04x\n", offset, *sp );
410 switch (rep->address_type & 0x7f)
411 {
412 case NE_RADDR_LOWBYTE:
413 *(BYTE *)sp = LOBYTE((int)address);
414 break;
415 case NE_RADDR_OFFSET16:
416 *sp = LOWORD(address);
417 break;
418 case NE_RADDR_POINTER32:
419 *(FARPROC16 *)sp = address;
420 break;
421 case NE_RADDR_SELECTOR:
422 *sp = SELECTOROF(address);
423 break;
424 default:
425 goto unknown;
426 }
427 if (next_offset == offset) break; /* avoid infinite loop */
428 if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
429 offset = next_offset;
430 } while (offset != 0xffff);
431 }
432 }
433
434 HeapFree(GetProcessHeap(), 0, reloc_entries);
435
436 succeed:
437 CloseHandle(hf);
438 return TRUE;
439
440 unknown:
441 WARN("WARNING: %d: unknown ADDR TYPE %d, "
442 "TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
443 i + 1, rep->address_type, rep->relocation_type,
444 rep->offset, rep->target1, rep->target2);
445 HeapFree(GetProcessHeap(), 0, reloc_entries);
446
447 fail:
448 CloseHandle(hf);
449 return FALSE;
450 }
451
452
453 /***********************************************************************
454 * NE_LoadAllSegments
455 */
456 BOOL NE_LoadAllSegments( NE_MODULE *pModule )
457 {
458 int i;
459 SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
460
461 if (pModule->flags & NE_FFLAGS_SELFLOAD)
462 {
463 HANDLE hf;
464 HFILE16 hFile16;
465 HGLOBAL16 sel;
466 /* Handle self-loading modules */
467 SELFLOADHEADER *selfloadheader;
468 HMODULE16 mod = GetModuleHandle16("KERNEL");
469 DWORD oldstack;
470 WORD args[2];
471
472 TRACE_(module)("%.*s is a self-loading module!\n",
473 *((BYTE*)pModule + pModule->name_table),
474 (char *)pModule + pModule->name_table + 1);
475 if (!NE_LoadSegment( pModule, 1 )) return FALSE;
476 selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg), 0) );
477 selfloadheader->EntryAddrProc = GetProcAddress16(mod,"EntryAddrProc");
478 selfloadheader->MyAlloc = GetProcAddress16(mod,"MyAlloc");
479 selfloadheader->SetOwner = GetProcAddress16(mod,"FarSetOwner");
480 sel = GlobalAlloc16( GMEM_ZEROINIT, 0xFF00 );
481 pModule->self_loading_sel = SEL(sel);
482 FarSetOwner16( sel, pModule->self );
483 oldstack = NtCurrentTeb()->cur_stack;
484 NtCurrentTeb()->cur_stack = MAKESEGPTR(pModule->self_loading_sel,
485 0xff00 - sizeof(STACK16FRAME) );
486
487 hf = NE_OpenFile(pModule);
488 hFile16 = Win32HandleToDosFileHandle( hf );
489 TRACE_(dll)("CallBootAppProc(hModule=0x%04x,hf=0x%04x)\n",
490 pModule->self,hFile16);
491 args[1] = pModule->self;
492 args[0] = hFile16;
493 WOWCallback16Ex( (DWORD)selfloadheader->BootApp, WCB16_PASCAL, sizeof(args), args, NULL );
494 TRACE_(dll)("Return from CallBootAppProc\n");
495 _lclose16(hFile16);
496 NtCurrentTeb()->cur_stack = oldstack;
497
498 for (i = 2; i <= pModule->seg_count; i++)
499 if (!NE_LoadSegment( pModule, i )) return FALSE;
500 }
501 else
502 {
503 for (i = 1; i <= pModule->seg_count; i++)
504 if (!NE_LoadSegment( pModule, i )) return FALSE;
505 }
506 return TRUE;
507 }
508
509
510 /***********************************************************************
511 * NE_FixupSegmentPrologs
512 *
513 * Fixup exported functions prologs of one segment
514 */
515 static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
516 {
517 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
518 ET_BUNDLE *bundle;
519 ET_ENTRY *entry;
520 WORD dgroup, num_entries, sel = SEL(pSegTable[segnum-1].hSeg);
521 BYTE *pSeg, *pFunc;
522
523 TRACE("(%d);\n", segnum);
524
525 if (pSegTable[segnum-1].flags & NE_SEGFLAGS_DATA)
526 {
527 pSegTable[segnum-1].flags |= NE_SEGFLAGS_LOADED;
528 return;
529 }
530
531 if (!pModule->dgroup) return;
532
533 if (!(dgroup = SEL(pSegTable[pModule->dgroup-1].hSeg))) return;
534
535 pSeg = MapSL( MAKESEGPTR(sel, 0) );
536
537 bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->entry_table);
538
539 do {
540 TRACE("num_entries: %d, bundle: %p, next: %04x, pSeg: %p\n", bundle->last - bundle->first, bundle, bundle->next, pSeg);
541 if (!(num_entries = bundle->last - bundle->first))
542 return;
543 entry = (ET_ENTRY *)((BYTE *)bundle+6);
544 while (num_entries--)
545 {
546 /*TRACE("entry: %p, entry->segnum: %d, entry->offs: %04x\n", entry, entry->segnum, entry->offs);*/
547 if (entry->segnum == segnum)
548 {
549 pFunc = ((BYTE *)pSeg+entry->offs);
550 TRACE("pFunc: %p, *(DWORD *)pFunc: %08lx, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
551 if (*(pFunc+2) == 0x90)
552 {
553 if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
554 {
555 TRACE("patch %04x:%04x -> mov ax, ds\n", sel, entry->offs);
556 *(WORD *)pFunc = 0xd88c; /* mov ax, ds */
557 }
558
559 if (*(WORD *)pFunc == 0xd88c)
560 {
561 if ((entry->flags & 2)) /* public data ? */
562 {
563 TRACE("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry->offs, dgroup);
564 *pFunc = 0xb8; /* mov ax, */
565 *(WORD *)(pFunc+1) = dgroup;
566 }
567 else
568 if ((pModule->flags & NE_FFLAGS_MULTIPLEDATA)
569 && (entry->flags & 1)) /* exported ? */
570 {
571 TRACE("patch %04x:%04x -> nop, nop\n", sel, entry->offs);
572 *(WORD *)pFunc = 0x9090; /* nop, nop */
573 }
574 }
575 }
576 }
577 entry++;
578 }
579 } while ( (bundle->next)
580 && (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
581 }
582
583
584 /***********************************************************************
585 * PatchCodeHandle (KERNEL.110)
586 *
587 * Needed for self-loading modules.
588 */
589 DWORD WINAPI PatchCodeHandle16(HANDLE16 hSeg)
590 {
591 WORD segnum;
592 WORD sel = SEL(hSeg);
593 NE_MODULE *pModule = NE_GetPtr(FarGetOwner16(sel));
594 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE(pModule);
595
596 TRACE_(module)("(%04x);\n", hSeg);
597
598 /* find the segment number of the module that belongs to hSeg */
599 for (segnum = 1; segnum <= pModule->seg_count; segnum++)
600 {
601 if (SEL(pSegTable[segnum-1].hSeg) == sel)
602 {
603 NE_FixupSegmentPrologs(pModule, segnum);
604 break;
605 }
606 }
607
608 return MAKELONG(hSeg, sel);
609 }
610
611
612 /***********************************************************************
613 * NE_GetDLLInitParams
614 */
615 static VOID NE_GetDLLInitParams( NE_MODULE *pModule,
616 WORD *hInst, WORD *ds, WORD *heap )
617 {
618 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
619
620 if (!(pModule->flags & NE_FFLAGS_SINGLEDATA))
621 {
622 if (pModule->flags & NE_FFLAGS_MULTIPLEDATA || pModule->dgroup)
623 {
624 /* Not SINGLEDATA */
625 ERR_(dll)("Library is not marked SINGLEDATA\n");
626 exit(1);
627 }
628 else /* DATA NONE DLL */
629 {
630 *ds = 0;
631 *heap = 0;
632 }
633 }
634 else /* DATA SINGLE DLL */
635 {
636 if (pModule->dgroup) {
637 *ds = SEL(pSegTable[pModule->dgroup-1].hSeg);
638 *heap = pModule->heap_size;
639 }
640 else /* hmm, DLL has no dgroup,
641 but why has it NE_FFLAGS_SINGLEDATA set ?
642 Buggy DLL compiler ? */
643 {
644 *ds = 0;
645 *heap = 0;
646 }
647 }
648
649 *hInst = *ds ? GlobalHandle16(*ds) : pModule->self;
650 }
651
652
653 /***********************************************************************
654 * NE_InitDLL
655 *
656 * Call the DLL initialization code
657 */
658 static BOOL NE_InitDLL( NE_MODULE *pModule )
659 {
660 SEGTABLEENTRY *pSegTable;
661 WORD hInst, ds, heap;
662 CONTEXT86 context;
663
664 pSegTable = NE_SEG_TABLE( pModule );
665
666 if (!(pModule->flags & NE_FFLAGS_LIBMODULE) ||
667 (pModule->flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
668
669 /* Call USER signal handler for Win3.1 compatibility. */
670 NE_CallUserSignalProc( pModule->self, USIG16_DLL_LOAD );
671
672 if (!pModule->cs) return TRUE; /* no initialization code */
673
674
675 /* Registers at initialization must be:
676 * cx heap size
677 * di library instance
678 * ds data segment if any
679 * es:si command line (always 0)
680 */
681
682 memset( &context, 0, sizeof(context) );
683
684 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
685
686 context.Ecx = heap;
687 context.Edi = hInst;
688 context.SegDs = ds;
689 context.SegEs = ds; /* who knows ... */
690 context.SegFs = wine_get_fs();
691 context.SegGs = wine_get_gs();
692 context.SegCs = SEL(pSegTable[pModule->cs-1].hSeg);
693 context.Eip = pModule->ip;
694 context.Ebp = OFFSETOF(NtCurrentTeb()->cur_stack) + (WORD)&((STACK16FRAME*)0)->bp;
695
696 pModule->cs = 0; /* Don't initialize it twice */
697 TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
698 *((BYTE*)pModule + pModule->name_table),
699 (char *)pModule + pModule->name_table + 1,
700 context.SegCs, context.Eip, context.SegDs,
701 LOWORD(context.Edi), LOWORD(context.Ecx) );
702 WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&context );
703 return TRUE;
704 }
705
706 /***********************************************************************
707 * NE_InitializeDLLs
708 *
709 * Recursively initialize all DLLs (according to the order in which
710 * they where loaded).
711 */
712 void NE_InitializeDLLs( HMODULE16 hModule )
713 {
714 NE_MODULE *pModule;
715 HMODULE16 *pDLL;
716
717 if (!(pModule = NE_GetPtr( hModule ))) return;
718 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
719
720 if (pModule->dlls_to_init)
721 {
722 HGLOBAL16 to_init = pModule->dlls_to_init;
723 pModule->dlls_to_init = 0;
724 for (pDLL = (HMODULE16 *)GlobalLock16( to_init ); *pDLL; pDLL++)
725 {
726 NE_InitializeDLLs( *pDLL );
727 }
728 GlobalFree16( to_init );
729 }
730 NE_InitDLL( pModule );
731 }
732
733
734 /**********************************************************************
735 * NE_CallUserSignalProc
736 *
737 * According to "Undocumented Windows", the task signal proc is
738 * bypassed for module load/unload notifications, and the USER signal
739 * proc is called directly instead. This is what this function does.
740 */
741 typedef DWORD (WINAPI *pSignalProc)( HANDLE16 module, UINT16 code, UINT16 exit,
742 HINSTANCE16 inst, HQUEUE16 queue );
743
744 void NE_CallUserSignalProc( HMODULE16 hModule, UINT16 code )
745 {
746 FARPROC16 proc;
747 HMODULE16 user = GetModuleHandle16("user.exe");
748
749 if (!user) return;
750 if ((proc = GetProcAddress16( user, "SignalProc" )))
751 {
752 /* USER is always a builtin dll */
753 pSignalProc sigproc = (pSignalProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)proc ))->target;
754 sigproc( hModule, code, 0, 0, 0 );
755 }
756 }
757
758
759 /***********************************************************************
760 * NE_CallDllEntryPoint
761 *
762 * Call the DllEntryPoint of DLLs with subsystem >= 4.0
763 */
764 typedef DWORD (WINAPI *WinNEEntryProc)(DWORD,WORD,WORD,WORD,DWORD,WORD);
765
766 static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
767 {
768 WORD hInst, ds, heap;
769 FARPROC16 entryPoint;
770
771 if (!(pModule->flags & NE_FFLAGS_LIBMODULE)) return;
772 if (!(pModule->flags & NE_FFLAGS_BUILTIN) && pModule->expected_version < 0x0400) return;
773 if (!(entryPoint = GetProcAddress16( pModule->self, "DllEntryPoint" ))) return;
774
775 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
776
777 TRACE_(dll)( "Calling %s DllEntryPoint, cs:ip=%04x:%04x\n",
778 NE_MODULE_NAME( pModule ),
779 SELECTOROF(entryPoint), OFFSETOF(entryPoint) );
780
781 if ( pModule->flags & NE_FFLAGS_BUILTIN )
782 {
783 WinNEEntryProc entryProc = (WinNEEntryProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)entryPoint ))->target;
784
785 entryProc( dwReason, hInst, ds, heap, 0, 0 );
786 }
787 else
788 {
789 CONTEXT86 context;
790 WORD args[8];
791
792 memset( &context, 0, sizeof(context) );
793 context.SegDs = ds;
794 context.SegEs = ds; /* who knows ... */
795 context.SegFs = wine_get_fs();
796 context.SegGs = wine_get_gs();
797 context.SegCs = HIWORD(entryPoint);
798 context.Eip = LOWORD(entryPoint);
799 context.Ebp = OFFSETOF( NtCurrentTeb()->cur_stack )
800 + (WORD)&((STACK16FRAME*)0)->bp;
801
802 args[7] = HIWORD(dwReason);
803 args[6] = LOWORD(dwReason);
804 args[5] = hInst;
805 args[4] = ds;
806 args[3] = heap;
807 args[2] = 0; /* HIWORD(dwReserved1) */
808 args[1] = 0; /* LOWORD(dwReserved1) */
809 args[0] = 0; /* wReserved2 */
810 WOWCallback16Ex( 0, WCB16_REGS, sizeof(args), args, (DWORD *)&context );
811 }
812 }
813
814 /***********************************************************************
815 * NE_DllProcessAttach
816 *
817 * Call the DllEntryPoint of all modules this one (recursively)
818 * depends on, according to the order in which they were loaded.
819 *
820 * Note that --as opposed to the PE module case-- there is no notion
821 * of 'module loaded into a process' for NE modules, and hence we
822 * have no place to store the fact that the DllEntryPoint of a
823 * given module was already called on behalf of this process (e.g.
824 * due to some earlier LoadLibrary16 call).
825 *
826 * Thus, we just call the DllEntryPoint twice in that case. Win9x
827 * appears to behave this way as well ...
828 *
829 * This routine must only be called with the Win16Lock held.
830 *
831 * FIXME: We should actually abort loading in case the DllEntryPoint
832 * returns FALSE ...
833 *
834 */
835
836 struct ne_init_list
837 {
838 int count;
839 int size;
840 NE_MODULE **module;
841 };
842
843 static void add_to_init_list( struct ne_init_list *list, NE_MODULE *hModule )
844 {
845 NE_MODULE **newModule = NULL;
846 if ( list->count == list->size )
847 {
848 int newSize = list->size + 128;
849
850 if (list->module)
851 newModule = HeapReAlloc( GetProcessHeap(), 0,
852 list->module, newSize*sizeof(NE_MODULE *) );
853 else
854 newModule = HeapAlloc( GetProcessHeap(), 0,
855 newSize*sizeof(NE_MODULE *) );
856 if ( !newModule )
857 {
858 FIXME_(dll)("Out of memory!\n");
859 return;
860 }
861
862 list->module = newModule;
863 list->size = newSize;
864 }
865
866 list->module[list->count++] = hModule;
867 }
868
869 static void free_init_list( struct ne_init_list *list )
870 {
871 if ( list->module )
872 {
873 HeapFree( GetProcessHeap(), 0, list->module );
874 memset( list, 0, sizeof(*list) );
875 }
876 }
877
878 static void fill_init_list( struct ne_init_list *list, HMODULE16 hModule )
879 {
880 NE_MODULE *pModule;
881 HMODULE16 *pModRef;
882 int i;
883
884 if (!(pModule = NE_GetPtr( hModule ))) return;
885 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
886
887 /* Never add a module twice */
888 for ( i = 0; i < list->count; i++ )
889 if ( list->module[i] == pModule )
890 return;
891
892 /* Check for recursive call */
893 if ( pModule->misc_flags & 0x80 ) return;
894
895 TRACE_(dll)("(%s) - START\n", NE_MODULE_NAME(pModule) );
896
897 /* Tag current module to prevent recursive loop */
898 pModule->misc_flags |= 0x80;
899
900 /* Recursively attach all DLLs this one depends on */
901 pModRef = (HMODULE16 *)((char *)pModule + pModule->modref_table);
902 for ( i = 0; i < pModule->modref_count; i++ )
903 if ( pModRef[i] ) fill_init_list( list, pModRef[i] );
904
905 /* Add current module */
906 add_to_init_list( list, pModule );
907
908 /* Remove recursion flag */
909 pModule->misc_flags &= ~0x80;
910
911 TRACE_(dll)("(%s) - END\n", NE_MODULE_NAME(pModule) );
912 }
913
914 static void call_init_list( struct ne_init_list *list )
915 {
916 int i;
917 for ( i = 0; i < list->count; i++ )
918 NE_CallDllEntryPoint( list->module[i], DLL_PROCESS_ATTACH );
919 }
920
921 void NE_DllProcessAttach( HMODULE16 hModule )
922 {
923 struct ne_init_list list;
924 memset( &list, 0, sizeof(list) );
925
926 fill_init_list( &list, hModule );
927 call_init_list( &list );
928 free_init_list( &list );
929 }
930
931
932 /***********************************************************************
933 * NE_Ne2MemFlags
934 *
935 * This function translates NE segment flags to GlobalAlloc flags
936 */
937 static WORD NE_Ne2MemFlags(WORD flags)
938 {
939 WORD memflags = 0;
940 #if 1
941 if (flags & NE_SEGFLAGS_DISCARDABLE)
942 memflags |= GMEM_DISCARDABLE;
943 if (flags & NE_SEGFLAGS_MOVEABLE ||
944 ( ! (flags & NE_SEGFLAGS_DATA) &&
945 ! (flags & NE_SEGFLAGS_LOADED) &&
946 ! (flags & NE_SEGFLAGS_ALLOCATED)
947 )
948 )
949 memflags |= GMEM_MOVEABLE;
950 memflags |= GMEM_ZEROINIT;
951 #else
952 memflags = GMEM_ZEROINIT | GMEM_FIXED;
953 #endif
954 return memflags;
955 }
956
957 /***********************************************************************
958 * MyAlloc (KERNEL.668) Wine-specific export
959 *
960 * MyAlloc() function for self-loading apps.
961 */
962 DWORD WINAPI MyAlloc16( WORD wFlags, WORD wSize, WORD wElem )
963 {
964 WORD size = wSize << wElem;
965 HANDLE16 hMem = 0;
966
967 if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE))
968 hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size);
969
970 if ( ((wFlags & 0x7) != 0x1) && /* DATA */
971 ((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */
972 {
973 WORD hSel = SEL(hMem);
974 WORD access = SelectorAccessRights16(hSel,0,0);
975
976 access |= 2<<2; /* SEGMENT_CODE */
977 SelectorAccessRights16(hSel,1,access);
978 }
979 if (size)
980 return MAKELONG( hMem, SEL(hMem) );
981 else
982 return MAKELONG( 0, hMem );
983 }
984
985 /***********************************************************************
986 * NE_GetInstance
987 */
988 HINSTANCE16 NE_GetInstance( NE_MODULE *pModule )
989 {
990 if ( !pModule->dgroup )
991 return pModule->self;
992 else
993 {
994 SEGTABLEENTRY *pSeg;
995 pSeg = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
996 return pSeg->hSeg;
997 }
998 }
999
1000 /***********************************************************************
1001 * NE_CreateSegment
1002 */
1003 BOOL NE_CreateSegment( NE_MODULE *pModule, int segnum )
1004 {
1005 SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + segnum - 1;
1006 int minsize;
1007 unsigned char selflags;
1008
1009 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
1010
1011 if ( segnum < 1 || segnum > pModule->seg_count )
1012 return FALSE;
1013
1014 if ( (pModule->flags & NE_FFLAGS_SELFLOAD) && segnum != 1 )
1015 return TRUE; /* selfloader allocates segment itself */
1016
1017 if ( (pSeg->flags & NE_SEGFLAGS_ALLOCATED) && segnum != pModule->dgroup )
1018 return TRUE; /* all but DGROUP only allocated once */
1019
1020 minsize = pSeg->minsize ? pSeg->minsize : 0x10000;
1021 if ( segnum == pModule->ss ) minsize += pModule->stack_size;
1022 if ( segnum == pModule->dgroup ) minsize += pModule->heap_size;
1023
1024 selflags = (pSeg->flags & NE_SEGFLAGS_DATA) ? WINE_LDT_FLAGS_DATA : WINE_LDT_FLAGS_CODE;
1025 if (pSeg->flags & NE_SEGFLAGS_32BIT) selflags |= WINE_LDT_FLAGS_32BIT;
1026 pSeg->hSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSeg->flags), minsize, pModule->self, selflags );
1027 if (!pSeg->hSeg) return FALSE;
1028
1029 pSeg->flags |= NE_SEGFLAGS_ALLOCATED;
1030 return TRUE;
1031 }
1032
1033 /***********************************************************************
1034 * NE_CreateAllSegments
1035 */
1036 BOOL NE_CreateAllSegments( NE_MODULE *pModule )
1037 {
1038 int i;
1039 for ( i = 1; i <= pModule->seg_count; i++ )
1040 if ( !NE_CreateSegment( pModule, i ) )
1041 return FALSE;
1042
1043 pModule->dgroup_entry = pModule->dgroup ? pModule->seg_table +
1044 (pModule->dgroup - 1) * sizeof(SEGTABLEENTRY) : 0;
1045 return TRUE;
1046 }
1047
1048
1049 /**********************************************************************
1050 * IsSharedSelector (KERNEL.345)
1051 */
1052 BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
1053 {
1054 /* Check whether the selector belongs to a DLL */
1055 NE_MODULE *pModule = NE_GetPtr( selector );
1056 if (!pModule) return FALSE;
1057 return (pModule->flags & NE_FFLAGS_LIBMODULE) != 0;
1058 }
Maarten's multimedia branch