?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't create thunk for task signal proc, call it directly.
[wine/wine-kai.git] / loader / ne / segment.c
blob698343852651796d8ab57b3291478c3d2c4b0fc0
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 TASK_CallTaskSignalProc( USIG16_DLL_LOAD, pModule->self );
617
618 if (!pModule->cs) return TRUE; /* no initialization code */
619
620
621 /* Registers at initialization must be:
622 * cx heap size
623 * di library instance
624 * ds data segment if any
625 * es:si command line (always 0)
626 */
627
628 memset( &context, 0, sizeof(context) );
629
630 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
631
632 ECX_reg(&context) = heap;
633 EDI_reg(&context) = hInst;
634 DS_reg(&context) = ds;
635 ES_reg(&context) = ds; /* who knows ... */
636
637 CS_reg(&context) = SEL(pSegTable[pModule->cs-1].hSeg);
638 EIP_reg(&context) = pModule->ip;
639 EBP_reg(&context) = OFFSETOF(NtCurrentTeb()->cur_stack) + (WORD)&((STACK16FRAME*)0)->bp;
640
641
642 pModule->cs = 0; /* Don't initialize it twice */
643 TRACE_(dll)("Calling LibMain, cs:ip=%04lx:%04lx ds=%04lx di=%04x cx=%04x\n",
644 CS_reg(&context), EIP_reg(&context), DS_reg(&context),
645 DI_reg(&context), CX_reg(&context) );
646 Callbacks->CallRegisterShortProc( &context, 0 );
647 return TRUE;
648 }
649
650 /***********************************************************************
651 * NE_CallDllEntryPoint
652 *
653 * Call the DllEntryPoint of DLLs with subsystem >= 4.0
654 */
655
656 static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
657 {
658 WORD hInst, ds, heap;
659 FARPROC16 entryPoint;
660 WORD ordinal;
661 CONTEXT86 context;
662 LPBYTE stack = (LPBYTE)CURRENT_STACK16;
663
664 if (!(pModule->flags & NE_FFLAGS_BUILTIN) && pModule->expected_version < 0x0400) return;
665 if (!(ordinal = NE_GetOrdinal( pModule->self, "DllEntryPoint" ))) return;
666 if (!(entryPoint = NE_GetEntryPoint( pModule->self, ordinal ))) return;
667
668 memset( &context, 0, sizeof(context) );
669
670 NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
671
672 DS_reg(&context) = ds;
673 ES_reg(&context) = ds; /* who knows ... */
674
675 CS_reg(&context) = HIWORD(entryPoint);
676 EIP_reg(&context) = LOWORD(entryPoint);
677 EBP_reg(&context) = OFFSETOF( NtCurrentTeb()->cur_stack )
678 + (WORD)&((STACK16FRAME*)0)->bp;
679
680 *(DWORD *)(stack - 4) = dwReason; /* dwReason */
681 *(WORD *) (stack - 6) = hInst; /* hInst */
682 *(WORD *) (stack - 8) = ds; /* wDS */
683 *(WORD *) (stack - 10) = heap; /* wHeapSize */
684 *(DWORD *)(stack - 14) = 0; /* dwReserved1 */
685 *(WORD *) (stack - 16) = 0; /* wReserved2 */
686
687 TRACE_(dll)("Calling DllEntryPoint, cs:ip=%04lx:%04lx\n",
688 CS_reg(&context), EIP_reg(&context));
689
690 Callbacks->CallRegisterShortProc( &context, 16 );
691 }
692
693
694 /***********************************************************************
695 * NE_InitializeDLLs
696 *
697 * Recursively initialize all DLLs (according to the order in which
698 * they where loaded).
699 */
700 void NE_InitializeDLLs( HMODULE16 hModule )
701 {
702 TDB* pTask = (TDB*)GlobalLock16(GetCurrentTask());
703 NE_MODULE *pModule;
704 HMODULE16 *pDLL;
705
706 if (!(pModule = NE_GetPtr( hModule ))) return;
707 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
708
709 if (pModule->dlls_to_init)
710 {
711 HGLOBAL16 to_init = pModule->dlls_to_init;
712 pModule->dlls_to_init = 0;
713 for (pDLL = (HMODULE16 *)GlobalLock16( to_init ); *pDLL; pDLL++)
714 {
715 NE_InitializeDLLs( *pDLL );
716 }
717 GlobalFree16( to_init );
718 }
719 NE_InitDLL( pTask, pModule );
720 NE_CallDllEntryPoint( pModule, DLL_PROCESS_ATTACH );
721 }
722
723
724 /***********************************************************************
725 * NE_Ne2MemFlags
726 *
727 * This function translates NE segment flags to GlobalAlloc flags
728 */
729 static WORD NE_Ne2MemFlags(WORD flags)
730 {
731 WORD memflags = 0;
732 #if 1
733 if (flags & NE_SEGFLAGS_DISCARDABLE)
734 memflags |= GMEM_DISCARDABLE;
735 if (flags & NE_SEGFLAGS_MOVEABLE ||
736 ( ! (flags & NE_SEGFLAGS_DATA) &&
737 ! (flags & NE_SEGFLAGS_LOADED) &&
738 ! (flags & NE_SEGFLAGS_ALLOCATED)
739 )
740 )
741 memflags |= GMEM_MOVEABLE;
742 memflags |= GMEM_ZEROINIT;
743 #else
744 memflags = GMEM_ZEROINIT | GMEM_FIXED;
745 #endif
746 return memflags;
747 }
748
749
750 /***********************************************************************
751 * NE_CreateInstance
752 *
753 * If lib_only is TRUE, handle the module like a library even if it is a .EXE
754 */
755 HINSTANCE16 NE_CreateInstance( NE_MODULE *pModule, HINSTANCE16 *prev,
756 BOOL lib_only )
757 {
758 SEGTABLEENTRY *pSegment;
759 int minsize;
760 HINSTANCE16 hNewSeg;
761
762 if (pModule->dgroup == 0)
763 {
764 if (prev) *prev = pModule->self;
765 return pModule->self;
766 }
767
768 pSegment = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1;
769 if (prev) *prev = SEL(pSegment->hSeg);
770
771 /* if it's a library, create a new instance only the first time */
772 if (pSegment->hSeg)
773 {
774 if (pModule->flags & NE_FFLAGS_LIBMODULE) return SEL(pSegment->hSeg);
775 if (lib_only) return SEL(pSegment->hSeg);
776 }
777
778 minsize = pSegment->minsize ? pSegment->minsize : 0x10000;
779 if (pModule->ss == pModule->dgroup) minsize += pModule->stack_size;
780 minsize += pModule->heap_size;
781 hNewSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSegment->flags), minsize,
782 pModule->self, FALSE, FALSE, FALSE );
783 if (!hNewSeg) return 0;
784 pSegment->hSeg = hNewSeg;
785 pSegment->flags |= NE_SEGFLAGS_ALLOCATED;
786
787 /* a HINSTANCE is the selector of the DSEG */
788 return (HINSTANCE16)SEL(hNewSeg);
789 }
790
791
792 /***********************************************************************
793 * NE_AllocateSegment (WPROCS.26)
794 *
795 * MyAlloc() function for self-loading apps.
796 */
797 DWORD WINAPI NE_AllocateSegment( WORD wFlags, WORD wSize, WORD wElem )
798 {
799 WORD size = wSize << wElem;
800 HANDLE16 hMem = 0;
801
802 if (wSize || (wFlags & NE_SEGFLAGS_MOVEABLE))
803 hMem = GlobalAlloc16( NE_Ne2MemFlags(wFlags), size);
804
805 if ( ((wFlags & 0x7) != 0x1) && /* DATA */
806 ((wFlags & 0x7) != 0x7) ) /* DATA|ALLOCATED|LOADED */
807 {
808 WORD hSel = SEL(hMem);
809 WORD access = SelectorAccessRights16(hSel,0,0);
810
811 access |= 2<<2; /* SEGMENT_CODE */
812 SelectorAccessRights16(hSel,1,access);
813 }
814 if (size)
815 return MAKELONG( hMem, SEL(hMem) );
816 else
817 return MAKELONG( 0, hMem );
818 }
819
820
821 /***********************************************************************
822 * NE_CreateSegments
823 */
824 BOOL NE_CreateSegments( NE_MODULE *pModule )
825 {
826 SEGTABLEENTRY *pSegment;
827 int i, minsize, seg_count;
828
829 assert( !(pModule->flags & NE_FFLAGS_WIN32) );
830
831 pSegment = NE_SEG_TABLE( pModule );
832
833 if (pModule->flags & NE_FFLAGS_SELFLOAD)
834 seg_count = 1;
835 else
836 seg_count = pModule->seg_count;
837 for (i = 1; i <= seg_count; i++, pSegment++)
838 {
839 minsize = pSegment->minsize ? pSegment->minsize : 0x10000;
840 if (i == pModule->ss) minsize += pModule->stack_size;
841 /* The DGROUP is allocated by NE_CreateInstance */
842 if (i == pModule->dgroup) continue;
843 pSegment->hSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSegment->flags),
844 minsize, pModule->self,
845 !(pSegment->flags & NE_SEGFLAGS_DATA),
846 (pSegment->flags & NE_SEGFLAGS_32BIT) != 0,
847 FALSE /*pSegment->flags & NE_SEGFLAGS_READONLY*/ );
848 if (!pSegment->hSeg) return FALSE;
849 pSegment->flags |= NE_SEGFLAGS_ALLOCATED;
850 }
851
852 pModule->dgroup_entry = pModule->dgroup ? pModule->seg_table +
853 (pModule->dgroup - 1) * sizeof(SEGTABLEENTRY) : 0;
854 return TRUE;
855 }
856
857
858 /**********************************************************************
859 * IsSharedSelector (KERNEL.345)
860 */
861 BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
862 {
863 /* Check whether the selector belongs to a DLL */
864 NE_MODULE *pModule = NE_GetPtr( selector );
865 if (!pModule) return FALSE;
866 return (pModule->flags & NE_FFLAGS_LIBMODULE) != 0;
867 }
Work in progress by Kai Blin