?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 480b0ab11d721a21c8618d4f9374bf7a3008a5c8
[wine/hacks.git] / dlls / dbghelp / pe_module.c
blob2937013feeb6cc8bacf5eb015c95d85b0b5a368d
1 /*
2 * File pe_module.c - handle PE module information
3 *
4 * Copyright (C) 1996, Eric Youngdale.
5 * Copyright (C) 1999-2000, Ulrich Weigand.
6 * Copyright (C) 2004-2007, Eric Pouech.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <assert.h>
31
32 #include "dbghelp_private.h"
33 #include "winternl.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
37
38 /******************************************************************
39 * pe_load_symbol_table
40 *
41 * Use the COFF symbol table (if any) from the IMAGE_FILE_HEADER to set the absolute address
42 * of global symbols.
43 * Mingw32 requires this for stabs debug information as address for global variables isn't filled in
44 * (this is similar to what is done in elf_module.c when using the .symtab ELF section)
45 */
46 static BOOL pe_load_symbol_table(struct module* module, IMAGE_NT_HEADERS* nth, void* mapping)
47 {
48 const IMAGE_SYMBOL* isym;
49 int i, numsym, naux;
50 const char* strtable;
51 char tmp[9];
52 const char* name;
53 struct hash_table_iter hti;
54 void* ptr;
55 struct symt_data* sym;
56 const IMAGE_SECTION_HEADER* sect;
57
58 numsym = nth->FileHeader.NumberOfSymbols;
59 if (!nth->FileHeader.PointerToSymbolTable || !numsym)
60 return TRUE;
61 isym = (const IMAGE_SYMBOL*)((char*)mapping + nth->FileHeader.PointerToSymbolTable);
62 /* FIXME: no way to get strtable size */
63 strtable = (const char*)&isym[numsym];
64 sect = IMAGE_FIRST_SECTION(nth);
65
66 for (i = 0; i < numsym; i+= naux, isym += naux)
67 {
68 if (isym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
69 isym->SectionNumber > 0 && isym->SectionNumber <= nth->FileHeader.NumberOfSections)
70 {
71 if (isym->N.Name.Short)
72 {
73 name = memcpy(tmp, isym->N.ShortName, 8);
74 tmp[8] = '\0';
75 }
76 else name = strtable + isym->N.Name.Long;
77 if (name[0] == '_') name++;
78 hash_table_iter_init(&module->ht_symbols, &hti, name);
79 while ((ptr = hash_table_iter_up(&hti)))
80 {
81 sym = GET_ENTRY(ptr, struct symt_data, hash_elt);
82 if (sym->symt.tag == SymTagData &&
83 (sym->kind == DataIsGlobal || sym->kind == DataIsFileStatic) &&
84 !strcmp(sym->hash_elt.name, name))
85 {
86 TRACE("Changing absolute address for %d.%s: %lx -> %s\n",
87 isym->SectionNumber, name, sym->u.var.offset,
88 wine_dbgstr_longlong(module->module.BaseOfImage +
89 sect[isym->SectionNumber - 1].VirtualAddress + isym->Value));
90 sym->u.var.offset = module->module.BaseOfImage +
91 sect[isym->SectionNumber - 1].VirtualAddress + isym->Value;
92 break;
93 }
94 }
95 }
96 naux = isym->NumberOfAuxSymbols + 1;
97 }
98 return TRUE;
99 }
100
101 static inline void* pe_get_sect(IMAGE_NT_HEADERS* nth, void* mapping,
102 IMAGE_SECTION_HEADER* sect)
103 {
104 return (sect) ? RtlImageRvaToVa(nth, mapping, sect->VirtualAddress, NULL) : NULL;
105 }
106
107 static inline DWORD pe_get_sect_size(IMAGE_SECTION_HEADER* sect)
108 {
109 return (sect) ? sect->SizeOfRawData : 0;
110 }
111
112 /******************************************************************
113 * pe_load_stabs
114 *
115 * look for stabs information in PE header (it's how the mingw compiler provides
116 * its debugging information)
117 */
118 static BOOL pe_load_stabs(const struct process* pcs, struct module* module,
119 void* mapping, IMAGE_NT_HEADERS* nth)
120 {
121 IMAGE_SECTION_HEADER* section;
122 IMAGE_SECTION_HEADER* sect_stabs = NULL;
123 IMAGE_SECTION_HEADER* sect_stabstr = NULL;
124 int i;
125 BOOL ret = FALSE;
126
127 section = (IMAGE_SECTION_HEADER*)
128 ((char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader);
129 for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++)
130 {
131 if (!strcasecmp((const char*)section->Name, ".stab")) sect_stabs = section;
132 else if (!strncasecmp((const char*)section->Name, ".stabstr", 8)) sect_stabstr = section;
133 }
134 if (sect_stabs && sect_stabstr)
135 {
136 ret = stabs_parse(module,
137 module->module.BaseOfImage - nth->OptionalHeader.ImageBase,
138 pe_get_sect(nth, mapping, sect_stabs), pe_get_sect_size(sect_stabs),
139 pe_get_sect(nth, mapping, sect_stabstr), pe_get_sect_size(sect_stabstr),
140 NULL, NULL);
141 if (ret) pe_load_symbol_table(module, nth, mapping);
142 }
143 TRACE("%s the STABS debug info\n", ret ? "successfully loaded" : "failed to load");
144
145 return ret;
146 }
147
148 /******************************************************************
149 * pe_load_dwarf
150 *
151 * look for dwarf information in PE header (it's also a way for the mingw compiler
152 * to provide its debugging information)
153 */
154 static BOOL pe_load_dwarf(const struct process* pcs, struct module* module,
155 void* mapping, IMAGE_NT_HEADERS* nth)
156 {
157 IMAGE_SECTION_HEADER* section;
158 IMAGE_SECTION_HEADER* sect_debuginfo = NULL;
159 IMAGE_SECTION_HEADER* sect_debugstr = NULL;
160 IMAGE_SECTION_HEADER* sect_debugabbrev = NULL;
161 IMAGE_SECTION_HEADER* sect_debugline = NULL;
162 IMAGE_SECTION_HEADER* sect_debugloc = NULL;
163 int i;
164 const char* strtable;
165 const char* sectname;
166 BOOL ret = FALSE;
167
168 if (nth->FileHeader.PointerToSymbolTable && nth->FileHeader.NumberOfSymbols)
169 /* FIXME: no way to get strtable size */
170 strtable = (const char*)mapping + nth->FileHeader.PointerToSymbolTable +
171 nth->FileHeader.NumberOfSymbols * sizeof(IMAGE_SYMBOL);
172 else strtable = NULL;
173
174 section = (IMAGE_SECTION_HEADER*)
175 ((char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader);
176 for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++)
177 {
178 sectname = (const char*)section->Name;
179 /* long section names start with a '/' (at least on MinGW32) */
180 if (*sectname == '/' && strtable)
181 sectname = strtable + atoi(sectname + 1);
182 if (!strcasecmp(sectname, ".debug_info")) sect_debuginfo = section;
183 else if (!strcasecmp(sectname, ".debug_str")) sect_debugstr = section;
184 else if (!strcasecmp(sectname, ".debug_abbrev")) sect_debugabbrev = section;
185 else if (!strcasecmp(sectname, ".debug_line")) sect_debugline = section;
186 else if (!strcasecmp(sectname, ".debug_loc")) sect_debugloc = section;
187 }
188 if (sect_debuginfo)
189 {
190 ret = dwarf2_parse(module,
191 module->module.BaseOfImage - nth->OptionalHeader.ImageBase,
192 NULL, /* FIXME: some thunks to deal with ? */
193 pe_get_sect(nth, mapping, sect_debuginfo), pe_get_sect_size(sect_debuginfo),
194 pe_get_sect(nth, mapping, sect_debugabbrev), pe_get_sect_size(sect_debugabbrev),
195 pe_get_sect(nth, mapping, sect_debugstr), pe_get_sect_size(sect_debugstr),
196 pe_get_sect(nth, mapping, sect_debugline), pe_get_sect_size(sect_debugline),
197 pe_get_sect(nth, mapping, sect_debugloc), pe_get_sect_size(sect_debugloc));
198 }
199 TRACE("%s the DWARF debug info\n", ret ? "successfully loaded" : "failed to load");
200
201 return ret;
202 }
203
204 /******************************************************************
205 * pe_load_dbg_file
206 *
207 * loads a .dbg file
208 */
209 static BOOL pe_load_dbg_file(const struct process* pcs, struct module* module,
210 const char* dbg_name, DWORD timestamp)
211 {
212 char tmp[MAX_PATH];
213 HANDLE hFile = INVALID_HANDLE_VALUE, hMap = 0;
214 const BYTE* dbg_mapping = NULL;
215 BOOL ret = FALSE;
216
217 TRACE("Processing DBG file %s\n", debugstr_a(dbg_name));
218
219 if (path_find_symbol_file(pcs, dbg_name, NULL, timestamp, 0, tmp, &module->module.DbgUnmatched) &&
220 (hFile = CreateFileA(tmp, GENERIC_READ, FILE_SHARE_READ, NULL,
221 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) != INVALID_HANDLE_VALUE &&
222 ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0) &&
223 ((dbg_mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL))
224 {
225 const IMAGE_SEPARATE_DEBUG_HEADER* hdr;
226 const IMAGE_SECTION_HEADER* sectp;
227 const IMAGE_DEBUG_DIRECTORY* dbg;
228
229 hdr = (const IMAGE_SEPARATE_DEBUG_HEADER*)dbg_mapping;
230 /* section headers come immediately after debug header */
231 sectp = (const IMAGE_SECTION_HEADER*)(hdr + 1);
232 /* and after that and the exported names comes the debug directory */
233 dbg = (const IMAGE_DEBUG_DIRECTORY*)
234 (dbg_mapping + sizeof(*hdr) +
235 hdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) +
236 hdr->ExportedNamesSize);
237
238 ret = pe_load_debug_directory(pcs, module, dbg_mapping, sectp,
239 hdr->NumberOfSections, dbg,
240 hdr->DebugDirectorySize / sizeof(*dbg));
241 }
242 else
243 ERR("Couldn't find .DBG file %s (%s)\n", debugstr_a(dbg_name), debugstr_a(tmp));
244
245 if (dbg_mapping) UnmapViewOfFile(dbg_mapping);
246 if (hMap) CloseHandle(hMap);
247 if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
248 return ret;
249 }
250
251 /******************************************************************
252 * pe_load_msc_debug_info
253 *
254 * Process MSC debug information in PE file.
255 */
256 static BOOL pe_load_msc_debug_info(const struct process* pcs,
257 struct module* module,
258 void* mapping, const IMAGE_NT_HEADERS* nth)
259 {
260 BOOL ret = FALSE;
261 const IMAGE_DATA_DIRECTORY* dir;
262 const IMAGE_DEBUG_DIRECTORY*dbg = NULL;
263 int nDbg;
264
265 /* Read in debug directory */
266 dir = nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
267 nDbg = dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY);
268 if (!nDbg) return FALSE;
269
270 dbg = RtlImageRvaToVa(nth, mapping, dir->VirtualAddress, NULL);
271
272 /* Parse debug directory */
273 if (nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED)
274 {
275 /* Debug info is stripped to .DBG file */
276 const IMAGE_DEBUG_MISC* misc = (const IMAGE_DEBUG_MISC*)
277 ((const char*)mapping + dbg->PointerToRawData);
278
279 if (nDbg != 1 || dbg->Type != IMAGE_DEBUG_TYPE_MISC ||
280 misc->DataType != IMAGE_DEBUG_MISC_EXENAME)
281 {
282 WINE_ERR("-Debug info stripped, but no .DBG file in module %s\n",
283 debugstr_w(module->module.ModuleName));
284 }
285 else
286 {
287 ret = pe_load_dbg_file(pcs, module, (const char*)misc->Data, nth->FileHeader.TimeDateStamp);
288 }
289 }
290 else
291 {
292 const IMAGE_SECTION_HEADER *sectp = (const IMAGE_SECTION_HEADER*)((const char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader);
293 /* Debug info is embedded into PE module */
294 ret = pe_load_debug_directory(pcs, module, mapping, sectp,
295 nth->FileHeader.NumberOfSections, dbg, nDbg);
296 }
297
298 return ret;
299 }
300
301 /***********************************************************************
302 * pe_load_export_debug_info
303 */
304 static BOOL pe_load_export_debug_info(const struct process* pcs,
305 struct module* module,
306 void* mapping, const IMAGE_NT_HEADERS* nth)
307 {
308 unsigned int i;
309 const IMAGE_EXPORT_DIRECTORY* exports;
310 DWORD base = module->module.BaseOfImage;
311 DWORD size;
312
313 if (dbghelp_options & SYMOPT_NO_PUBLICS) return TRUE;
314
315 #if 0
316 /* Add start of DLL (better use the (yet unimplemented) Exe SymTag for this) */
317 /* FIXME: module.ModuleName isn't correctly set yet if it's passed in SymLoadModule */
318 symt_new_public(module, NULL, module->module.ModuleName, base, 1,
319 TRUE /* FIXME */, TRUE /* FIXME */);
320 #endif
321
322 /* Add entry point */
323 symt_new_public(module, NULL, "EntryPoint",
324 base + nth->OptionalHeader.AddressOfEntryPoint, 1,
325 TRUE, TRUE);
326 #if 0
327 /* FIXME: we'd better store addresses linked to sections rather than
328 absolute values */
329 IMAGE_SECTION_HEADER* section;
330 /* Add start of sections */
331 section = (IMAGE_SECTION_HEADER*)
332 ((char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader);
333 for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++)
334 {
335 symt_new_public(module, NULL, section->Name,
336 RtlImageRvaToVa(nth, mapping, section->VirtualAddress, NULL),
337 1, TRUE /* FIXME */, TRUE /* FIXME */);
338 }
339 #endif
340
341 /* Add exported functions */
342 if ((exports = RtlImageDirectoryEntryToData(mapping, FALSE,
343 IMAGE_DIRECTORY_ENTRY_EXPORT, &size)))
344 {
345 const WORD* ordinals = NULL;
346 const DWORD_PTR* functions = NULL;
347 const DWORD* names = NULL;
348 unsigned int j;
349 char buffer[16];
350
351 functions = RtlImageRvaToVa(nth, mapping, exports->AddressOfFunctions, NULL);
352 ordinals = RtlImageRvaToVa(nth, mapping, exports->AddressOfNameOrdinals, NULL);
353 names = RtlImageRvaToVa(nth, mapping, exports->AddressOfNames, NULL);
354
355 if (functions && ordinals && names)
356 {
357 for (i = 0; i < exports->NumberOfNames; i++)
358 {
359 if (!names[i]) continue;
360 symt_new_public(module, NULL,
361 RtlImageRvaToVa(nth, mapping, names[i], NULL),
362 base + functions[ordinals[i]],
363 1, TRUE /* FIXME */, TRUE /* FIXME */);
364 }
365
366 for (i = 0; i < exports->NumberOfFunctions; i++)
367 {
368 if (!functions[i]) continue;
369 /* Check if we already added it with a name */
370 for (j = 0; j < exports->NumberOfNames; j++)
371 if ((ordinals[j] == i) && names[j]) break;
372 if (j < exports->NumberOfNames) continue;
373 snprintf(buffer, sizeof(buffer), "%d", i + exports->Base);
374 symt_new_public(module, NULL, buffer, base + (DWORD)functions[i], 1,
375 TRUE /* FIXME */, TRUE /* FIXME */);
376 }
377 }
378 }
379 /* no real debug info, only entry points */
380 if (module->module.SymType == SymDeferred)
381 module->module.SymType = SymExport;
382 return TRUE;
383 }
384
385 /******************************************************************
386 * pe_load_debug_info
387 *
388 */
389 BOOL pe_load_debug_info(const struct process* pcs, struct module* module)
390 {
391 BOOL ret = FALSE;
392 HANDLE hFile;
393 HANDLE hMap;
394 void* mapping;
395 IMAGE_NT_HEADERS* nth;
396
397 hFile = CreateFileW(module->module.LoadedImageName, GENERIC_READ, FILE_SHARE_READ,
398 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
399 if (hFile == INVALID_HANDLE_VALUE) return ret;
400 if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0)
401 {
402 if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
403 {
404 nth = RtlImageNtHeader(mapping);
405
406 if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY))
407 {
408 ret = pe_load_stabs(pcs, module, mapping, nth) ||
409 pe_load_dwarf(pcs, module, mapping, nth) ||
410 pe_load_msc_debug_info(pcs, module, mapping, nth);
411 /* if we still have no debug info (we could only get SymExport at this
412 * point), then do the SymExport except if we have an ELF container,
413 * in which case we'll rely on the export's on the ELF side
414 */
415 }
416 /* FIXME shouldn't we check that? if (!module_get_debug(pcs, module))l */
417 if (pe_load_export_debug_info(pcs, module, mapping, nth) && !ret)
418 ret = TRUE;
419 UnmapViewOfFile(mapping);
420 }
421 CloseHandle(hMap);
422 }
423 CloseHandle(hFile);
424
425 return ret;
426 }
427
428 /******************************************************************
429 * pe_load_native_module
430 *
431 */
432 struct module* pe_load_native_module(struct process* pcs, const WCHAR* name,
433 HANDLE hFile, DWORD base, DWORD size)
434 {
435 struct module* module = NULL;
436 BOOL opened = FALSE;
437 HANDLE hMap;
438 WCHAR loaded_name[MAX_PATH];
439
440 loaded_name[0] = '\0';
441 if (!hFile)
442 {
443
444 assert(name);
445
446 if ((hFile = FindExecutableImageExW(name, pcs->search_path, loaded_name, NULL, NULL)) == NULL)
447 return NULL;
448 opened = TRUE;
449 }
450 else if (name) strcpyW(loaded_name, name);
451 else if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
452 FIXME("Trouble ahead (no module name passed in deferred mode)\n");
453
454 if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL)
455 {
456 void* mapping;
457
458 if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)
459 {
460 IMAGE_NT_HEADERS* nth = RtlImageNtHeader(mapping);
461
462 if (nth)
463 {
464 if (!base) base = nth->OptionalHeader.ImageBase;
465 if (!size) size = nth->OptionalHeader.SizeOfImage;
466
467 module = module_new(pcs, loaded_name, DMT_PE, FALSE, base, size,
468 nth->FileHeader.TimeDateStamp,
469 nth->OptionalHeader.CheckSum);
470 if (module)
471 {
472 if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
473 module->module.SymType = SymDeferred;
474 else
475 pe_load_debug_info(pcs, module);
476 }
477 else
478 ERR("could not load the module '%s'\n", debugstr_w(loaded_name));
479 }
480 UnmapViewOfFile(mapping);
481 }
482 CloseHandle(hMap);
483 }
484 if (opened) CloseHandle(hFile);
485
486 return module;
487 }
488
489 /******************************************************************
490 * pe_load_nt_header
491 *
492 */
493 BOOL pe_load_nt_header(HANDLE hProc, DWORD64 base, IMAGE_NT_HEADERS* nth)
494 {
495 IMAGE_DOS_HEADER dos;
496
497 return ReadProcessMemory(hProc, (char*)(DWORD_PTR)base, &dos, sizeof(dos), NULL) &&
498 dos.e_magic == IMAGE_DOS_SIGNATURE &&
499 ReadProcessMemory(hProc, (char*)(DWORD_PTR)(base + dos.e_lfanew),
500 nth, sizeof(*nth), NULL) &&
501 nth->Signature == IMAGE_NT_SIGNATURE;
502 }
503
504 /******************************************************************
505 * pe_load_builtin_module
506 *
507 */
508 struct module* pe_load_builtin_module(struct process* pcs, const WCHAR* name,
509 DWORD64 base, DWORD64 size)
510 {
511 struct module* module = NULL;
512
513 if (base && pcs->dbg_hdr_addr)
514 {
515 IMAGE_NT_HEADERS nth;
516
517 if (pe_load_nt_header(pcs->handle, base, &nth))
518 {
519 if (!size) size = nth.OptionalHeader.SizeOfImage;
520 module = module_new(pcs, name, DMT_PE, FALSE, base, size,
521 nth.FileHeader.TimeDateStamp,
522 nth.OptionalHeader.CheckSum);
523 }
524 }
525 return module;
526 }
527
528 /***********************************************************************
529 * ImageDirectoryEntryToDataEx (DBGHELP.@)
530 *
531 * Search for specified directory in PE image
532 *
533 * PARAMS
534 *
535 * base [in] Image base address
536 * image [in] TRUE - image has been loaded by loader, FALSE - raw file image
537 * dir [in] Target directory index
538 * size [out] Receives directory size
539 * section [out] Receives pointer to section header of section containing directory data
540 *
541 * RETURNS
542 * Success: pointer to directory data
543 * Failure: NULL
544 *
545 */
546 PVOID WINAPI ImageDirectoryEntryToDataEx( PVOID base, BOOLEAN image, USHORT dir, PULONG size, PIMAGE_SECTION_HEADER *section )
547 {
548 const IMAGE_NT_HEADERS *nt;
549 DWORD addr;
550
551 *size = 0;
552 if (section) *section = NULL;
553
554 if (!(nt = RtlImageNtHeader( base ))) return NULL;
555 if (dir >= nt->OptionalHeader.NumberOfRvaAndSizes) return NULL;
556 if (!(addr = nt->OptionalHeader.DataDirectory[dir].VirtualAddress)) return NULL;
557
558 *size = nt->OptionalHeader.DataDirectory[dir].Size;
559 if (image || addr < nt->OptionalHeader.SizeOfHeaders) return (char *)base + addr;
560
561 return RtlImageRvaToVa( nt, base, addr, section );
562 }
563
564 /***********************************************************************
565 * ImageDirectoryEntryToData (DBGHELP.@)
566 *
567 * NOTES
568 * See ImageDirectoryEntryToDataEx
569 */
570 PVOID WINAPI ImageDirectoryEntryToData( PVOID base, BOOLEAN image, USHORT dir, PULONG size )
571 {
572 return ImageDirectoryEntryToDataEx( base, image, dir, size, NULL );
573 }
useful hacks and other patches not (yet) suitable for mainline