2 * Copyright 1994 Eric Youndale & Erik Bos
3 * Copyright 1995 Martin von Löwis
4 * Copyright 1996-98 Marcus Meissner
6 * based on Eric Youndale's pe-test and:
8 * ftp.microsoft.com:/pub/developer/MSDN/CD8/PEFILE.ZIP
10 * ftp.microsoft.com:/developr/MSDN/OctCD/PEFILE.ZIP
13 * Before you start changing something in this file be aware of the following:
15 * - There are several functions called recursively. In a very subtle and
16 * obscure way. DLLs can reference each other recursively etc.
17 * - If you want to enhance, speed up or clean up something in here, think
18 * twice WHY it is implemented in that strange way. There is usually a reason.
19 * Though sometimes it might just be lazyness ;)
20 * - In PE_MapImage, right before fixup_imports() all external and internal
21 * state MUST be correct since this function can be called with the SAME image
22 * AGAIN. (Thats recursion for you.) That means MODREF.module and
28 #include <sys/types.h>
29 #ifdef HAVE_SYS_MMAN_H
32 #include "wine/winbase16.h"
37 #include "debugtools.h"
39 DEFAULT_DEBUG_CHANNEL(win32);
40 DECLARE_DEBUG_CHANNEL(delayhlp);
41 DECLARE_DEBUG_CHANNEL(fixup);
42 DECLARE_DEBUG_CHANNEL(module);
43 DECLARE_DEBUG_CHANNEL(relay);
44 DECLARE_DEBUG_CHANNEL(segment);
47 static IMAGE_EXPORT_DIRECTORY *get_exports( HMODULE hmod )
49 IMAGE_EXPORT_DIRECTORY *ret = NULL;
50 IMAGE_DATA_DIRECTORY *dir = PE_HEADER(hmod)->OptionalHeader.DataDirectory
51 + IMAGE_DIRECTORY_ENTRY_EXPORT;
52 if (dir->Size && dir->VirtualAddress)
53 ret = (IMAGE_EXPORT_DIRECTORY *)((char *)hmod + dir->VirtualAddress);
57 static IMAGE_IMPORT_DESCRIPTOR *get_imports( HMODULE hmod )
59 IMAGE_IMPORT_DESCRIPTOR *ret = NULL;
60 IMAGE_DATA_DIRECTORY *dir = PE_HEADER(hmod)->OptionalHeader.DataDirectory
61 + IMAGE_DIRECTORY_ENTRY_IMPORT;
62 if (dir->Size && dir->VirtualAddress)
63 ret = (IMAGE_IMPORT_DESCRIPTOR *)((char *)hmod + dir->VirtualAddress);
68 /* convert PE image VirtualAddress to Real Address */
69 #define RVA(x) ((void *)((char *)load_addr+(unsigned int)(x)))
71 #define AdjustPtr(ptr,delta) ((char *)(ptr) + (delta))
73 void dump_exports( HMODULE hModule )
78 DWORD *function,*functions;
80 unsigned int load_addr = hModule;
82 DWORD rva_start = PE_HEADER(hModule)->OptionalHeader
83 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
84 DWORD rva_end = rva_start + PE_HEADER(hModule)->OptionalHeader
85 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
86 IMAGE_EXPORT_DIRECTORY *pe_exports = (IMAGE_EXPORT_DIRECTORY*)RVA(rva_start);
88 Module = (char*)RVA(pe_exports->Name);
89 TRACE("*******EXPORT DATA*******\n");
90 TRACE("Module name is %s, %ld functions, %ld names\n",
91 Module, pe_exports->NumberOfFunctions, pe_exports->NumberOfNames);
93 ordinal = RVA(pe_exports->AddressOfNameOrdinals);
94 functions = function = RVA(pe_exports->AddressOfFunctions);
95 name = RVA(pe_exports->AddressOfNames);
97 TRACE(" Ord RVA Addr Name\n" );
98 for (i=0;i<pe_exports->NumberOfFunctions;i++, function++)
100 if (!*function) continue; /* No such function */
103 DPRINTF( "%4ld %08lx %p", i + pe_exports->Base, *function, RVA(*function) );
104 /* Check if we have a name for it */
105 for (j = 0; j < pe_exports->NumberOfNames; j++)
108 DPRINTF( " %s", (char*)RVA(name[j]) );
111 if ((*function >= rva_start) && (*function <= rva_end))
112 DPRINTF(" (forwarded -> %s)", (char *)RVA(*function));
118 /* Look up the specified function or ordinal in the exportlist:
120 * - look up the name in the Name list.
121 * - look up the ordinal with that index.
122 * - use the ordinal as offset into the functionlist
123 * If it is a ordinal:
124 * - use ordinal-pe_export->Base as offset into the functionlist
126 static FARPROC PE_FindExportedFunction(
127 WINE_MODREF *wm, /* [in] WINE modreference */
128 LPCSTR funcName, /* [in] function name */
133 BYTE ** name, *ename = NULL;
135 unsigned int load_addr = wm->module;
136 DWORD rva_start, rva_end, addr;
138 IMAGE_EXPORT_DIRECTORY *exports = get_exports(wm->module);
140 if (HIWORD(funcName))
141 TRACE("(%s)\n",funcName);
143 TRACE("(%d)\n",(int)funcName);
145 /* Not a fatal problem, some apps do
146 * GetProcAddress(0,"RegisterPenApp") which triggers this
149 WARN("Module %08x(%s)/MODREF %p doesn't have a exports table.\n",wm->module,wm->modname,wm);
152 ordinals= RVA(exports->AddressOfNameOrdinals);
153 function= RVA(exports->AddressOfFunctions);
154 name = RVA(exports->AddressOfNames);
156 rva_start = PE_HEADER(wm->module)->OptionalHeader
157 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
158 rva_end = rva_start + PE_HEADER(wm->module)->OptionalHeader
159 .DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
161 if (HIWORD(funcName))
163 /* first try a binary search */
164 int min = 0, max = exports->NumberOfNames - 1;
167 int res, pos = (min + max) / 2;
168 ename = RVA(name[pos]);
169 if (!(res = strcmp( ename, funcName )))
171 ordinal = ordinals[pos];
174 if (res > 0) max = pos - 1;
177 /* now try a linear search in case the names aren't sorted properly */
178 for (i = 0; i < exports->NumberOfNames; i++)
180 ename = RVA(name[i]);
181 if (!strcmp( ename, funcName ))
183 ERR( "%s.%s required a linear search\n", wm->modname, funcName );
184 ordinal = ordinals[i];
190 else /* find by ordinal */
192 ordinal = LOWORD(funcName) - exports->Base;
193 if (snoop && name) /* need to find a name for it */
195 for (i = 0; i < exports->NumberOfNames; i++)
196 if (ordinals[i] == ordinal)
198 ename = RVA(name[i]);
205 if (ordinal >= exports->NumberOfFunctions)
207 TRACE(" ordinal %ld out of range!\n", ordinal + exports->Base );
210 addr = function[ordinal];
211 if (!addr) return NULL;
212 if ((addr < rva_start) || (addr >= rva_end))
214 FARPROC proc = RVA(addr);
217 if (!ename) ename = "@";
218 proc = SNOOP_GetProcAddress(wm->module,ename,ordinal,proc);
222 else /* forward entry point */
226 char *forward = RVA(addr);
228 char *end = strchr(forward, '.');
230 if (!end) return NULL;
231 if (end - forward >= sizeof(module)) return NULL;
232 memcpy( module, forward, end - forward );
233 module[end-forward] = 0;
234 if (!(wm = MODULE_FindModule( module )))
236 ERR("module not found for forward '%s'\n", forward );
239 if (!(proc = MODULE_GetProcAddress( wm->module, end + 1, snoop )))
240 ERR("function not found for forward '%s'\n", forward );
245 DWORD fixup_imports( WINE_MODREF *wm )
247 IMAGE_IMPORT_DESCRIPTOR *pe_imp;
248 unsigned int load_addr = wm->module;
249 int i,characteristics_detection=1;
251 IMAGE_EXPORT_DIRECTORY *exports = get_exports(wm->module);
252 IMAGE_IMPORT_DESCRIPTOR *imports = get_imports(wm->module);
255 modname = (char*) RVA(exports->Name);
257 modname = "<unknown>";
259 /* first, count the number of imported non-internal modules */
261 if (!pe_imp) return 0;
263 /* OK, now dump the import list */
264 TRACE("Dumping imports list\n");
266 /* We assume that we have at least one import with !0 characteristics and
267 * detect broken imports with all characteristics 0 (notably Borland) and
268 * switch the detection off for them.
270 for (i = 0; pe_imp->Name ; pe_imp++) {
271 if (!i && !pe_imp->u.Characteristics)
272 characteristics_detection = 0;
273 if (characteristics_detection && !pe_imp->u.Characteristics)
277 if (!i) return 0; /* no imports */
279 /* Allocate module dependency list */
281 wm->deps = HeapAlloc( GetProcessHeap(), 0, i*sizeof(WINE_MODREF *) );
283 /* load the imported modules. They are automatically
284 * added to the modref list of the process.
287 for (i = 0, pe_imp = imports; pe_imp->Name ; pe_imp++) {
289 IMAGE_IMPORT_BY_NAME *pe_name;
290 PIMAGE_THUNK_DATA import_list,thunk_list;
291 char *name = (char *) RVA(pe_imp->Name);
293 if (characteristics_detection && !pe_imp->u.Characteristics)
296 wmImp = MODULE_LoadLibraryExA( name, 0, 0 );
298 ERR_(module)("Module (file) %s needed by %s not found\n", name, wm->filename);
301 wm->deps[i++] = wmImp;
303 /* FIXME: forwarder entries ... */
305 if (pe_imp->u.OriginalFirstThunk != 0) { /* original MS style */
306 TRACE("Microsoft style imports used\n");
307 import_list =(PIMAGE_THUNK_DATA) RVA(pe_imp->u.OriginalFirstThunk);
308 thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
310 while (import_list->u1.Ordinal) {
311 if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal)) {
312 int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
314 TRACE("--- Ordinal %s,%d\n", name, ordinal);
315 thunk_list->u1.Function=MODULE_GetProcAddress(
316 wmImp->module, (LPCSTR)ordinal, TRUE
318 if (!thunk_list->u1.Function) {
319 ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
321 thunk_list->u1.Function = (FARPROC)0xdeadbeef;
323 } else { /* import by name */
324 pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
325 TRACE("--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
326 thunk_list->u1.Function=MODULE_GetProcAddress(
327 wmImp->module, pe_name->Name, TRUE
329 if (!thunk_list->u1.Function) {
330 ERR("No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
331 name,pe_name->Hint,pe_name->Name);
332 thunk_list->u1.Function = (FARPROC)0xdeadbeef;
338 } else { /* Borland style */
339 TRACE("Borland style imports used\n");
340 thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
341 while (thunk_list->u1.Ordinal) {
342 if (IMAGE_SNAP_BY_ORDINAL(thunk_list->u1.Ordinal)) {
343 /* not sure about this branch, but it seems to work */
344 int ordinal = IMAGE_ORDINAL(thunk_list->u1.Ordinal);
346 TRACE("--- Ordinal %s.%d\n",name,ordinal);
347 thunk_list->u1.Function=MODULE_GetProcAddress(
348 wmImp->module, (LPCSTR) ordinal, TRUE
350 if (!thunk_list->u1.Function) {
351 ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
353 thunk_list->u1.Function = (FARPROC)0xdeadbeef;
356 pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
357 TRACE("--- %s %s.%d\n",
358 pe_name->Name,name,pe_name->Hint);
359 thunk_list->u1.Function=MODULE_GetProcAddress(
360 wmImp->module, pe_name->Name, TRUE
362 if (!thunk_list->u1.Function) {
363 ERR("No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
364 name, pe_name->Hint, pe_name->Name);
365 thunk_list->u1.Function = (FARPROC)0xdeadbeef;
375 /***********************************************************************
378 * Apply the relocations to a mapped PE image
380 static int do_relocations( char *base, const IMAGE_NT_HEADERS *nt, const char *filename )
382 const IMAGE_DATA_DIRECTORY *dir;
383 const IMAGE_BASE_RELOCATION *rel;
384 int delta = base - (char *)nt->OptionalHeader.ImageBase;
386 dir = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
387 rel = (IMAGE_BASE_RELOCATION *)(base + dir->VirtualAddress);
389 WARN("Info: base relocations needed for %s\n", filename);
390 if (!dir->VirtualAddress || !dir->Size)
392 if (nt->OptionalHeader.ImageBase == 0x400000)
393 ERR("Standard load address for a Win32 program not available - patched kernel ?\n");
394 ERR( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
396 (nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)?
397 "stripped during link" : "unknown reason" );
401 /* FIXME: If we need to relocate a system DLL (base > 2GB) we should
402 * really make sure that the *new* base address is also > 2GB.
403 * Some DLLs really check the MSB of the module handle :-/
405 if ((nt->OptionalHeader.ImageBase & 0x80000000) && !((DWORD)base & 0x80000000))
406 ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
408 for ( ; ((char *)rel < base + dir->VirtualAddress + dir->Size) && rel->VirtualAddress;
409 rel = (IMAGE_BASE_RELOCATION*)((char*)rel + rel->SizeOfBlock))
411 char *page = base + rel->VirtualAddress;
412 int i, count = (rel->SizeOfBlock - 8) / sizeof(rel->TypeOffset);
414 if (!count) continue;
417 if ((char *)rel + rel->SizeOfBlock > base + dir->VirtualAddress + dir->Size ||
418 page > base + nt->OptionalHeader.SizeOfImage)
420 ERR_(module)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
421 rel, rel->VirtualAddress, rel->SizeOfBlock,
422 base, dir->VirtualAddress, dir->Size );
426 TRACE_(module)("%ld relocations for page %lx\n", rel->SizeOfBlock, rel->VirtualAddress);
428 /* patching in reverse order */
429 for (i = 0 ; i < count; i++)
431 int offset = rel->TypeOffset[i] & 0xFFF;
432 int type = rel->TypeOffset[i] >> 12;
435 case IMAGE_REL_BASED_ABSOLUTE:
437 case IMAGE_REL_BASED_HIGH:
438 *(short*)(page+offset) += HIWORD(delta);
440 case IMAGE_REL_BASED_LOW:
441 *(short*)(page+offset) += LOWORD(delta);
443 case IMAGE_REL_BASED_HIGHLOW:
444 *(int*)(page+offset) += delta;
445 /* FIXME: if this is an exported address, fire up enhanced logic */
448 FIXME_(module)("Unknown/unsupported fixup type %d.\n", type);
457 /**********************************************************************
459 * Load one PE format DLL/EXE into memory
461 * Unluckily we can't just mmap the sections where we want them, for
462 * (at least) Linux does only support offsets which are page-aligned.
464 * BUT we have to map the whole image anyway, for Win32 programs sometimes
465 * want to access them. (HMODULE32 point to the start of it)
467 HMODULE PE_LoadImage( HANDLE hFile, LPCSTR filename, DWORD flags )
469 IMAGE_NT_HEADERS *nt;
474 TRACE_(module)( "loading %s\n", filename );
476 mapping = CreateFileMappingA( hFile, NULL, SEC_IMAGE, 0, 0, NULL );
477 if (!mapping) return 0;
478 base = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
479 CloseHandle( mapping );
482 hModule = (HMODULE)base;
483 if (flags & LOAD_LIBRARY_AS_DATAFILE) return hModule; /* nothing else to do */
485 /* perform base relocation, if necessary */
487 nt = PE_HEADER( hModule );
488 if (hModule != nt->OptionalHeader.ImageBase)
490 if (!do_relocations( base, nt, filename ))
492 UnmapViewOfFile( base );
493 SetLastError( ERROR_BAD_EXE_FORMAT );
500 if (nt->OptionalHeader.AddressOfEntryPoint)
503 IMAGE_SECTION_HEADER *sec = (IMAGE_SECTION_HEADER*)((char*)&nt->OptionalHeader +
504 nt->FileHeader.SizeOfOptionalHeader);
505 for (i = 0; i < nt->FileHeader.NumberOfSections; i++, sec++)
507 if (nt->OptionalHeader.AddressOfEntryPoint < sec->VirtualAddress)
509 if (nt->OptionalHeader.AddressOfEntryPoint < sec->VirtualAddress+sec->SizeOfRawData)
512 if (i == nt->FileHeader.NumberOfSections)
513 MESSAGE("VIRUS WARNING: PE module has an invalid entrypoint (0x%08lx) "
514 "outside all sections (possibly infected by Tchernobyl/SpaceFiller virus)!\n",
515 nt->OptionalHeader.AddressOfEntryPoint );
521 /**********************************************************************
524 * Create WINE_MODREF structure for loaded HMODULE32, link it into
525 * process modref_list, and fixup all imports.
527 * Note: hModule must point to a correctly allocated PE image,
528 * with base relocations applied; the 16-bit dummy module
529 * associated to hModule must already exist.
531 * Note: This routine must always be called in the context of the
532 * process that is to own the module to be created.
534 * Note: Assumes that the process critical section is held
536 WINE_MODREF *PE_CreateModule( HMODULE hModule, LPCSTR filename, DWORD flags,
537 HFILE hFile, BOOL builtin )
539 DWORD load_addr = (DWORD)hModule; /* for RVA */
540 IMAGE_NT_HEADERS *nt = PE_HEADER(hModule);
541 IMAGE_DATA_DIRECTORY *dir;
542 IMAGE_EXPORT_DIRECTORY *pe_export = NULL;
546 /* Retrieve DataDirectory entries */
548 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_EXPORT;
550 pe_export = (PIMAGE_EXPORT_DIRECTORY)RVA(dir->VirtualAddress);
552 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_EXCEPTION;
553 if (dir->Size) FIXME("Exception directory ignored\n" );
555 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_SECURITY;
556 if (dir->Size) FIXME("Security directory ignored\n" );
558 /* IMAGE_DIRECTORY_ENTRY_BASERELOC handled in PE_LoadImage */
559 /* IMAGE_DIRECTORY_ENTRY_DEBUG handled by debugger */
561 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_GLOBALPTR;
562 if (dir->Size) FIXME("Global Pointer (MIPS) ignored\n" );
564 /* IMAGE_DIRECTORY_ENTRY_TLS handled in PE_TlsInit */
566 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG;
567 if (dir->Size) FIXME("Load Configuration directory ignored\n" );
569 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT;
570 if (dir->Size) TRACE("Bound Import directory ignored\n" );
572 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_IAT;
573 if (dir->Size) TRACE("Import Address Table directory ignored\n" );
575 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT;
578 TRACE("Delayed import, stub calls LoadLibrary\n" );
580 * Nothing to do here.
585 * This code is useful to observe what the heck is going on.
588 ImgDelayDescr *pe_delay = NULL;
589 pe_delay = (PImgDelayDescr)RVA(dir->VirtualAddress);
590 TRACE_(delayhlp)("pe_delay->grAttrs = %08x\n", pe_delay->grAttrs);
591 TRACE_(delayhlp)("pe_delay->szName = %s\n", pe_delay->szName);
592 TRACE_(delayhlp)("pe_delay->phmod = %08x\n", pe_delay->phmod);
593 TRACE_(delayhlp)("pe_delay->pIAT = %08x\n", pe_delay->pIAT);
594 TRACE_(delayhlp)("pe_delay->pINT = %08x\n", pe_delay->pINT);
595 TRACE_(delayhlp)("pe_delay->pBoundIAT = %08x\n", pe_delay->pBoundIAT);
596 TRACE_(delayhlp)("pe_delay->pUnloadIAT = %08x\n", pe_delay->pUnloadIAT);
597 TRACE_(delayhlp)("pe_delay->dwTimeStamp = %08x\n", pe_delay->dwTimeStamp);
599 #endif /* ImgDelayDescr */
602 dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR;
603 if (dir->Size) FIXME("Unknown directory 14 ignored\n" );
605 dir = nt->OptionalHeader.DataDirectory+15;
606 if (dir->Size) FIXME("Unknown directory 15 ignored\n" );
608 /* Create 16-bit dummy module */
610 if ((hModule16 = MODULE_CreateDummyModule( filename, hModule )) < 32)
612 SetLastError( (DWORD)hModule16 ); /* This should give the correct error */
616 /* Allocate and fill WINE_MODREF */
618 if (!(wm = MODULE_AllocModRef( hModule, filename )))
620 FreeLibrary16( hModule16 );
623 wm->hDummyMod = hModule16;
627 NE_MODULE *pModule = (NE_MODULE *)GlobalLock16( hModule16 );
628 pModule->flags |= NE_FFLAGS_BUILTIN;
629 wm->flags |= WINE_MODREF_INTERNAL;
632 if ( flags & DONT_RESOLVE_DLL_REFERENCES )
633 wm->flags |= WINE_MODREF_DONT_RESOLVE_REFS;
635 wm->find_export = PE_FindExportedFunction;
640 dump_exports( hModule );
642 /* The exe_modref must be in place, before implicit linked DLLs are loaded
643 by fixup_imports, otherwhise GetModuleFileName will not work and modules
644 in the executables directory can not be found */
646 if (!(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
648 if ( PROCESS_Current()->exe_modref )
649 FIXME( "Trying to load second .EXE file: %s\n", filename );
652 PROCESS_Current()->exe_modref = wm;
653 PROCESS_Current()->module = wm->module;
659 if (!(wm->flags & WINE_MODREF_DONT_RESOLVE_REFS) && fixup_imports( wm ))
661 /* remove entry from modref chain */
664 PROCESS_Current()->modref_list = wm->next;
666 wm->prev->next = wm->next;
668 if ( wm->next ) wm->next->prev = wm->prev;
669 wm->next = wm->prev = NULL;
671 /* FIXME: there are several more dangling references
672 * left. Including dlls loaded by this dll before the
673 * failed one. Unrolling is rather difficult with the
674 * current structure and we can leave it them lying
675 * around with no problems, so we don't care.
676 * As these might reference our wm, we don't free it.
682 SNOOP_RegisterDLL( hModule, wm->modname, pe_export->NumberOfFunctions );
684 /* Send DLL load event */
685 /* we don't need to send a dll event for the main exe */
687 if (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)
691 struct load_dll_request *req = server_alloc_req( sizeof(*req), 0 );
693 req->base = (void *)hModule;
694 req->dbg_offset = nt->FileHeader.PointerToSymbolTable;
695 req->dbg_size = nt->FileHeader.NumberOfSymbols;
696 req->name = &wm->filename;
697 server_call_noerr( REQ_LOAD_DLL );
705 /******************************************************************************
706 * The PE Library Loader frontend.
707 * FIXME: handle the flags.
709 WINE_MODREF *PE_LoadLibraryExA (LPCSTR name, DWORD flags)
715 hFile = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
716 NULL, OPEN_EXISTING, 0, -1 );
717 if ( hFile == INVALID_HANDLE_VALUE ) return NULL;
720 hModule32 = PE_LoadImage( hFile, name, flags );
723 CloseHandle( hFile );
727 /* Create 32-bit MODREF */
728 if ( !(wm = PE_CreateModule( hModule32, name, flags, hFile, FALSE )) )
730 ERR( "can't load %s\n", name );
731 CloseHandle( hFile );
732 SetLastError( ERROR_OUTOFMEMORY );
736 CloseHandle( hFile );
741 /* Called if the library is loaded or freed.
742 * NOTE: if a thread attaches a DLL, the current thread will only do
743 * DLL_PROCESS_ATTACH. Only new created threads do DLL_THREAD_ATTACH
746 typedef DWORD CALLBACK(*DLLENTRYPROC)(HMODULE,DWORD,LPVOID);
748 BOOL PE_InitDLL( HMODULE module, DWORD type, LPVOID lpReserved )
751 IMAGE_NT_HEADERS *nt = PE_HEADER(module);
753 /* Is this a library? And has it got an entrypoint? */
754 if ((nt->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
755 (nt->OptionalHeader.AddressOfEntryPoint))
757 DLLENTRYPROC entry = (void*)((char*)module + nt->OptionalHeader.AddressOfEntryPoint);
758 TRACE_(relay)("CallTo32(entryproc=%p,module=%08x,type=%ld,res=%p)\n",
759 entry, module, type, lpReserved );
761 retv = entry( module, type, lpReserved );
767 /************************************************************************
768 * PE_InitTls (internal)
770 * If included, initialises the thread local storages of modules.
771 * Pointers in those structs are not RVAs but real pointers which have been
772 * relocated by do_relocations() already.
775 _fixup_address(PIMAGE_OPTIONAL_HEADER opt,int delta,LPVOID addr) {
776 if ( ((DWORD)addr>opt->ImageBase) &&
777 ((DWORD)addr<opt->ImageBase+opt->SizeOfImage)
779 /* the address has not been relocated! */
780 return (LPVOID)(((DWORD)addr)+delta);
782 /* the address has been relocated already */
785 void PE_InitTls( void )
788 IMAGE_NT_HEADERS *peh;
791 PIMAGE_TLS_DIRECTORY pdir;
794 for (wm = PROCESS_Current()->modref_list;wm;wm=wm->next) {
795 peh = PE_HEADER(wm->module);
796 delta = wm->module - peh->OptionalHeader.ImageBase;
797 if (!peh->OptionalHeader.DataDirectory[IMAGE_FILE_THREAD_LOCAL_STORAGE].VirtualAddress)
799 pdir = (LPVOID)(wm->module + peh->OptionalHeader.
800 DataDirectory[IMAGE_FILE_THREAD_LOCAL_STORAGE].VirtualAddress);
803 if ( wm->tlsindex == -1 ) {
805 wm->tlsindex = TlsAlloc();
806 xaddr = _fixup_address(&(peh->OptionalHeader),delta,
811 datasize= pdir->EndAddressOfRawData-pdir->StartAddressOfRawData;
812 size = datasize + pdir->SizeOfZeroFill;
813 mem=VirtualAlloc(0,size,MEM_RESERVE|MEM_COMMIT,PAGE_READWRITE);
814 memcpy(mem,_fixup_address(&(peh->OptionalHeader),delta,(LPVOID)pdir->StartAddressOfRawData),datasize);
815 if (pdir->AddressOfCallBacks) {
816 PIMAGE_TLS_CALLBACK *cbs;
818 cbs = _fixup_address(&(peh->OptionalHeader),delta,pdir->AddressOfCallBacks);
820 FIXME("TLS Callbacks aren't going to be called\n");
823 TlsSetValue( wm->tlsindex, mem );