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