514 lines
17 KiB
C
514 lines
17 KiB
C
|
/*
|
||
|
|
* File pe.c - handle PE module information
|
||
|
|
*
|
||
|
|
* Copyright (C) 1996, Eric Youngdale.
|
||
|
|
* Copyright (C) 1999, 2000, Ulrich Weigand.
|
||
|
|
*
|
||
|
|
* This library is free software; you can redistribute it and/or
|
||
|
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
|
* License as published by the Free Software Foundation; either
|
||
|
|
* version 2.1 of the License, or (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This library is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
|
* Lesser General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
|
* License along with this library; if not, write to the Free Software
|
||
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "config.h"
|
||
|
|
#include "wine/port.h"
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <string.h>
|
||
|
|
#ifdef HAVE_UNISTD_H
|
||
|
|
# include <unistd.h>
|
||
|
|
#endif
|
||
|
|
#ifndef PATH_MAX
|
||
|
|
#define PATH_MAX MAX_PATH
|
||
|
|
#endif
|
||
|
|
#include "wine/exception.h"
|
||
|
|
#include "wine/debug.h"
|
||
|
|
#include "excpt.h"
|
||
|
|
#include "debugger.h"
|
||
|
|
|
||
|
|
WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
|
||
|
|
|
||
|
|
#define MAX_PATHNAME_LEN 1024
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
DWORD from;
|
||
|
|
DWORD to;
|
||
|
|
|
||
|
|
} OMAP_DATA;
|
||
|
|
|
||
|
|
typedef struct tagMSC_DBG_INFO
|
||
|
|
{
|
||
|
|
int nsect;
|
||
|
|
PIMAGE_SECTION_HEADER sectp;
|
||
|
|
int nomap;
|
||
|
|
OMAP_DATA* omapp;
|
||
|
|
|
||
|
|
} MSC_DBG_INFO;
|
||
|
|
|
||
|
|
/***********************************************************************
|
||
|
|
* DEBUG_LocateDebugInfoFile
|
||
|
|
*
|
||
|
|
* NOTE: dbg_filename must be at least MAX_PATHNAME_LEN bytes in size
|
||
|
|
*/
|
||
|
|
static void DEBUG_LocateDebugInfoFile(const char* filename, char* dbg_filename)
|
||
|
|
{
|
||
|
|
char* str1 = DBG_alloc(MAX_PATHNAME_LEN);
|
||
|
|
char* str2 = DBG_alloc(MAX_PATHNAME_LEN*10);
|
||
|
|
const char* file;
|
||
|
|
char* name_part;
|
||
|
|
|
||
|
|
file = strrchr(filename, '\\');
|
||
|
|
if (file == NULL) file = filename; else file++;
|
||
|
|
|
||
|
|
if ((GetEnvironmentVariable("_NT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
|
||
|
|
(SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
|
||
|
|
(GetEnvironmentVariable("_NT_ALT_SYMBOL_PATH", str1, MAX_PATHNAME_LEN) &&
|
||
|
|
(SearchPath(str1, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part))) ||
|
||
|
|
(SearchPath(NULL, file, NULL, MAX_PATHNAME_LEN*10, str2, &name_part)))
|
||
|
|
lstrcpyn(dbg_filename, str2, MAX_PATHNAME_LEN);
|
||
|
|
else
|
||
|
|
lstrcpyn(dbg_filename, filename, MAX_PATHNAME_LEN);
|
||
|
|
DBG_free(str1);
|
||
|
|
DBG_free(str2);
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************
|
||
|
|
* DEBUG_MapDebugInfoFile
|
||
|
|
*/
|
||
|
|
void* DEBUG_MapDebugInfoFile(const char* name, DWORD offset, DWORD size,
|
||
|
|
HANDLE* hFile, HANDLE* hMap)
|
||
|
|
{
|
||
|
|
DWORD g_offset; /* offset aligned on map granuality */
|
||
|
|
DWORD g_size; /* size to map, with offset aligned */
|
||
|
|
char* ret;
|
||
|
|
|
||
|
|
*hMap = 0;
|
||
|
|
|
||
|
|
if (name != NULL)
|
||
|
|
{
|
||
|
|
char filename[MAX_PATHNAME_LEN];
|
||
|
|
|
||
|
|
DEBUG_LocateDebugInfoFile(name, filename);
|
||
|
|
if ((*hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
|
||
|
|
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!size)
|
||
|
|
{
|
||
|
|
DWORD file_size = GetFileSize(*hFile, NULL);
|
||
|
|
if (file_size == (DWORD)-1) return NULL;
|
||
|
|
size = file_size - offset;
|
||
|
|
}
|
||
|
|
|
||
|
|
g_offset = offset & ~0xFFFF; /* FIXME: is granularity portable ? */
|
||
|
|
g_size = offset + size - g_offset;
|
||
|
|
|
||
|
|
if ((*hMap = CreateFileMapping(*hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == 0)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
if ((ret = MapViewOfFile(*hMap, FILE_MAP_READ, 0, g_offset, g_size)) != NULL)
|
||
|
|
ret += offset - g_offset;
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************
|
||
|
|
* DEBUG_UnmapDebugInfoFile
|
||
|
|
*/
|
||
|
|
void DEBUG_UnmapDebugInfoFile(HANDLE hFile, HANDLE hMap, const void* addr)
|
||
|
|
{
|
||
|
|
if (addr) UnmapViewOfFile((void*)addr);
|
||
|
|
if (hMap) CloseHandle(hMap);
|
||
|
|
if (hFile!=INVALID_HANDLE_VALUE) CloseHandle(hFile);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*========================================================================
|
||
|
|
* Process DBG file.
|
||
|
|
*/
|
||
|
|
static enum DbgInfoLoad DEBUG_ProcessDBGFile(DBG_MODULE* module,
|
||
|
|
const char* filename, DWORD timestamp)
|
||
|
|
{
|
||
|
|
enum DbgInfoLoad dil = DIL_ERROR;
|
||
|
|
HANDLE hFile = INVALID_HANDLE_VALUE, hMap = 0;
|
||
|
|
const BYTE* file_map = NULL;
|
||
|
|
PIMAGE_SEPARATE_DEBUG_HEADER hdr;
|
||
|
|
PIMAGE_DEBUG_DIRECTORY dbg;
|
||
|
|
int nDbg;
|
||
|
|
|
||
|
|
WINE_TRACE("Processing DBG file %s\n", filename);
|
||
|
|
|
||
|
|
file_map = DEBUG_MapDebugInfoFile(filename, 0, 0, &hFile, &hMap);
|
||
|
|
if (!file_map)
|
||
|
|
{
|
||
|
|
WINE_ERR("-Unable to peruse .DBG file %s\n", filename);
|
||
|
|
goto leave;
|
||
|
|
}
|
||
|
|
|
||
|
|
hdr = (PIMAGE_SEPARATE_DEBUG_HEADER) file_map;
|
||
|
|
|
||
|
|
if (hdr->TimeDateStamp != timestamp)
|
||
|
|
{
|
||
|
|
WINE_ERR("Warning - %s has incorrect internal timestamp\n", filename);
|
||
|
|
/*
|
||
|
|
* Well, sometimes this happens to DBG files which ARE REALLY the right .DBG
|
||
|
|
* files but nonetheless this check fails. Anyway, WINDBG (debugger for
|
||
|
|
* Windows by Microsoft) loads debug symbols which have incorrect timestamps.
|
||
|
|
*/
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
dbg = (PIMAGE_DEBUG_DIRECTORY)
|
||
|
|
(file_map + sizeof(*hdr) + hdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
|
||
|
|
+ hdr->ExportedNamesSize);
|
||
|
|
|
||
|
|
nDbg = hdr->DebugDirectorySize / sizeof(*dbg);
|
||
|
|
|
||
|
|
dil = DEBUG_ProcessDebugDirectory(module, file_map, dbg, nDbg);
|
||
|
|
|
||
|
|
leave:
|
||
|
|
DEBUG_UnmapDebugInfoFile(hFile, hMap, file_map);
|
||
|
|
return dil;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*========================================================================
|
||
|
|
* Process MSC debug information in PE file.
|
||
|
|
*/
|
||
|
|
enum DbgInfoLoad DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile,
|
||
|
|
void* _nth, unsigned long nth_ofs)
|
||
|
|
{
|
||
|
|
enum DbgInfoLoad dil = DIL_ERROR;
|
||
|
|
PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
|
||
|
|
PIMAGE_DATA_DIRECTORY dir = nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
|
||
|
|
PIMAGE_DEBUG_DIRECTORY dbg = NULL;
|
||
|
|
int nDbg;
|
||
|
|
MSC_DBG_INFO extra_info = { 0, NULL, 0, NULL };
|
||
|
|
HANDLE hMap = 0;
|
||
|
|
const BYTE* file_map = NULL;
|
||
|
|
|
||
|
|
/* Read in section data */
|
||
|
|
|
||
|
|
module->msc_dbg_info = &extra_info;
|
||
|
|
extra_info.nsect = nth->FileHeader.NumberOfSections;
|
||
|
|
extra_info.sectp = DBG_alloc(extra_info.nsect * sizeof(IMAGE_SECTION_HEADER));
|
||
|
|
if (!extra_info.sectp)
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((char*)module->load_addr +
|
||
|
|
nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
|
||
|
|
nth->FileHeader.SizeOfOptionalHeader,
|
||
|
|
extra_info.sectp,
|
||
|
|
extra_info.nsect * sizeof(IMAGE_SECTION_HEADER)))
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
/* Read in debug directory */
|
||
|
|
|
||
|
|
nDbg = dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY);
|
||
|
|
if (!nDbg)
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
dbg = (PIMAGE_DEBUG_DIRECTORY) DBG_alloc(nDbg * sizeof(IMAGE_DEBUG_DIRECTORY));
|
||
|
|
if (!dbg)
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + dir->VirtualAddress,
|
||
|
|
dbg, nDbg * sizeof(IMAGE_DEBUG_DIRECTORY)))
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
|
||
|
|
/* Map in PE file */
|
||
|
|
file_map = DEBUG_MapDebugInfoFile(NULL, 0, 0, &hFile, &hMap);
|
||
|
|
if (!file_map)
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
|
||
|
|
/* Parse debug directory */
|
||
|
|
|
||
|
|
if (nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED)
|
||
|
|
{
|
||
|
|
/* Debug info is stripped to .DBG file */
|
||
|
|
|
||
|
|
PIMAGE_DEBUG_MISC misc = (PIMAGE_DEBUG_MISC)(file_map + dbg->PointerToRawData);
|
||
|
|
|
||
|
|
if (nDbg != 1 || dbg->Type != IMAGE_DEBUG_TYPE_MISC
|
||
|
|
|| misc->DataType != IMAGE_DEBUG_MISC_EXENAME)
|
||
|
|
{
|
||
|
|
WINE_ERR("-Debug info stripped, but no .DBG file in module %s\n",
|
||
|
|
module->module_name);
|
||
|
|
goto leave;
|
||
|
|
}
|
||
|
|
|
||
|
|
dil = DEBUG_ProcessDBGFile(module, misc->Data, nth->FileHeader.TimeDateStamp);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
/* Debug info is embedded into PE module */
|
||
|
|
/* FIXME: the nDBG information we're manipulating comes from the debuggee
|
||
|
|
* address space. However, the following code will be made against the
|
||
|
|
* version mapped in the debugger address space. There are cases (for example
|
||
|
|
* when the PE sections are compressed in the file and become decompressed
|
||
|
|
* in the debuggee address space) where the two don't match.
|
||
|
|
* Therefore, redo the DBG information lookup with the mapped data
|
||
|
|
*/
|
||
|
|
PIMAGE_NT_HEADERS mpd_nth = (PIMAGE_NT_HEADERS)(file_map + nth_ofs);
|
||
|
|
PIMAGE_DATA_DIRECTORY mpd_dir;
|
||
|
|
PIMAGE_DEBUG_DIRECTORY mpd_dbg = NULL;
|
||
|
|
|
||
|
|
/* sanity checks */
|
||
|
|
if (mpd_nth->Signature != IMAGE_NT_SIGNATURE ||
|
||
|
|
mpd_nth->FileHeader.NumberOfSections != nth->FileHeader.NumberOfSections ||
|
||
|
|
(mpd_nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) != 0)
|
||
|
|
goto leave;
|
||
|
|
mpd_dir = mpd_nth->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_DEBUG;
|
||
|
|
|
||
|
|
if ((mpd_dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY)) != nDbg)
|
||
|
|
goto leave;
|
||
|
|
|
||
|
|
mpd_dbg = (PIMAGE_DEBUG_DIRECTORY)(file_map + mpd_dir->VirtualAddress);
|
||
|
|
|
||
|
|
dil = DEBUG_ProcessDebugDirectory(module, file_map, mpd_dbg, nDbg);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
leave:
|
||
|
|
module->msc_dbg_info = NULL;
|
||
|
|
|
||
|
|
DEBUG_UnmapDebugInfoFile(0, hMap, file_map);
|
||
|
|
if (extra_info.sectp) DBG_free(extra_info.sectp);
|
||
|
|
if (dbg) DBG_free(dbg);
|
||
|
|
return dil;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*========================================================================
|
||
|
|
* look for stabs information in PE header (it's how mingw compiler provides its
|
||
|
|
* debugging information), and also wine PE <-> ELF linking through .wsolnk sections
|
||
|
|
*/
|
||
|
|
enum DbgInfoLoad DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile,
|
||
|
|
void* _nth, unsigned long nth_ofs)
|
||
|
|
{
|
||
|
|
IMAGE_SECTION_HEADER pe_seg;
|
||
|
|
unsigned long pe_seg_ofs;
|
||
|
|
int i, stabsize = 0, stabstrsize = 0;
|
||
|
|
unsigned int stabs = 0, stabstr = 0;
|
||
|
|
PIMAGE_NT_HEADERS nth = (PIMAGE_NT_HEADERS)_nth;
|
||
|
|
enum DbgInfoLoad dil = DIL_ERROR;
|
||
|
|
|
||
|
|
pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
|
||
|
|
nth->FileHeader.SizeOfOptionalHeader;
|
||
|
|
|
||
|
|
for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg))
|
||
|
|
{
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((void*)((char*)module->load_addr + pe_seg_ofs),
|
||
|
|
&pe_seg, sizeof(pe_seg)))
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (!strcasecmp(pe_seg.Name, ".stab"))
|
||
|
|
{
|
||
|
|
stabs = pe_seg.VirtualAddress;
|
||
|
|
stabsize = pe_seg.SizeOfRawData;
|
||
|
|
}
|
||
|
|
else if (!strncasecmp(pe_seg.Name, ".stabstr", 8))
|
||
|
|
{
|
||
|
|
stabstr = pe_seg.VirtualAddress;
|
||
|
|
stabstrsize = pe_seg.SizeOfRawData;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (stabstrsize && stabsize)
|
||
|
|
{
|
||
|
|
char* s1 = DBG_alloc(stabsize+stabstrsize);
|
||
|
|
|
||
|
|
if (s1)
|
||
|
|
{
|
||
|
|
if (DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabs, s1, stabsize) &&
|
||
|
|
DEBUG_READ_MEM_VERBOSE((char*)module->load_addr + stabstr,
|
||
|
|
s1 + stabsize, stabstrsize))
|
||
|
|
{
|
||
|
|
dil = DEBUG_ParseStabs(s1, 0, 0, stabsize, stabsize, stabstrsize);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DEBUG_Printf("couldn't read data block\n");
|
||
|
|
}
|
||
|
|
DBG_free(s1);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DEBUG_Printf("couldn't alloc %d bytes\n", stabsize + stabstrsize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dil = DIL_NOINFO;
|
||
|
|
}
|
||
|
|
return dil;
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************
|
||
|
|
* DEBUG_RegisterPEDebugInfo
|
||
|
|
*/
|
||
|
|
enum DbgInfoLoad DEBUG_RegisterPEDebugInfo(DBG_MODULE* wmod, HANDLE hFile,
|
||
|
|
void* _nth, unsigned long nth_ofs)
|
||
|
|
{
|
||
|
|
DBG_VALUE value;
|
||
|
|
char buffer[512];
|
||
|
|
char bufstr[256];
|
||
|
|
unsigned int i;
|
||
|
|
IMAGE_SECTION_HEADER pe_seg;
|
||
|
|
DWORD pe_seg_ofs;
|
||
|
|
IMAGE_DATA_DIRECTORY dir;
|
||
|
|
DWORD dir_ofs;
|
||
|
|
const char* prefix;
|
||
|
|
IMAGE_NT_HEADERS* nth = (PIMAGE_NT_HEADERS)_nth;
|
||
|
|
void* base = wmod->load_addr;
|
||
|
|
|
||
|
|
value.type = NULL;
|
||
|
|
value.cookie = DV_TARGET;
|
||
|
|
value.addr.seg = 0;
|
||
|
|
value.addr.off = 0;
|
||
|
|
|
||
|
|
/* Add start of DLL */
|
||
|
|
value.addr.off = (unsigned long)base;
|
||
|
|
if ((prefix = strrchr(wmod->module_name, '\\'))) prefix++;
|
||
|
|
else prefix = wmod->module_name;
|
||
|
|
|
||
|
|
DEBUG_AddSymbol(prefix, &value, NULL, SYM_WIN32 | SYM_FUNC);
|
||
|
|
|
||
|
|
/* Add entry point */
|
||
|
|
snprintf(buffer, sizeof(buffer), "%s.EntryPoint", prefix);
|
||
|
|
value.addr.off = (unsigned long)base + nth->OptionalHeader.AddressOfEntryPoint;
|
||
|
|
DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
|
||
|
|
|
||
|
|
/* Add start of sections */
|
||
|
|
pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
|
||
|
|
nth->FileHeader.SizeOfOptionalHeader;
|
||
|
|
|
||
|
|
for (i = 0; i < nth->FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg))
|
||
|
|
{
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((char*)base + pe_seg_ofs, &pe_seg, sizeof(pe_seg)))
|
||
|
|
continue;
|
||
|
|
snprintf(buffer, sizeof(buffer), "%s.%s", prefix, pe_seg.Name);
|
||
|
|
value.addr.off = (unsigned long)base + pe_seg.VirtualAddress;
|
||
|
|
DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add exported functions */
|
||
|
|
dir_ofs = nth_ofs +
|
||
|
|
OFFSET_OF(IMAGE_NT_HEADERS,
|
||
|
|
OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]);
|
||
|
|
if (DEBUG_READ_MEM_VERBOSE((char*)base + dir_ofs, &dir, sizeof(dir)) && dir.Size)
|
||
|
|
{
|
||
|
|
IMAGE_EXPORT_DIRECTORY exports;
|
||
|
|
WORD* ordinals = NULL;
|
||
|
|
void** functions = NULL;
|
||
|
|
DWORD* names = NULL;
|
||
|
|
unsigned int j;
|
||
|
|
|
||
|
|
if (DEBUG_READ_MEM_VERBOSE((char*)base + dir.VirtualAddress,
|
||
|
|
&exports, sizeof(exports)) &&
|
||
|
|
|
||
|
|
((functions = DBG_alloc(sizeof(functions[0]) * exports.NumberOfFunctions))) &&
|
||
|
|
DEBUG_READ_MEM_VERBOSE((char*)base + exports.AddressOfFunctions,
|
||
|
|
functions, sizeof(functions[0]) * exports.NumberOfFunctions) &&
|
||
|
|
|
||
|
|
((ordinals = DBG_alloc(sizeof(ordinals[0]) * exports.NumberOfNames))) &&
|
||
|
|
DEBUG_READ_MEM_VERBOSE((char*)base + (DWORD)exports.AddressOfNameOrdinals,
|
||
|
|
ordinals, sizeof(ordinals[0]) * exports.NumberOfNames) &&
|
||
|
|
|
||
|
|
((names = DBG_alloc(sizeof(names[0]) * exports.NumberOfNames))) &&
|
||
|
|
DEBUG_READ_MEM_VERBOSE((char*)base + (DWORD)exports.AddressOfNames,
|
||
|
|
names, sizeof(names[0]) * exports.NumberOfNames))
|
||
|
|
{
|
||
|
|
|
||
|
|
for (i = 0; i < exports.NumberOfNames; i++)
|
||
|
|
{
|
||
|
|
if (!names[i] ||
|
||
|
|
!DEBUG_READ_MEM_VERBOSE((char*)base + names[i], bufstr, sizeof(bufstr)))
|
||
|
|
continue;
|
||
|
|
bufstr[sizeof(bufstr) - 1] = 0;
|
||
|
|
snprintf(buffer, sizeof(buffer), "%s.%s", prefix, bufstr);
|
||
|
|
value.addr.off = (unsigned long)base + (DWORD)functions[ordinals[i]];
|
||
|
|
DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < exports.NumberOfFunctions; i++)
|
||
|
|
{
|
||
|
|
if (!functions[i]) continue;
|
||
|
|
/* Check if we already added it with a name */
|
||
|
|
for (j = 0; j < exports.NumberOfNames; j++)
|
||
|
|
if ((ordinals[j] == i) && names[j]) break;
|
||
|
|
if (j < exports.NumberOfNames) continue;
|
||
|
|
snprintf(buffer, sizeof(buffer), "%s.%ld", prefix, i + exports.Base);
|
||
|
|
value.addr.off = (unsigned long)base + (DWORD)functions[i];
|
||
|
|
DEBUG_AddSymbol(buffer, &value, NULL, SYM_WIN32 | SYM_FUNC);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
DBG_free(functions);
|
||
|
|
DBG_free(ordinals);
|
||
|
|
DBG_free(names);
|
||
|
|
}
|
||
|
|
/* no real debug info, only entry points */
|
||
|
|
return DIL_NOINFO;
|
||
|
|
}
|
||
|
|
|
||
|
|
/***********************************************************************
|
||
|
|
* DEBUG_LoadPEModule
|
||
|
|
*/
|
||
|
|
void DEBUG_LoadPEModule(const char* name, HANDLE hFile, void* base)
|
||
|
|
{
|
||
|
|
IMAGE_NT_HEADERS pe_header;
|
||
|
|
DWORD nth_ofs;
|
||
|
|
DBG_MODULE* wmod = NULL;
|
||
|
|
int i;
|
||
|
|
IMAGE_SECTION_HEADER pe_seg;
|
||
|
|
DWORD pe_seg_ofs;
|
||
|
|
DWORD size = 0;
|
||
|
|
enum DbgInfoLoad dil = DIL_ERROR;
|
||
|
|
|
||
|
|
/* grab PE Header */
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((char*)base + OFFSET_OF(IMAGE_DOS_HEADER, e_lfanew),
|
||
|
|
&nth_ofs, sizeof(nth_ofs)) ||
|
||
|
|
!DEBUG_READ_MEM_VERBOSE((char*)base + nth_ofs, &pe_header, sizeof(pe_header)))
|
||
|
|
return;
|
||
|
|
|
||
|
|
pe_seg_ofs = nth_ofs + OFFSET_OF(IMAGE_NT_HEADERS, OptionalHeader) +
|
||
|
|
pe_header.FileHeader.SizeOfOptionalHeader;
|
||
|
|
|
||
|
|
for (i = 0; i < pe_header.FileHeader.NumberOfSections; i++, pe_seg_ofs += sizeof(pe_seg))
|
||
|
|
{
|
||
|
|
if (!DEBUG_READ_MEM_VERBOSE((char*)base + pe_seg_ofs, &pe_seg, sizeof(pe_seg)))
|
||
|
|
continue;
|
||
|
|
if (size < pe_seg.VirtualAddress + pe_seg.SizeOfRawData)
|
||
|
|
size = pe_seg.VirtualAddress + pe_seg.SizeOfRawData;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* FIXME: we make the assumption that hModule == base */
|
||
|
|
wmod = DEBUG_AddModule(name, DMT_PE, base, size, (HMODULE)base);
|
||
|
|
|
||
|
|
if (wmod)
|
||
|
|
{
|
||
|
|
dil = DEBUG_RegisterStabsDebugInfo(wmod, hFile, &pe_header, nth_ofs);
|
||
|
|
if (dil != DIL_LOADED)
|
||
|
|
dil = DEBUG_RegisterMSCDebugInfo(wmod, hFile, &pe_header, nth_ofs);
|
||
|
|
if (dil != DIL_LOADED)
|
||
|
|
dil = DEBUG_RegisterPEDebugInfo(wmod, hFile, &pe_header, nth_ofs);
|
||
|
|
wmod->dil = dil;
|
||
|
|
}
|
||
|
|
|
||
|
|
DEBUG_ReportDIL(dil, "32bit DLL", name, base);
|
||
|
|
}
|