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