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
33 #include <sys/types.h>
35 #ifdef HAVE_SYS_MMAN_H
40 #include "wine/winbase16.h"
53 #include "debugtools.h"
55 DEFAULT_DEBUG_CHANNEL(win32
);
56 DECLARE_DEBUG_CHANNEL(delayhlp
);
57 DECLARE_DEBUG_CHANNEL(fixup
);
58 DECLARE_DEBUG_CHANNEL(module
);
59 DECLARE_DEBUG_CHANNEL(relay
);
60 DECLARE_DEBUG_CHANNEL(segment
);
63 static IMAGE_EXPORT_DIRECTORY
*get_exports( HMODULE hmod
)
65 IMAGE_EXPORT_DIRECTORY
*ret
= NULL
;
66 IMAGE_DATA_DIRECTORY
*dir
= PE_HEADER(hmod
)->OptionalHeader
.DataDirectory
67 + IMAGE_DIRECTORY_ENTRY_EXPORT
;
68 if (dir
->Size
&& dir
->VirtualAddress
)
69 ret
= (IMAGE_EXPORT_DIRECTORY
*)((char *)hmod
+ dir
->VirtualAddress
);
73 static IMAGE_IMPORT_DESCRIPTOR
*get_imports( HMODULE hmod
)
75 IMAGE_IMPORT_DESCRIPTOR
*ret
= NULL
;
76 IMAGE_DATA_DIRECTORY
*dir
= PE_HEADER(hmod
)->OptionalHeader
.DataDirectory
77 + IMAGE_DIRECTORY_ENTRY_IMPORT
;
78 if (dir
->Size
&& dir
->VirtualAddress
)
79 ret
= (IMAGE_IMPORT_DESCRIPTOR
*)((char *)hmod
+ dir
->VirtualAddress
);
84 /* convert PE image VirtualAddress to Real Address */
85 #define RVA(x) ((void *)((char *)load_addr+(unsigned int)(x)))
87 #define AdjustPtr(ptr,delta) ((char *)(ptr) + (delta))
89 void dump_exports( HMODULE hModule
)
94 u_long
*function
,*functions
;
96 unsigned int load_addr
= hModule
;
98 DWORD rva_start
= PE_HEADER(hModule
)->OptionalHeader
99 .DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
].VirtualAddress
;
100 DWORD rva_end
= rva_start
+ PE_HEADER(hModule
)->OptionalHeader
101 .DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
].Size
;
102 IMAGE_EXPORT_DIRECTORY
*pe_exports
= (IMAGE_EXPORT_DIRECTORY
*)RVA(rva_start
);
104 Module
= (char*)RVA(pe_exports
->Name
);
105 TRACE("*******EXPORT DATA*******\n");
106 TRACE("Module name is %s, %ld functions, %ld names\n",
107 Module
, pe_exports
->NumberOfFunctions
, pe_exports
->NumberOfNames
);
109 ordinal
=(u_short
*) RVA(pe_exports
->AddressOfNameOrdinals
);
110 functions
=function
=(u_long
*) RVA(pe_exports
->AddressOfFunctions
);
111 name
=(u_char
**) RVA(pe_exports
->AddressOfNames
);
113 TRACE(" Ord RVA Addr Name\n" );
114 for (i
=0;i
<pe_exports
->NumberOfFunctions
;i
++, function
++)
116 if (!*function
) continue; /* No such function */
119 DPRINTF( "%4ld %08lx %p", i
+ pe_exports
->Base
, *function
, RVA(*function
) );
120 /* Check if we have a name for it */
121 for (j
= 0; j
< pe_exports
->NumberOfNames
; j
++)
124 DPRINTF( " %s", (char*)RVA(name
[j
]) );
127 if ((*function
>= rva_start
) && (*function
<= rva_end
))
128 DPRINTF(" (forwarded -> %s)", (char *)RVA(*function
));
134 /* Look up the specified function or ordinal in the exportlist:
136 * - look up the name in the Name list.
137 * - look up the ordinal with that index.
138 * - use the ordinal as offset into the functionlist
139 * If it is a ordinal:
140 * - use ordinal-pe_export->Base as offset into the functionlist
142 static FARPROC
PE_FindExportedFunction(
143 WINE_MODREF
*wm
, /* [in] WINE modreference */
144 LPCSTR funcName
, /* [in] function name */
149 u_char
** name
, *ename
= NULL
;
151 unsigned int load_addr
= wm
->module
;
152 u_long rva_start
, rva_end
, addr
;
154 IMAGE_EXPORT_DIRECTORY
*exports
= get_exports(wm
->module
);
156 if (HIWORD(funcName
))
157 TRACE("(%s)\n",funcName
);
159 TRACE("(%d)\n",(int)funcName
);
161 /* Not a fatal problem, some apps do
162 * GetProcAddress(0,"RegisterPenApp") which triggers this
165 WARN("Module %08x(%s)/MODREF %p doesn't have a exports table.\n",wm
->module
,wm
->modname
,wm
);
168 ordinals
= (u_short
*) RVA(exports
->AddressOfNameOrdinals
);
169 function
= (u_long
*) RVA(exports
->AddressOfFunctions
);
170 name
= (u_char
**) RVA(exports
->AddressOfNames
);
172 rva_start
= PE_HEADER(wm
->module
)->OptionalHeader
173 .DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
].VirtualAddress
;
174 rva_end
= rva_start
+ PE_HEADER(wm
->module
)->OptionalHeader
175 .DataDirectory
[IMAGE_DIRECTORY_ENTRY_EXPORT
].Size
;
177 if (HIWORD(funcName
))
179 /* first try a binary search */
180 int min
= 0, max
= exports
->NumberOfNames
- 1;
183 int res
, pos
= (min
+ max
) / 2;
184 ename
= RVA(name
[pos
]);
185 if (!(res
= strcmp( ename
, funcName
)))
187 ordinal
= ordinals
[pos
];
190 if (res
> 0) max
= pos
- 1;
193 /* now try a linear search in case the names aren't sorted properly */
194 for (i
= 0; i
< exports
->NumberOfNames
; i
++)
196 ename
= RVA(name
[i
]);
197 if (!strcmp( ename
, funcName
))
199 ERR( "%s.%s required a linear search\n", wm
->modname
, funcName
);
200 ordinal
= ordinals
[i
];
206 else /* find by ordinal */
208 ordinal
= LOWORD(funcName
) - exports
->Base
;
209 if (snoop
&& name
) /* need to find a name for it */
211 for (i
= 0; i
< exports
->NumberOfNames
; i
++)
212 if (ordinals
[i
] == ordinal
)
214 ename
= RVA(name
[i
]);
221 if (ordinal
>= exports
->NumberOfFunctions
)
223 TRACE(" ordinal %ld out of range!\n", ordinal
+ exports
->Base
);
226 addr
= function
[ordinal
];
227 if (!addr
) return NULL
;
228 if ((addr
< rva_start
) || (addr
>= rva_end
))
230 FARPROC proc
= RVA(addr
);
233 if (!ename
) ename
= "@";
234 proc
= SNOOP_GetProcAddress(wm
->module
,ename
,ordinal
,proc
);
238 else /* forward entry point */
242 char *forward
= RVA(addr
);
244 char *end
= strchr(forward
, '.');
246 if (!end
) return NULL
;
247 if (end
- forward
>= sizeof(module
)) return NULL
;
248 memcpy( module
, forward
, end
- forward
);
249 module
[end
-forward
] = 0;
250 if (!(wm
= MODULE_FindModule( module
)))
252 ERR("module not found for forward '%s'\n", forward
);
255 if (!(proc
= MODULE_GetProcAddress( wm
->module
, end
+ 1, snoop
)))
256 ERR("function not found for forward '%s'\n", forward
);
261 DWORD
fixup_imports( WINE_MODREF
*wm
)
263 IMAGE_IMPORT_DESCRIPTOR
*pe_imp
;
264 unsigned int load_addr
= wm
->module
;
265 int i
,characteristics_detection
=1;
267 IMAGE_EXPORT_DIRECTORY
*exports
= get_exports(wm
->module
);
268 IMAGE_IMPORT_DESCRIPTOR
*imports
= get_imports(wm
->module
);
271 modname
= (char*) RVA(exports
->Name
);
273 modname
= "<unknown>";
275 /* first, count the number of imported non-internal modules */
277 if (!pe_imp
) return 0;
279 /* OK, now dump the import list */
280 TRACE("Dumping imports list\n");
282 /* We assume that we have at least one import with !0 characteristics and
283 * detect broken imports with all characteristics 0 (notably Borland) and
284 * switch the detection off for them.
286 for (i
= 0; pe_imp
->Name
; pe_imp
++) {
287 if (!i
&& !pe_imp
->u
.Characteristics
)
288 characteristics_detection
= 0;
289 if (characteristics_detection
&& !pe_imp
->u
.Characteristics
)
293 if (!i
) return 0; /* no imports */
295 /* Allocate module dependency list */
297 wm
->deps
= HeapAlloc( GetProcessHeap(), 0, i
*sizeof(WINE_MODREF
*) );
299 /* load the imported modules. They are automatically
300 * added to the modref list of the process.
303 for (i
= 0, pe_imp
= imports
; pe_imp
->Name
; pe_imp
++) {
305 IMAGE_IMPORT_BY_NAME
*pe_name
;
306 PIMAGE_THUNK_DATA import_list
,thunk_list
;
307 char *name
= (char *) RVA(pe_imp
->Name
);
309 if (characteristics_detection
&& !pe_imp
->u
.Characteristics
)
312 wmImp
= MODULE_LoadLibraryExA( name
, 0, 0 );
314 ERR_(module
)("Module (file) %s needed by %s not found\n", name
, wm
->filename
);
317 wm
->deps
[i
++] = wmImp
;
319 /* FIXME: forwarder entries ... */
321 if (pe_imp
->u
.OriginalFirstThunk
!= 0) { /* original MS style */
322 TRACE("Microsoft style imports used\n");
323 import_list
=(PIMAGE_THUNK_DATA
) RVA(pe_imp
->u
.OriginalFirstThunk
);
324 thunk_list
= (PIMAGE_THUNK_DATA
) RVA(pe_imp
->FirstThunk
);
326 while (import_list
->u1
.Ordinal
) {
327 if (IMAGE_SNAP_BY_ORDINAL(import_list
->u1
.Ordinal
)) {
328 int ordinal
= IMAGE_ORDINAL(import_list
->u1
.Ordinal
);
330 TRACE("--- Ordinal %s,%d\n", name
, ordinal
);
331 thunk_list
->u1
.Function
=MODULE_GetProcAddress(
332 wmImp
->module
, (LPCSTR
)ordinal
, TRUE
334 if (!thunk_list
->u1
.Function
) {
335 ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
337 thunk_list
->u1
.Function
= (FARPROC
)0xdeadbeef;
339 } else { /* import by name */
340 pe_name
= (PIMAGE_IMPORT_BY_NAME
)RVA(import_list
->u1
.AddressOfData
);
341 TRACE("--- %s %s.%d\n", pe_name
->Name
, name
, pe_name
->Hint
);
342 thunk_list
->u1
.Function
=MODULE_GetProcAddress(
343 wmImp
->module
, pe_name
->Name
, TRUE
345 if (!thunk_list
->u1
.Function
) {
346 ERR("No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
347 name
,pe_name
->Hint
,pe_name
->Name
);
348 thunk_list
->u1
.Function
= (FARPROC
)0xdeadbeef;
354 } else { /* Borland style */
355 TRACE("Borland style imports used\n");
356 thunk_list
= (PIMAGE_THUNK_DATA
) RVA(pe_imp
->FirstThunk
);
357 while (thunk_list
->u1
.Ordinal
) {
358 if (IMAGE_SNAP_BY_ORDINAL(thunk_list
->u1
.Ordinal
)) {
359 /* not sure about this branch, but it seems to work */
360 int ordinal
= IMAGE_ORDINAL(thunk_list
->u1
.Ordinal
);
362 TRACE("--- Ordinal %s.%d\n",name
,ordinal
);
363 thunk_list
->u1
.Function
=MODULE_GetProcAddress(
364 wmImp
->module
, (LPCSTR
) ordinal
, TRUE
366 if (!thunk_list
->u1
.Function
) {
367 ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
369 thunk_list
->u1
.Function
= (FARPROC
)0xdeadbeef;
372 pe_name
=(PIMAGE_IMPORT_BY_NAME
) RVA(thunk_list
->u1
.AddressOfData
);
373 TRACE("--- %s %s.%d\n",
374 pe_name
->Name
,name
,pe_name
->Hint
);
375 thunk_list
->u1
.Function
=MODULE_GetProcAddress(
376 wmImp
->module
, pe_name
->Name
, TRUE
378 if (!thunk_list
->u1
.Function
) {
379 ERR("No implementation for %s.%d, setting to 0xdeadbeef\n",
380 name
, pe_name
->Hint
);
381 thunk_list
->u1
.Function
= (FARPROC
)0xdeadbeef;
391 /***********************************************************************
394 * Apply the relocations to a mapped PE image
396 static int do_relocations( char *base
, const IMAGE_NT_HEADERS
*nt
, const char *filename
)
398 const IMAGE_DATA_DIRECTORY
*dir
;
399 const IMAGE_BASE_RELOCATION
*rel
;
400 int delta
= base
- (char *)nt
->OptionalHeader
.ImageBase
;
402 dir
= &nt
->OptionalHeader
.DataDirectory
[IMAGE_DIRECTORY_ENTRY_BASERELOC
];
403 rel
= (IMAGE_BASE_RELOCATION
*)(base
+ dir
->VirtualAddress
);
405 WARN("Info: base relocations needed for %s\n", filename
);
406 if (!dir
->VirtualAddress
|| !dir
->Size
)
408 if (nt
->OptionalHeader
.ImageBase
== 0x400000)
409 ERR("Standard load address for a Win32 program not available - patched kernel ?\n");
410 ERR( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
412 (nt
->FileHeader
.Characteristics
&IMAGE_FILE_RELOCS_STRIPPED
)?
413 "stripped during link" : "unknown reason" );
417 /* FIXME: If we need to relocate a system DLL (base > 2GB) we should
418 * really make sure that the *new* base address is also > 2GB.
419 * Some DLLs really check the MSB of the module handle :-/
421 if ((nt
->OptionalHeader
.ImageBase
& 0x80000000) && !((DWORD
)base
& 0x80000000))
422 ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
424 for ( ; ((char *)rel
< base
+ dir
->VirtualAddress
+ dir
->Size
) && rel
->VirtualAddress
;
425 rel
= (IMAGE_BASE_RELOCATION
*)((char*)rel
+ rel
->SizeOfBlock
))
427 char *page
= base
+ rel
->VirtualAddress
;
428 int i
, count
= (rel
->SizeOfBlock
- 8) / sizeof(rel
->TypeOffset
);
430 if (!count
) continue;
433 if ((char *)rel
+ rel
->SizeOfBlock
> base
+ dir
->VirtualAddress
+ dir
->Size
||
434 page
> base
+ nt
->OptionalHeader
.SizeOfImage
)
436 ERR_(module
)("invalid relocation %p,%lx,%ld at %p,%lx,%lx\n",
437 rel
, rel
->VirtualAddress
, rel
->SizeOfBlock
,
438 base
, dir
->VirtualAddress
, dir
->Size
);
442 TRACE_(module
)("%ld relocations for page %lx\n", rel
->SizeOfBlock
, rel
->VirtualAddress
);
444 /* patching in reverse order */
445 for (i
= 0 ; i
< count
; i
++)
447 int offset
= rel
->TypeOffset
[i
] & 0xFFF;
448 int type
= rel
->TypeOffset
[i
] >> 12;
451 case IMAGE_REL_BASED_ABSOLUTE
:
453 case IMAGE_REL_BASED_HIGH
:
454 *(short*)(page
+offset
) += HIWORD(delta
);
456 case IMAGE_REL_BASED_LOW
:
457 *(short*)(page
+offset
) += LOWORD(delta
);
459 case IMAGE_REL_BASED_HIGHLOW
:
460 *(int*)(page
+offset
) += delta
;
461 /* FIXME: if this is an exported address, fire up enhanced logic */
464 FIXME_(module
)("Unknown/unsupported fixup type %d.\n", type
);
473 /**********************************************************************
475 * Load one PE format DLL/EXE into memory
477 * Unluckily we can't just mmap the sections where we want them, for
478 * (at least) Linux does only support offsets which are page-aligned.
480 * BUT we have to map the whole image anyway, for Win32 programs sometimes
481 * want to access them. (HMODULE32 point to the start of it)
483 HMODULE
PE_LoadImage( HANDLE hFile
, LPCSTR filename
, DWORD flags
)
485 IMAGE_NT_HEADERS
*nt
;
490 TRACE_(module
)( "loading %s\n", filename
);
492 mapping
= CreateFileMappingA( hFile
, NULL
, SEC_IMAGE
, 0, 0, NULL
);
493 base
= MapViewOfFile( mapping
, FILE_MAP_READ
, 0, 0, 0 );
494 CloseHandle( mapping
);
497 hModule
= (HMODULE
)base
;
498 if (flags
& LOAD_LIBRARY_AS_DATAFILE
) return hModule
; /* nothing else to do */
500 /* perform base relocation, if necessary */
502 nt
= PE_HEADER( hModule
);
503 if (hModule
!= nt
->OptionalHeader
.ImageBase
)
505 if (!do_relocations( base
, nt
, filename
))
507 UnmapViewOfFile( base
);
508 SetLastError( ERROR_BAD_EXE_FORMAT
);
515 if (nt
->OptionalHeader
.AddressOfEntryPoint
)
518 IMAGE_SECTION_HEADER
*sec
= (IMAGE_SECTION_HEADER
*)((char*)&nt
->OptionalHeader
+
519 nt
->FileHeader
.SizeOfOptionalHeader
);
520 for (i
= 0; i
< nt
->FileHeader
.NumberOfSections
; i
++, sec
++)
522 if (nt
->OptionalHeader
.AddressOfEntryPoint
< sec
->VirtualAddress
)
524 if (nt
->OptionalHeader
.AddressOfEntryPoint
< sec
->VirtualAddress
+sec
->SizeOfRawData
)
527 if (i
== nt
->FileHeader
.NumberOfSections
)
528 MESSAGE("VIRUS WARNING: PE module has an invalid entrypoint (0x%08lx) "
529 "outside all sections (possibly infected by Tchernobyl/SpaceFiller virus)!\n",
530 nt
->OptionalHeader
.AddressOfEntryPoint
);
536 /**********************************************************************
539 * Create WINE_MODREF structure for loaded HMODULE32, link it into
540 * process modref_list, and fixup all imports.
542 * Note: hModule must point to a correctly allocated PE image,
543 * with base relocations applied; the 16-bit dummy module
544 * associated to hModule must already exist.
546 * Note: This routine must always be called in the context of the
547 * process that is to own the module to be created.
549 * Note: Assumes that the process critical section is held
551 WINE_MODREF
*PE_CreateModule( HMODULE hModule
, LPCSTR filename
, DWORD flags
,
552 HFILE hFile
, BOOL builtin
)
554 DWORD load_addr
= (DWORD
)hModule
; /* for RVA */
555 IMAGE_NT_HEADERS
*nt
= PE_HEADER(hModule
);
556 IMAGE_DATA_DIRECTORY
*dir
;
557 IMAGE_EXPORT_DIRECTORY
*pe_export
= NULL
;
561 /* Retrieve DataDirectory entries */
563 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_EXPORT
;
565 pe_export
= (PIMAGE_EXPORT_DIRECTORY
)RVA(dir
->VirtualAddress
);
567 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_EXCEPTION
;
568 if (dir
->Size
) FIXME("Exception directory ignored\n" );
570 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_SECURITY
;
571 if (dir
->Size
) FIXME("Security directory ignored\n" );
573 /* IMAGE_DIRECTORY_ENTRY_BASERELOC handled in PE_LoadImage */
574 /* IMAGE_DIRECTORY_ENTRY_DEBUG handled by debugger */
576 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_GLOBALPTR
;
577 if (dir
->Size
) FIXME("Global Pointer (MIPS) ignored\n" );
579 /* IMAGE_DIRECTORY_ENTRY_TLS handled in PE_TlsInit */
581 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG
;
582 if (dir
->Size
) FIXME("Load Configuration directory ignored\n" );
584 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT
;
585 if (dir
->Size
) TRACE("Bound Import directory ignored\n" );
587 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_IAT
;
588 if (dir
->Size
) TRACE("Import Address Table directory ignored\n" );
590 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
;
593 TRACE("Delayed import, stub calls LoadLibrary\n" );
595 * Nothing to do here.
600 * This code is useful to observe what the heck is going on.
603 ImgDelayDescr
*pe_delay
= NULL
;
604 pe_delay
= (PImgDelayDescr
)RVA(dir
->VirtualAddress
);
605 TRACE_(delayhlp
)("pe_delay->grAttrs = %08x\n", pe_delay
->grAttrs
);
606 TRACE_(delayhlp
)("pe_delay->szName = %s\n", pe_delay
->szName
);
607 TRACE_(delayhlp
)("pe_delay->phmod = %08x\n", pe_delay
->phmod
);
608 TRACE_(delayhlp
)("pe_delay->pIAT = %08x\n", pe_delay
->pIAT
);
609 TRACE_(delayhlp
)("pe_delay->pINT = %08x\n", pe_delay
->pINT
);
610 TRACE_(delayhlp
)("pe_delay->pBoundIAT = %08x\n", pe_delay
->pBoundIAT
);
611 TRACE_(delayhlp
)("pe_delay->pUnloadIAT = %08x\n", pe_delay
->pUnloadIAT
);
612 TRACE_(delayhlp
)("pe_delay->dwTimeStamp = %08x\n", pe_delay
->dwTimeStamp
);
614 #endif /* ImgDelayDescr */
617 dir
= nt
->OptionalHeader
.DataDirectory
+IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR
;
618 if (dir
->Size
) FIXME("Unknown directory 14 ignored\n" );
620 dir
= nt
->OptionalHeader
.DataDirectory
+15;
621 if (dir
->Size
) FIXME("Unknown directory 15 ignored\n" );
623 /* Create 16-bit dummy module */
625 if ((hModule16
= MODULE_CreateDummyModule( filename
, hModule
)) < 32)
627 SetLastError( (DWORD
)hModule16
); /* This should give the correct error */
631 /* Allocate and fill WINE_MODREF */
633 if (!(wm
= MODULE_AllocModRef( hModule
, filename
)))
635 FreeLibrary16( hModule16
);
641 NE_MODULE
*pModule
= (NE_MODULE
*)GlobalLock16( hModule16
);
642 pModule
->flags
|= NE_FFLAGS_BUILTIN
;
643 wm
->flags
|= WINE_MODREF_INTERNAL
;
646 if ( flags
& DONT_RESOLVE_DLL_REFERENCES
)
647 wm
->flags
|= WINE_MODREF_DONT_RESOLVE_REFS
;
649 wm
->find_export
= PE_FindExportedFunction
;
654 dump_exports( hModule
);
656 /* The exe_modref must be in place, before implicit linked DLLs are loaded
657 by fixup_imports, otherwhise GetModuleFileName will not work and modules
658 in the executables directory can not be found */
660 if (!(nt
->FileHeader
.Characteristics
& IMAGE_FILE_DLL
))
662 if ( PROCESS_Current()->exe_modref
)
663 FIXME( "Trying to load second .EXE file: %s\n", filename
);
666 PROCESS_Current()->exe_modref
= wm
;
667 PROCESS_Current()->module
= wm
->module
;
673 if (!(wm
->flags
& WINE_MODREF_DONT_RESOLVE_REFS
) && fixup_imports( wm
))
675 /* remove entry from modref chain */
678 PROCESS_Current()->modref_list
= wm
->next
;
680 wm
->prev
->next
= wm
->next
;
682 if ( wm
->next
) wm
->next
->prev
= wm
->prev
;
683 wm
->next
= wm
->prev
= NULL
;
685 /* FIXME: there are several more dangling references
686 * left. Including dlls loaded by this dll before the
687 * failed one. Unrolling is rather difficult with the
688 * current structure and we can leave it them lying
689 * around with no problems, so we don't care.
690 * As these might reference our wm, we don't free it.
696 SNOOP_RegisterDLL( hModule
, wm
->modname
, pe_export
->NumberOfFunctions
);
698 /* Send DLL load event */
699 /* we don't need to send a dll event for the main exe */
701 if (nt
->FileHeader
.Characteristics
& IMAGE_FILE_DLL
)
703 struct load_dll_request
*req
= get_req_buffer();
705 req
->base
= (void *)hModule
;
706 req
->dbg_offset
= nt
->FileHeader
.PointerToSymbolTable
;
707 req
->dbg_size
= nt
->FileHeader
.NumberOfSymbols
;
708 req
->name
= &wm
->filename
;
709 server_call_noerr( REQ_LOAD_DLL
);
715 /******************************************************************************
716 * The PE Library Loader frontend.
717 * FIXME: handle the flags.
719 WINE_MODREF
*PE_LoadLibraryExA (LPCSTR name
, DWORD flags
)
726 /* Search for and open PE file */
727 if ( SearchPathA( NULL
, name
, ".DLL",
728 sizeof(filename
), filename
, NULL
) == 0 ) return NULL
;
730 hFile
= CreateFileA( filename
, GENERIC_READ
, FILE_SHARE_READ
,
731 NULL
, OPEN_EXISTING
, 0, -1 );
732 if ( hFile
== INVALID_HANDLE_VALUE
) return NULL
;
735 hModule32
= PE_LoadImage( hFile
, filename
, flags
);
738 CloseHandle( hFile
);
742 /* Create 32-bit MODREF */
743 if ( !(wm
= PE_CreateModule( hModule32
, filename
, flags
, -1, FALSE
)) )
745 ERR( "can't load %s\n", filename
);
746 CloseHandle( hFile
);
747 SetLastError( ERROR_OUTOFMEMORY
);
751 CloseHandle( hFile
);
756 /* Called if the library is loaded or freed.
757 * NOTE: if a thread attaches a DLL, the current thread will only do
758 * DLL_PROCESS_ATTACH. Only new created threads do DLL_THREAD_ATTACH
761 typedef DWORD
CALLBACK(*DLLENTRYPROC
)(HMODULE
,DWORD
,LPVOID
);
763 BOOL
PE_InitDLL( HMODULE module
, DWORD type
, LPVOID lpReserved
)
766 IMAGE_NT_HEADERS
*nt
= PE_HEADER(module
);
768 /* Is this a library? And has it got an entrypoint? */
769 if ((nt
->FileHeader
.Characteristics
& IMAGE_FILE_DLL
) &&
770 (nt
->OptionalHeader
.AddressOfEntryPoint
))
772 DLLENTRYPROC entry
= (void*)((char*)module
+ nt
->OptionalHeader
.AddressOfEntryPoint
);
773 TRACE_(relay
)("CallTo32(entryproc=%p,module=%08x,type=%ld,res=%p)\n",
774 entry
, module
, type
, lpReserved
);
776 retv
= entry( module
, type
, lpReserved
);
782 /************************************************************************
783 * PE_InitTls (internal)
785 * If included, initialises the thread local storages of modules.
786 * Pointers in those structs are not RVAs but real pointers which have been
787 * relocated by do_relocations() already.
790 _fixup_address(PIMAGE_OPTIONAL_HEADER opt
,int delta
,LPVOID addr
) {
791 if ( ((DWORD
)addr
>opt
->ImageBase
) &&
792 ((DWORD
)addr
<opt
->ImageBase
+opt
->SizeOfImage
)
794 /* the address has not been relocated! */
795 return (LPVOID
)(((DWORD
)addr
)+delta
);
797 /* the address has been relocated already */
800 void PE_InitTls( void )
803 IMAGE_NT_HEADERS
*peh
;
806 PIMAGE_TLS_DIRECTORY pdir
;
809 for (wm
= PROCESS_Current()->modref_list
;wm
;wm
=wm
->next
) {
810 peh
= PE_HEADER(wm
->module
);
811 delta
= wm
->module
- peh
->OptionalHeader
.ImageBase
;
812 if (!peh
->OptionalHeader
.DataDirectory
[IMAGE_FILE_THREAD_LOCAL_STORAGE
].VirtualAddress
)
814 pdir
= (LPVOID
)(wm
->module
+ peh
->OptionalHeader
.
815 DataDirectory
[IMAGE_FILE_THREAD_LOCAL_STORAGE
].VirtualAddress
);
818 if ( wm
->tlsindex
== -1 ) {
820 wm
->tlsindex
= TlsAlloc();
821 xaddr
= _fixup_address(&(peh
->OptionalHeader
),delta
,
826 datasize
= pdir
->EndAddressOfRawData
-pdir
->StartAddressOfRawData
;
827 size
= datasize
+ pdir
->SizeOfZeroFill
;
828 mem
=VirtualAlloc(0,size
,MEM_RESERVE
|MEM_COMMIT
,PAGE_READWRITE
);
829 memcpy(mem
,_fixup_address(&(peh
->OptionalHeader
),delta
,(LPVOID
)pdir
->StartAddressOfRawData
),datasize
);
830 if (pdir
->AddressOfCallBacks
) {
831 PIMAGE_TLS_CALLBACK
*cbs
;
833 cbs
= _fixup_address(&(peh
->OptionalHeader
),delta
,pdir
->AddressOfCallBacks
);
835 FIXME("TLS Callbacks aren't going to be called\n");
838 TlsSetValue( wm
->tlsindex
, mem
);