diff --git a/reactos/dll/win32/dbghelp/Makefile.in b/reactos/dll/win32/dbghelp/Makefile.in index 1af272516bb..280e199c9ac 100644 --- a/reactos/dll/win32/dbghelp/Makefile.in +++ b/reactos/dll/win32/dbghelp/Makefile.in @@ -3,11 +3,13 @@ TOPOBJDIR = ../.. SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = dbghelp.dll +IMPORTLIB = libdbghelp.$(IMPLIBEXT) IMPORTS = psapi kernel32 ntdll C_SRCS = \ coff.c \ dbghelp.c \ + dwarf.c \ elf_module.c \ image.c \ memory.c \ @@ -21,9 +23,8 @@ C_SRCS = \ stack.c \ storage.c \ symbol.c \ - type.c \ - regex.c # ReactOS Port + type.c @MAKE_DLL_RULES@ -### Dependencies: +@DEPENDENCIES@ # everything below this line is overwritten by make depend diff --git a/reactos/dll/win32/dbghelp/coff.c b/reactos/dll/win32/dbghelp/coff.c index 9e8bcacb261..ef8632b0f09 100644 --- a/reactos/dll/win32/dbghelp/coff.c +++ b/reactos/dll/win32/dbghelp/coff.c @@ -18,7 +18,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ /* @@ -48,14 +48,12 @@ #include #include "windef.h" #include "winbase.h" -#include "winreg.h" #include "winternl.h" #include "wine/exception.h" #include "wine/debug.h" -#include "excpt.h" #include "dbghelp_private.h" -#include "mscvpdb.h" +#include "wine/mscvpdb.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_coff); @@ -82,7 +80,7 @@ struct CoffFileSet int nfiles_alloc; }; -static const char* coff_get_name(const IMAGE_SYMBOL* coff_sym, +static const char* coff_get_name(const IMAGE_SYMBOL* coff_sym, const char* coff_strtab) { static char namebuff[9]; @@ -120,7 +118,8 @@ static int coff_add_file(struct CoffFileSet* coff_files, struct module* module, file = coff_files->files + coff_files->nfiles; file->startaddr = 0xffffffff; file->endaddr = 0; - file->compiland = symt_new_compiland(module, filename); + file->compiland = symt_new_compiland(module, 0, + source_new(module, NULL, filename)); file->linetab_offset = -1; file->linecnt = 0; file->entries = NULL; @@ -137,7 +136,7 @@ static void coff_add_symbol(struct CoffFile* coff_file, struct symt* sym) coff_file->entries = (coff_file->entries) ? HeapReAlloc(GetProcessHeap(), 0, coff_file->entries, coff_file->neps_alloc * sizeof(struct symt*)) : - HeapAlloc(GetProcessHeap(), 0, + HeapAlloc(GetProcessHeap(), 0, coff_file->neps_alloc * sizeof(struct symt*)); } coff_file->entries[coff_file->neps++] = sym; @@ -174,10 +173,8 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root; - coff_symbols = (const IMAGE_SYMBOL*)((unsigned int)coff + - coff->LvaToFirstSymbol); - coff_linetab = (const IMAGE_LINENUMBER*)((unsigned int)coff + - coff->LvaToFirstLinenumber); + coff_symbols = (const IMAGE_SYMBOL*)((const char *)coff + coff->LvaToFirstSymbol); + coff_linetab = (const IMAGE_LINENUMBER*)((const char *)coff + coff->LvaToFirstLinenumber); coff_strtab = (const char*)(coff_symbols + coff->NumberOfSymbols); linetab_indx = 0; @@ -189,7 +186,7 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE) { - curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, + curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, (const char*)(coff_sym + 1)); TRACE("New file %s\n", (const char*)(coff_sym + 1)); i += naux; @@ -224,12 +221,12 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) fn = source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source); - TRACE("Duplicating sect from %s: %lx %x %x %d %d\n", + TRACE("Duplicating sect from %s: %x %x %x %d %d\n", fn, aux->Section.Length, aux->Section.NumberOfRelocations, aux->Section.NumberOfLinenumbers, aux->Section.Number, aux->Section.Selection); - TRACE("More sect %d %s %08lx %d %d %d\n", + TRACE("More sect %d %s %08x %d %d %d\n", coff_sym->SectionNumber, coff_get_name(coff_sym, coff_strtab), coff_sym->Value, coff_sym->Type, @@ -243,7 +240,7 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) } else { - TRACE("New text sect from %s: %lx %x %x %d %d\n", + TRACE("New text sect from %s: %x %x %x %d %d\n", source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source), aux->Section.Length, aux->Section.NumberOfRelocations, @@ -268,7 +265,7 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) continue; } - if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 && + if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 && coff_sym->SectionNumber == 1) { DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress; @@ -283,8 +280,8 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) /* FIXME: was adding symbol to this_file ??? */ coff_add_symbol(&coff_files.files[curr_file_idx], - &symt_new_function(msc_dbg->module, - coff_files.files[curr_file_idx].compiland, + &symt_new_function(msc_dbg->module, + coff_files.files[curr_file_idx].compiland, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, @@ -300,8 +297,8 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress; nampnt = coff_get_name(coff_sym, coff_strtab); - TRACE("%d: %lx %s\n", - i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, + TRACE("%d: %s %s\n", + i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value), nampnt); TRACE("\tAdding global symbol %s (sect=%s)\n", nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name); @@ -321,13 +318,13 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) if (j < coff_files.nfiles) { coff_add_symbol(&coff_files.files[j], - &symt_new_function(msc_dbg->module, compiland, nampnt, + &symt_new_function(msc_dbg->module, compiland, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, NULL /* FIXME */)->symt); - } - else + } + else { - symt_new_function(msc_dbg->module, NULL, nampnt, + symt_new_function(msc_dbg->module, NULL, nampnt, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, 0 /* FIXME */, NULL /* FIXME */); } @@ -345,8 +342,8 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) */ nampnt = coff_get_name(coff_sym, coff_strtab); - TRACE("%d: %lx %s\n", - i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, + TRACE("%d: %s %s\n", + i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value), nampnt); TRACE("\tAdding global data symbol %s\n", nampnt); @@ -373,7 +370,7 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) TRACE("Skipping unknown entry '%s' %d %d %d\n", coff_get_name(coff_sym, coff_strtab), coff_sym->StorageClass, coff_sym->SectionNumber, naux); - + /* * For now, skip past the aux entries. */ @@ -430,7 +427,7 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) * first. */ symt_get_info(coff_files.files[j].entries[l+1], TI_GET_ADDRESS, &addr); - symt_add_func_line(msc_dbg->module, (struct symt_function*)coff_files.files[j].entries[l+1], + symt_add_func_line(msc_dbg->module, (struct symt_function*)coff_files.files[j].entries[l+1], coff_files.files[j].compiland->source, linepnt->Linenumber, msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress - addr); } @@ -440,13 +437,16 @@ BOOL coff_process_info(const struct msc_debug_info* msc_dbg) for (j = 0; j < coff_files.nfiles; j++) { - if (coff_files.files[j].entries != NULL) - { - HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries); - } + HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries); } HeapFree(GetProcessHeap(), 0, coff_files.files); msc_dbg->module->module.SymType = SymCoff; + /* FIXME: we could have a finer grain here */ + msc_dbg->module->module.LineNumbers = TRUE; + msc_dbg->module->module.GlobalSymbols = TRUE; + msc_dbg->module->module.TypeInfo = FALSE; + msc_dbg->module->module.SourceIndexed = TRUE; + msc_dbg->module->module.Publics = TRUE; ret = TRUE; } diff --git a/reactos/dll/win32/dbghelp/dbghelp.c b/reactos/dll/win32/dbghelp/dbghelp.c index dab8efc2302..dc3b86a35db 100644 --- a/reactos/dll/win32/dbghelp/dbghelp.c +++ b/reactos/dll/win32/dbghelp/dbghelp.c @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -24,19 +24,25 @@ #include "winerror.h" #include "psapi.h" #include "wine/debug.h" +#include "wdbgexts.h" +#include "winnls.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); /* TODO * - support for symbols' types is still partly missing * + C++ support - * + funcargtype:s are (partly) wrong: they should be a specific struct (like - * typedef) pointing to the actual type (and not a direct access) * + we should store the underlying type for an enum in the symt_enum struct - * + for enums, we store the names & values (associated to the enum type), + * + for enums, we store the names & values (associated to the enum type), * but those values are not directly usable from a debugger (that's why, I - * assume, that we have also to define constants for enum values, as + * assume, that we have also to define constants for enum values, as * Codeview does BTW. + * + SymEnumTypes should only return *user* defined types (UDT, typedefs...) not + * all the types stored/used in the modules (like char*) + * - SymGetLine{Next|Prev} don't work as expected (they don't seem to work across + * functions, and even across function blocks...). Basically, for *Next* to work + * it requires an address after the prolog of the func (the base address of the + * func doesn't work) * - most options (dbghelp_options) are not used (loading lines...) * - in symbol lookup by name, we don't use RE everywhere we should. Moreover, when * we're supposed to use RE, it doesn't make use of our hash tables. Therefore, @@ -45,18 +51,17 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); * - msc: * + we should add parameters' types to the function's signature * while processing a function's parameters - * + get rid of MSC reading FIXME:s (lots of types are not defined) + * + add support for function-less labels (as MSC seems to define them) * + C++ management - * - stabs: + * - stabs: * + when, in a same module, the same definition is used in several compilation - * units, we get several definitions of the same object (especially + * units, we get several definitions of the same object (especially * struct/union). we should find a way not to duplicate them * + in some cases (dlls/user/dialog16.c DIALOG_GetControl16), the same static * global variable is defined several times (at different scopes). We are - * getting several of those while looking for a unique symbol. Part of the + * getting several of those while looking for a unique symbol. Part of the * issue is that we don't give a scope to a static variable inside a function * + C++ management - * - implement the callback notification mechanism */ unsigned dbghelp_options = SYMOPT_UNDNAME; @@ -96,10 +101,43 @@ struct process* process_find_by_handle(HANDLE hProcess) } /****************************************************************** - * SymSetSearchPath (DBGHELP.@) + * validate_addr64 (internal) * */ -BOOL WINAPI SymSetSearchPath(HANDLE hProcess, PSTR searchPath) +BOOL validate_addr64(DWORD64 addr) +{ + if (addr >> 32) + { + FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr)); + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return TRUE; +} + +/****************************************************************** + * fetch_buffer + * + * Ensures process' internal buffer is large enough. + */ +void* fetch_buffer(struct process* pcs, unsigned size) +{ + if (size > pcs->buffer_size) + { + if (pcs->buffer) + pcs->buffer = HeapReAlloc(GetProcessHeap(), 0, pcs->buffer, size); + else + pcs->buffer = HeapAlloc(GetProcessHeap(), 0, size); + pcs->buffer_size = (pcs->buffer) ? size : 0; + } + return pcs->buffer; +} + +/****************************************************************** + * SymSetSearchPathW (DBGHELP.@) + * + */ +BOOL WINAPI SymSetSearchPathW(HANDLE hProcess, PCWSTR searchPath) { struct process* pcs = process_find_by_handle(hProcess); @@ -107,23 +145,64 @@ BOOL WINAPI SymSetSearchPath(HANDLE hProcess, PSTR searchPath) if (!searchPath) return FALSE; HeapFree(GetProcessHeap(), 0, pcs->search_path); - pcs->search_path = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(searchPath) + 1), - searchPath); + pcs->search_path = lstrcpyW(HeapAlloc(GetProcessHeap(), 0, + (lstrlenW(searchPath) + 1) * sizeof(WCHAR)), + searchPath); + return TRUE; +} + +/****************************************************************** + * SymSetSearchPath (DBGHELP.@) + * + */ +BOOL WINAPI SymSetSearchPath(HANDLE hProcess, PCSTR searchPath) +{ + BOOL ret = FALSE; + unsigned len; + WCHAR* sp; + + len = MultiByteToWideChar(CP_ACP, 0, searchPath, -1, NULL, 0); + if ((sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)))) + { + MultiByteToWideChar(CP_ACP, 0, searchPath, -1, sp, len); + + ret = SymSetSearchPathW(hProcess, sp); + HeapFree(GetProcessHeap(), 0, sp); + } + return ret; +} + +/*********************************************************************** + * SymGetSearchPathW (DBGHELP.@) + */ +BOOL WINAPI SymGetSearchPathW(HANDLE hProcess, PWSTR szSearchPath, + DWORD SearchPathLength) +{ + struct process* pcs = process_find_by_handle(hProcess); + if (!pcs) return FALSE; + + lstrcpynW(szSearchPath, pcs->search_path, SearchPathLength); return TRUE; } /*********************************************************************** * SymGetSearchPath (DBGHELP.@) */ -BOOL WINAPI SymGetSearchPath(HANDLE hProcess, LPSTR szSearchPath, +BOOL WINAPI SymGetSearchPath(HANDLE hProcess, PSTR szSearchPath, DWORD SearchPathLength) { - struct process* pcs = process_find_by_handle(hProcess); - if (!pcs) return FALSE; + WCHAR* buffer = HeapAlloc(GetProcessHeap(), 0, SearchPathLength * sizeof(WCHAR)); + BOOL ret = FALSE; - strncpy(szSearchPath, pcs->search_path, SearchPathLength); - szSearchPath[SearchPathLength - 1] = '\0'; - return TRUE; + if (buffer) + { + ret = SymGetSearchPathW(hProcess, buffer, SearchPathLength); + if (ret) + WideCharToMultiByte(CP_ACP, 0, buffer, SearchPathLength, + szSearchPath, SearchPathLength, NULL, NULL); + HeapFree(GetProcessHeap(), 0, buffer); + } + return ret; } /****************************************************************** @@ -132,34 +211,38 @@ BOOL WINAPI SymGetSearchPath(HANDLE hProcess, LPSTR szSearchPath, * SymInitialize helper: loads in dbghelp all known (and loaded modules) * this assumes that hProcess is a handle on a valid process */ -static BOOL process_invade(HANDLE hProcess) +static BOOL WINAPI process_invade_cb(PCSTR name, ULONG base, ULONG size, PVOID user) { - HMODULE hMods[256]; - char img[256]; - DWORD i, sz; - MODULEINFO mi; + char tmp[MAX_PATH]; + HANDLE hProcess = user; - if (!EnumProcessModules(hProcess, hMods, sizeof(hMods), &sz)) - return FALSE; /* FIXME should grow hMods */ + if (!GetModuleFileNameExA(hProcess, (HMODULE)base, + tmp, sizeof(tmp))) + lstrcpynA(tmp, name, sizeof(tmp)); - for (i = 0; i < sz / sizeof(HMODULE); i++) - { - if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) || - !GetModuleFileNameExA(hProcess, hMods[i], img, sizeof(img)) || - !SymLoadModule(hProcess, 0, img, NULL, (DWORD)mi.lpBaseOfDll, mi.SizeOfImage)) - return FALSE; - } - - return sz != 0; + SymLoadModule(hProcess, 0, tmp, name, base, size); + return TRUE; } /****************************************************************** - * SymInitialize (DBGHELP.@) + * check_live_target + * + */ +static BOOL check_live_target(struct process* pcs) +{ + if (!GetProcessId(pcs->handle)) return FALSE; + if (GetEnvironmentVariableA("DBGHELP_NOLIVE", NULL, 0)) return FALSE; + elf_read_wine_loader_dbg_info(pcs); + return TRUE; +} + +/****************************************************************** + * SymInitializeW (DBGHELP.@) * * The initialisation of a dbghelp's context. * Note that hProcess doesn't need to be a valid process handle (except * when fInvadeProcess is TRUE). - * Since, we're also allow to load ELF (pure) libraries and Wine ELF libraries + * Since, we're also allow to load ELF (pure) libraries and Wine ELF libraries * containing PE (and NE) module(s), here's how we handle it: * - we load every module (ELF, NE, PE) passed in SymLoadModule * - in fInvadeProcess (in SymInitialize) is TRUE, we set up what is called ELF @@ -168,19 +251,22 @@ static BOOL process_invade(HANDLE hProcess) * our internal ELF modules representation (loading / unloading). This way, * we'll pair every loaded builtin PE module with its ELF counterpart (and * access its debug information). - * - if fInvadeProcess (in SymInitialize) is FALSE, we won't be able to - * make the peering between a builtin PE module and its ELF counterpart, hence - * we won't be able to provide the requested debug information. We'll - * however be able to load native PE modules (and their debug information) - * without any trouble. - * Note also that this scheme can be intertwined with the deferred loading + * - if fInvadeProcess (in SymInitialize) is FALSE, we check anyway if the + * hProcess refers to a running process. We use some heuristics here, so YMMV. + * If we detect a live target, then we get the same handling as if + * fInvadeProcess is TRUE (except that the modules are not loaded). Otherwise, + * we won't be able to make the peering between a builtin PE module and its ELF + * counterpart. Hence we won't be able to provide the requested debug + * information. We'll however be able to load native PE modules (and their + * debug information) without any trouble. + * Note also that this scheme can be intertwined with the deferred loading * mechanism (ie only load the debug information when we actually need it). */ -BOOL WINAPI SymInitialize(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProcess) +BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeProcess) { struct process* pcs; - TRACE("(%p %s %u)\n", hProcess, debugstr_a(UserSearchPath), fInvadeProcess); + TRACE("(%p %s %u)\n", hProcess, debugstr_w(UserSearchPath), fInvadeProcess); if (process_find_by_handle(hProcess)) FIXME("what to do ??\n"); @@ -192,33 +278,36 @@ BOOL WINAPI SymInitialize(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProc if (UserSearchPath) { - pcs->search_path = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(UserSearchPath) + 1), - UserSearchPath); + pcs->search_path = lstrcpyW(HeapAlloc(GetProcessHeap(), 0, + (lstrlenW(UserSearchPath) + 1) * sizeof(WCHAR)), + UserSearchPath); } else { unsigned size; unsigned len; + static const WCHAR sym_path[] = {'_','N','T','_','S','Y','M','B','O','L','_','P','A','T','H',0}; + static const WCHAR alt_sym_path[] = {'_','N','T','_','A','L','T','E','R','N','A','T','E','_','S','Y','M','B','O','L','_','P','A','T','H',0}; - pcs->search_path = HeapAlloc(GetProcessHeap(), 0, len = MAX_PATH); - while ((size = GetCurrentDirectoryA(len, pcs->search_path)) >= len) - pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, len *= 2); - pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1); + pcs->search_path = HeapAlloc(GetProcessHeap(), 0, (len = MAX_PATH) * sizeof(WCHAR)); + while ((size = GetCurrentDirectoryW(len, pcs->search_path)) >= len) + pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (len *= 2) * sizeof(WCHAR)); + pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1) * sizeof(WCHAR)); - len = GetEnvironmentVariableA("_NT_SYMBOL_PATH", NULL, 0); + len = GetEnvironmentVariableW(sym_path, NULL, 0); if (len) { - pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1 + len + 1); + pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1 + len + 1) * sizeof(WCHAR)); pcs->search_path[size] = ';'; - GetEnvironmentVariableA("_NT_SYMBOL_PATH", pcs->search_path + size + 1, len); + GetEnvironmentVariableW(sym_path, pcs->search_path + size + 1, len); size += 1 + len; } - len = GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", NULL, 0); + len = GetEnvironmentVariableW(alt_sym_path, NULL, 0); if (len) { - pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, size + 1 + len + 1); + pcs->search_path = HeapReAlloc(GetProcessHeap(), 0, pcs->search_path, (size + 1 + len + 1) * sizeof(WCHAR)); pcs->search_path[size] = ';'; - GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", pcs->search_path + size + 1, len); + GetEnvironmentVariableW(alt_sym_path, pcs->search_path + size + 1, len); size += 1 + len; } } @@ -227,23 +316,47 @@ BOOL WINAPI SymInitialize(HANDLE hProcess, PSTR UserSearchPath, BOOL fInvadeProc pcs->dbg_hdr_addr = 0; pcs->next = process_first; process_first = pcs; - - if (fInvadeProcess) + + if (check_live_target(pcs)) { -#ifndef __REACTOS__ - if (!elf_read_wine_loader_dbg_info(pcs)) - { - SymCleanup(hProcess); - return FALSE; - } -#endif - process_invade(hProcess); + if (fInvadeProcess) + EnumerateLoadedModules(hProcess, process_invade_cb, hProcess); elf_synchronize_module_list(pcs); } - DbgPrint("SymInitialize - Success\n"); + else if (fInvadeProcess) + { + SymCleanup(hProcess); + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + return TRUE; } +/****************************************************************** + * SymInitialize (DBGHELP.@) + * + * + */ +BOOL WINAPI SymInitialize(HANDLE hProcess, PCSTR UserSearchPath, BOOL fInvadeProcess) +{ + WCHAR* sp = NULL; + BOOL ret; + + if (UserSearchPath) + { + unsigned len; + + len = MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, NULL, 0); + sp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, UserSearchPath, -1, sp, len); + } + + ret = SymInitializeW(hProcess, sp, fInvadeProcess); + HeapFree(GetProcessHeap(), 0, sp); + return ret; +} + /****************************************************************** * SymCleanup (DBGHELP.@) * @@ -275,6 +388,12 @@ BOOL WINAPI SymCleanup(HANDLE hProcess) */ DWORD WINAPI SymSetOptions(DWORD opts) { + struct process* pcs; + + for (pcs = process_first; pcs; pcs = pcs->next) + { + pcs_callback(pcs, CBA_SET_OPTIONS, &opts); + } return dbghelp_options = opts; } @@ -287,6 +406,17 @@ DWORD WINAPI SymGetOptions(void) return dbghelp_options; } +/****************************************************************** + * SymSetParentWindow (DBGHELP.@) + * + */ +BOOL WINAPI SymSetParentWindow(HWND hwnd) +{ + /* Save hwnd so it can be used as parent window */ + FIXME("(%p): stub\n", hwnd); + return TRUE; +} + /****************************************************************** * SymSetContext (DBGHELP.@) * @@ -297,21 +427,169 @@ BOOL WINAPI SymSetContext(HANDLE hProcess, PIMAGEHLP_STACK_FRAME StackFrame, struct process* pcs = process_find_by_handle(hProcess); if (!pcs) return FALSE; + if (pcs->ctx_frame.ReturnOffset == StackFrame->ReturnOffset && + pcs->ctx_frame.FrameOffset == StackFrame->FrameOffset && + pcs->ctx_frame.StackOffset == StackFrame->StackOffset) + { + TRACE("Setting same frame {rtn=%s frm=%s stk=%s}\n", + wine_dbgstr_longlong(pcs->ctx_frame.ReturnOffset), + wine_dbgstr_longlong(pcs->ctx_frame.FrameOffset), + wine_dbgstr_longlong(pcs->ctx_frame.StackOffset)); + pcs->ctx_frame.InstructionOffset = StackFrame->InstructionOffset; + SetLastError(ERROR_ACCESS_DENIED); /* latest MSDN says ERROR_SUCCESS */ + return FALSE; + } + pcs->ctx_frame = *StackFrame; /* MSDN states that Context is not (no longer?) used */ return TRUE; } +/****************************************************************** + * reg_cb64to32 (internal) + * + * Registered callback for converting information from 64 bit to 32 bit + */ +static BOOL CALLBACK reg_cb64to32(HANDLE hProcess, ULONG action, ULONG64 data, ULONG64 user) +{ + PSYMBOL_REGISTERED_CALLBACK cb32 = (PSYMBOL_REGISTERED_CALLBACK)(DWORD)(user >> 32); + DWORD user32 = (DWORD)user; + void* data32; + IMAGEHLP_DEFERRED_SYMBOL_LOAD64* idsl64; + IMAGEHLP_DEFERRED_SYMBOL_LOAD idsl; + + switch (action) + { + case CBA_DEBUG_INFO: + case CBA_DEFERRED_SYMBOL_LOAD_CANCEL: + case CBA_SET_OPTIONS: + case CBA_SYMBOLS_UNLOADED: + data32 = (void*)(DWORD)data; + break; + case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE: + case CBA_DEFERRED_SYMBOL_LOAD_FAILURE: + case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL: + case CBA_DEFERRED_SYMBOL_LOAD_START: + idsl64 = (IMAGEHLP_DEFERRED_SYMBOL_LOAD64*)(DWORD)data; + if (!validate_addr64(idsl64->BaseOfImage)) + return FALSE; + idsl.SizeOfStruct = sizeof(idsl); + idsl.BaseOfImage = (DWORD)idsl64->BaseOfImage; + idsl.CheckSum = idsl64->CheckSum; + idsl.TimeDateStamp = idsl64->TimeDateStamp; + memcpy(idsl.FileName, idsl64->FileName, sizeof(idsl.FileName)); + idsl.Reparse = idsl64->Reparse; + data32 = &idsl; + break; + case CBA_DUPLICATE_SYMBOL: + case CBA_EVENT: + case CBA_READ_MEMORY: + default: + FIXME("No mapping for action %u\n", action); + return FALSE; + } + return cb32(hProcess, action, data32, (PVOID)user32); +} + +/****************************************************************** + * pcs_callback (internal) + */ +BOOL pcs_callback(const struct process* pcs, ULONG action, void* data) +{ + TRACE("%p %u %p\n", pcs, action, data); + + if (!pcs->reg_cb) return FALSE; + if (!pcs->reg_is_unicode) + { + IMAGEHLP_DEFERRED_SYMBOL_LOAD64 idsl; + IMAGEHLP_DEFERRED_SYMBOL_LOADW64* idslW; + + switch (action) + { + case CBA_DEBUG_INFO: + case CBA_DEFERRED_SYMBOL_LOAD_CANCEL: + case CBA_SET_OPTIONS: + case CBA_SYMBOLS_UNLOADED: + break; + case CBA_DEFERRED_SYMBOL_LOAD_COMPLETE: + case CBA_DEFERRED_SYMBOL_LOAD_FAILURE: + case CBA_DEFERRED_SYMBOL_LOAD_PARTIAL: + case CBA_DEFERRED_SYMBOL_LOAD_START: + idslW = (IMAGEHLP_DEFERRED_SYMBOL_LOADW64*)(DWORD)data; + idsl.SizeOfStruct = sizeof(idsl); + idsl.BaseOfImage = idslW->BaseOfImage; + idsl.CheckSum = idslW->CheckSum; + idsl.TimeDateStamp = idslW->TimeDateStamp; + WideCharToMultiByte(CP_ACP, 0, idslW->FileName, -1, + idsl.FileName, sizeof(idsl.FileName), NULL, NULL); + idsl.Reparse = idslW->Reparse; + data = &idsl; + break; + case CBA_DUPLICATE_SYMBOL: + case CBA_EVENT: + case CBA_READ_MEMORY: + default: + FIXME("No mapping for action %u\n", action); + return FALSE; + } + } + return pcs->reg_cb(pcs->handle, action, (ULONG64)(DWORD_PTR)data, pcs->reg_user); +} + +/****************************************************************** + * sym_register_cb + * + * Helper for registering a callback. + */ +static BOOL sym_register_cb(HANDLE hProcess, + PSYMBOL_REGISTERED_CALLBACK64 cb, + DWORD64 user, BOOL unicode) +{ + struct process* pcs = process_find_by_handle(hProcess); + + if (!pcs) return FALSE; + pcs->reg_cb = cb; + pcs->reg_is_unicode = unicode; + pcs->reg_user = user; + + return TRUE; +} + /*********************************************************************** * SymRegisterCallback (DBGHELP.@) */ -BOOL WINAPI SymRegisterCallback(HANDLE hProcess, +BOOL WINAPI SymRegisterCallback(HANDLE hProcess, PSYMBOL_REGISTERED_CALLBACK CallbackFunction, PVOID UserContext) { - FIXME("(%p, %p, %p): stub\n", hProcess, CallbackFunction, UserContext); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + DWORD64 tmp = ((ULONGLONG)(DWORD)CallbackFunction << 32) | (DWORD)UserContext; + TRACE("(%p, %p, %p)\n", + hProcess, CallbackFunction, UserContext); + return sym_register_cb(hProcess, reg_cb64to32, tmp, FALSE); +} + +/*********************************************************************** + * SymRegisterCallback64 (DBGHELP.@) + */ +BOOL WINAPI SymRegisterCallback64(HANDLE hProcess, + PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, + ULONG64 UserContext) +{ + TRACE("(%p, %p, %s)\n", + hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext)); + return sym_register_cb(hProcess, CallbackFunction, UserContext, FALSE); +} + +/*********************************************************************** + * SymRegisterCallbackW64 (DBGHELP.@) + */ +BOOL WINAPI SymRegisterCallbackW64(HANDLE hProcess, + PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction, + ULONG64 UserContext) +{ + TRACE("(%p, %p, %s)\n", + hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext)); + return sym_register_cb(hProcess, CallbackFunction, UserContext, TRUE); } /* This is imagehlp version not dbghelp !! */ @@ -339,3 +617,20 @@ LPAPI_VERSION WINAPI ImagehlpApiVersionEx(LPAPI_VERSION AppVersion) return AppVersion; } + +/****************************************************************** + * ExtensionApiVersion (DBGHELP.@) + */ +LPEXT_API_VERSION WINAPI ExtensionApiVersion(void) +{ + static EXT_API_VERSION eav = {5, 5, 5, 0}; + return &eav; +} + +/****************************************************************** + * WinDbgExtensionDllInit (DBGHELP.@) + */ +void WINAPI WinDbgExtensionDllInit(PWINDBG_EXTENSION_APIS lpExtensionApis, + unsigned short major, unsigned short minor) +{ +} diff --git a/reactos/dll/win32/dbghelp/dbghelp.rbuild b/reactos/dll/win32/dbghelp/dbghelp.rbuild index 025b972e66f..0039f495a48 100644 --- a/reactos/dll/win32/dbghelp/dbghelp.rbuild +++ b/reactos/dll/win32/dbghelp/dbghelp.rbuild @@ -3,8 +3,10 @@ . include/reactos/wine 0x600 - 0x501 - 0x501 + 0x502 + 0x502 + + wine pseh ntdll @@ -12,6 +14,7 @@ psapi coff.c dbghelp.c + dwarf.c elf_module.c image.c memory.c diff --git a/reactos/dll/win32/dbghelp/dbghelp.spec b/reactos/dll/win32/dbghelp/dbghelp.spec index 2f39f63391e..b023f3d70e3 100644 --- a/reactos/dll/win32/dbghelp/dbghelp.spec +++ b/reactos/dll/win32/dbghelp/dbghelp.spec @@ -1,13 +1,17 @@ @ stub DbgHelpCreateUserDump @ stub DbgHelpCreateUserDumpW @ stdcall EnumDirTree(long str str ptr ptr ptr) +@ stdcall EnumDirTreeW(long wstr wstr ptr ptr ptr) @ stdcall EnumerateLoadedModules(long ptr ptr) -@ stub EnumerateLoadedModules64 -@ stub ExtensionApiVersion +@ stdcall EnumerateLoadedModules64(long ptr ptr) +@ stdcall EnumerateLoadedModulesW64(long ptr ptr) +@ stdcall ExtensionApiVersion() @ stdcall FindDebugInfoFile(str str ptr) @ stdcall FindDebugInfoFileEx(str str ptr ptr ptr) +@ stub FindDebugInfoFileExW @ stdcall FindExecutableImage(str str str) -@ stub FindExecutableImageEx +@ stdcall FindExecutableImageEx(str str ptr ptr ptr) +@ stdcall FindExecutableImageExW(wstr wstr ptr ptr ptr) @ stub FindFileInPath @ stub FindFileInSearchPath @ stdcall GetTimestampForLoadedLibrary(long) @@ -20,80 +24,163 @@ @ stdcall ImagehlpApiVersionEx(ptr) @ stdcall MakeSureDirectoryPathExists(str) @ stdcall MapDebugInformation(long str str long) -@ stub MiniDumpReadDumpStream +@ stdcall MiniDumpReadDumpStream(ptr long ptr ptr ptr) @ stdcall MiniDumpWriteDump(ptr long ptr long long long long) -@ stdcall SearchTreeForFile(str str str) +@ stdcall SearchTreeForFile(str str ptr) +@ stdcall SearchTreeForFileW(wstr wstr ptr) @ stdcall StackWalk(long long long ptr ptr ptr ptr ptr ptr) -@ stub StackWalk64 +@ stdcall StackWalk64(long long long ptr ptr ptr ptr ptr ptr) +@ stub SymAddSymbol +@ stub SymAddSymbolW @ stdcall SymCleanup(long) -@ stdcall SymEnumSourceFiles(ptr long long str ptr ptr) +@ stdcall SymEnumLines(ptr double str str ptr ptr) +@ stub SymEnumLinesW +@ stdcall SymEnumSourceFiles(ptr double str ptr ptr) +@ stub SymEnumSourceFilesW @ stub SymEnumSym -@ stdcall SymEnumSymbols(ptr long long str ptr ptr) -@ stdcall SymEnumTypes(ptr long long ptr ptr) +@ stdcall SymEnumSymbols(ptr double str ptr ptr) +@ stdcall SymEnumSymbolsW(ptr double wstr ptr ptr) +@ stub SymEnumSymbolsForAddr +@ stub SymEnumSymbolsForAddrW +@ stdcall SymEnumTypes(ptr double ptr ptr) +@ stdcall SymEnumTypesW(ptr double ptr ptr) @ stdcall SymEnumerateModules(long ptr ptr) -@ stub SymEnumerateModules64 +@ stdcall SymEnumerateModules64(long ptr ptr) +@ stdcall SymEnumerateModulesW64(long ptr ptr) @ stdcall SymEnumerateSymbols(long long ptr ptr) @ stub SymEnumerateSymbols64 @ stub SymEnumerateSymbolsW @ stub SymEnumerateSymbolsW64 +@ stub SymFindDebugInfoFile +@ stub SymFindDebugInfoFileW @ stdcall SymFindFileInPath(long str str ptr long long long ptr ptr ptr) -@ stdcall SymFromAddr(ptr long long ptr ptr) +@ stdcall SymFindFileInPathW(long wstr wstr ptr long long long ptr ptr ptr) +@ stdcall SymFromAddr(ptr double ptr ptr) +@ stdcall SymFromAddrW(ptr double ptr ptr) +@ stub SymFromIndex +@ stub SymFromIndexW @ stdcall SymFromName(long str ptr) +@ stub SymFromNameW +@ stub SymFromToken +@ stub SymFromTokenW @ stdcall SymFunctionTableAccess(long long) -@ stub SymFunctionTableAccess64 +@ stdcall SymFunctionTableAccess64(long double) @ stub SymGetFileLineOffsets64 +@ stub SymGetHomeDirectory +@ stub SymGetHomeDirectoryW @ stdcall SymGetLineFromAddr(long long ptr ptr) -@ stub SymGetLineFromAddr64 +@ stdcall SymGetLineFromAddr64(long double ptr ptr) +@ stdcall SymGetLineFromAddrW64(long double ptr ptr) @ stub SymGetLineFromName @ stub SymGetLineFromName64 @ stdcall SymGetLineNext(long ptr) -@ stub SymGetLineNext64 +@ stdcall SymGetLineNext64(long ptr) +@ stub SymGetLineNextW64 @ stdcall SymGetLinePrev(long ptr) -@ stub SymGetLinePrev64 +@ stdcall SymGetLinePrev64(long ptr) +@ stub SymGetLinePrevW64 @ stdcall SymGetModuleBase(long long) -@ stub SymGetModuleBase64 +@ stdcall SymGetModuleBase64(long double) @ stdcall SymGetModuleInfo(long long ptr) -@ stub SymGetModuleInfo64 -@ stub SymGetModuleInfoW -@ stub SymGetModuleInfoW64 +@ stdcall SymGetModuleInfo64(long double ptr) +@ stdcall SymGetModuleInfoW(long long ptr) +@ stdcall SymGetModuleInfoW64(long double ptr) +@ stub SymGetOmapBlockBase @ stdcall SymGetOptions() -@ stdcall SymGetSearchPath(long str long) +@ stub SymGetScope +@ stub SymGetScopeW +@ stdcall SymGetSearchPath(long ptr long) +@ stdcall SymGetSearchPathW(long ptr long) +@ stub SymGetSourceFileFromToken +@ stub SymGetSourceFileFromTokenW +@ stdcall SymGetSourceFileToken(ptr double str ptr ptr) +@ stdcall SymGetSourceFileTokenW(ptr double wstr ptr ptr) +@ stub SymGetSourceFileW +@ stub SymGetSourceVarFromToken +@ stub SymGetSourceVarFromTokenW @ stdcall SymGetSymFromAddr(long long ptr ptr) -@ stub SymGetSymFromAddr64 +@ stdcall SymGetSymFromAddr64(long double ptr ptr) @ stdcall SymGetSymFromName(long str ptr) @ stub SymGetSymFromName64 @ stdcall SymGetSymNext(long ptr) @ stub SymGetSymNext64 @ stdcall SymGetSymPrev(long ptr) @ stub SymGetSymPrev64 -@ stdcall SymGetTypeFromName(ptr long long str ptr) -@ stdcall SymGetTypeInfo(ptr long long long long ptr) +@ stub SymGetSymbolFile +@ stub SymGetSymbolFileW +@ stdcall SymGetTypeFromName(ptr double str ptr) +@ stub SymGetTypeFromNameW +@ stdcall SymGetTypeInfo(ptr double long long ptr) +@ stub SymGetTypeInfoEx @ stdcall SymInitialize(long str long) +@ stdcall SymInitializeW(long wstr long) @ stdcall SymLoadModule(long long str str long long) -@ stub SymLoadModule64 -@ stub SymLoadModuleEx +@ stdcall SymLoadModule64(long long str str double long) +@ stdcall SymLoadModuleEx(long long str str double long ptr long) +@ stdcall SymLoadModuleExW(long long wstr wstr double long ptr long) @ stdcall SymMatchFileName(str str ptr ptr) -@ stub SymMatchString +@ stdcall SymMatchFileNameW(wstr wstr ptr ptr) +@ stdcall SymMatchString(str str long) +@ stub SymMatchStringA +@ stub SymMatchStringW +@ stub SymNext +@ stub SymNextW +@ stub SymPrev +@ stub SymPrevW +@ stub SymRefreshModuleList @ stdcall SymRegisterCallback(long ptr ptr) -@ stub SymRegisterCallback64 -@ stub SymRegisterFunctionEntryCallback -@ stub SymRegisterFunctionEntryCallback64 +@ stdcall SymRegisterCallback64(long ptr double) +@ stdcall SymRegisterCallbackW64(long ptr double) +@ stdcall SymRegisterFunctionEntryCallback(ptr ptr ptr) +@ stdcall SymRegisterFunctionEntryCallback64(ptr ptr double) +@ stdcall SymSearch(long double long long str double ptr ptr long) +@ stdcall SymSearchW(long double long long wstr double ptr ptr long) @ stdcall SymSetContext(long ptr ptr) +@ stub SymSetHomeDirectory +@ stub SymSetHomeDirectoryW @ stdcall SymSetOptions(long) +@ stdcall SymSetParentWindow(long) @ stdcall SymSetSearchPath(long str) +@ stdcall SymSetSearchPathW(long wstr) @ stub SymSetSymWithAddr64 +@ stub SymSrvDeltaName +@ stub SymSrvDeltaNameW +@ stub SymSrvGetFileIndexInfo +@ stub SymSrvGetFileIndexInfoW +@ stub SymSrvGetFileIndexString +@ stub SymSrvGetFileIndexStringW +@ stub SymSrvGetFileIndexes +@ stub SymSrvGetFileIndexesW +@ stub SymSrvGetSupplement +@ stub SymSrvGetSupplementW +@ stub SymSrvIsStore +@ stub SymSrvIsStoreW +@ stub SymSrvStoreFile +@ stub SymSrvStoreFileW +@ stub SymSrvStoreSupplement +@ stub SymSrvStoreSupplementW +# @ stub SymSetSymWithAddr64 no longer present ?? @ stdcall SymUnDName(ptr str long) @ stub SymUnDName64 @ stdcall SymUnloadModule(long long) -@ stub SymUnloadModule64 +@ stdcall SymUnloadModule64(long double) @ stdcall UnDecorateSymbolName(str str long long) +@ stub UnDecorateSymbolNameW @ stdcall UnmapDebugInformation(ptr) -@ stub WinDbgExtensionDllInit +@ stdcall WinDbgExtensionDllInit(ptr long long) +#@ stub block +#@ stub chksym #@ stub dbghelp #@ stub dh -#@ stub lm +#@ stub fptr +#@ stub homedir +#@ stub itoldyouso #@ stub lmi +#@ stub lminfo #@ stub omap #@ stub srcfiles +#@ stub stack_force_ebp +#@ stub stackdbg #@ stub sym +#@ stub symsrv #@ stub vc7fpo diff --git a/reactos/dll/win32/dbghelp/dbghelp_private.h b/reactos/dll/win32/dbghelp/dbghelp_private.h index 76a47e914d9..99b8b542f9d 100644 --- a/reactos/dll/win32/dbghelp/dbghelp_private.h +++ b/reactos/dll/win32/dbghelp/dbghelp_private.h @@ -4,7 +4,7 @@ * Copyright (C) 1995, Alexandre Julliard * Copyright (C) 1996, Eric Youngdale. * Copyright (C) 1999-2000, Ulrich Weigand. - * Copyright (C) 2004, Eric Pouech. + * Copyright (C) 2004-2007, Eric Pouech. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,10 +18,9 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#define WIN32_NO_STATUS #include #include "windef.h" #include "winbase.h" @@ -29,6 +28,8 @@ #include "dbghelp.h" #include "objbase.h" #include "oaidl.h" +#include "winnls.h" +#include "wine/unicode.h" #include "cvconst.h" @@ -43,8 +44,6 @@ struct pool /* poor's man */ void pool_init(struct pool* a, unsigned arena_size); void pool_destroy(struct pool* a); void* pool_alloc(struct pool* a, unsigned len); -/* void* pool_realloc(struct pool* a, void* p, - unsigned old_size, unsigned new_size); */ char* pool_strdup(struct pool* a, const char* str); struct vector @@ -54,15 +53,24 @@ struct vector unsigned shift; unsigned num_elts; unsigned num_buckets; + unsigned buckets_allocated; }; void vector_init(struct vector* v, unsigned elt_sz, unsigned bucket_sz); unsigned vector_length(const struct vector* v); void* vector_at(const struct vector* v, unsigned pos); void* vector_add(struct vector* v, struct pool* pool); -/*void vector_pool_normalize(struct vector* v, struct pool* pool); */ -void* vector_iter_up(const struct vector* v, void* elt); -void* vector_iter_down(const struct vector* v, void* elt); + +struct sparse_array +{ + struct vector key2index; + struct vector elements; +}; + +void sparse_array_init(struct sparse_array* sa, unsigned elt_sz, unsigned bucket_sz); +void* sparse_array_find(const struct sparse_array* sa, unsigned long idx); +void* sparse_array_add(struct sparse_array* sa, unsigned long key, struct pool* pool); +unsigned sparse_array_length(const struct sparse_array* sa); struct hash_table_elt { @@ -72,8 +80,10 @@ struct hash_table_elt struct hash_table { + unsigned num_elts; unsigned num_buckets; struct hash_table_elt** buckets; + struct pool* pool; }; void hash_table_init(struct pool* pool, struct hash_table* ht, @@ -103,6 +113,27 @@ extern unsigned dbghelp_options; /* some more Wine extensions */ #define SYMOPT_WINE_WITH_ELF_MODULES 0x40000000 +enum location_kind {loc_error, /* reg is the error code */ + loc_absolute, /* offset is the location */ + loc_register, /* reg is the location */ + loc_regrel, /* [reg+offset] is the location */ + loc_user, /* value is debug information dependent, + reg & offset can be used ad libidem */ +}; + +enum location_error {loc_err_internal = -1, /* internal while computing */ + loc_err_too_complex = -2, /* couldn't compute location (even at runtime) */ + loc_err_out_of_scope = -3, /* variable isn't available at current address */ + loc_err_cant_read = -4, /* couldn't read memory at given address */ +}; + +struct location +{ + unsigned kind : 8, + reg; + unsigned long offset; +}; + struct symt { enum SymTagEnum tag; @@ -127,6 +158,7 @@ struct symt_block struct symt_compiland { struct symt symt; + unsigned long address; unsigned source; struct vector vchildren; /* global variables & functions */ }; @@ -140,14 +172,25 @@ struct symt_data struct symt* type; union /* depends on kind */ { - unsigned long address; /* DataIs{Global, FileStatic} */ + /* DataIs{Global, FileStatic}: + * loc.kind is loc_absolute + * loc.offset is address + * DataIs{Local,Param}: + * with loc.kind + * loc_absolute not supported + * loc_register location is in register loc.reg + * loc_regrel location is at address loc.reg + loc.offset + * >= loc_user ask debug info provider for resolution + */ + struct location var; + /* DataIs{Member} (all values are in bits, not bytes) */ struct { - long offset; /* DataIs{Member,Local,Param} in bits*/ - unsigned long length; /* DataIs{Member} in bits */ - unsigned long reg_id; /* DataIs{Local} (0 if frame relative) */ - } s; - VARIANT value; /* DataIsConstant */ + long offset; + unsigned long length; + } member; + /* DataIsConstant */ + VARIANT value; } u; }; @@ -167,7 +210,7 @@ struct symt_function_point { struct symt symt; /* either SymTagFunctionDebugStart, SymTagFunctionDebugEnd, SymTagLabel */ struct symt_function* parent; - unsigned long offset; + struct location loc; const char* name; /* for labels */ }; @@ -198,7 +241,8 @@ struct symt_array struct symt symt; int start; int end; - struct symt* basetype; + struct symt* base_type; + struct symt* index_type; }; struct symt_basic @@ -221,6 +265,14 @@ struct symt_function_signature struct symt symt; struct symt* rettype; struct vector vchildren; + enum CV_call_e call_conv; +}; + +struct symt_function_arg_type +{ + struct symt symt; + struct symt* arg_type; + struct symt* container; }; struct symt_pointer @@ -250,22 +302,36 @@ enum module_type DMT_UNKNOWN, /* for lookup, not actually used for a module */ DMT_ELF, /* a real ELF shared module */ DMT_PE, /* a native or builtin PE module */ + DMT_PDB, /* PDB file */ }; +struct process; + struct module { - IMAGEHLP_MODULE module; + IMAGEHLP_MODULEW64 module; + /* ANSI copy of module.ModuleName for efficiency */ + char module_name[MAX_PATH]; struct module* next; - enum module_type type; + enum module_type type : 16; + unsigned short is_virtual : 1; + + /* specific information for debug types */ struct elf_module_info* elf_info; + struct dwarf2_module_info_s*dwarf2_info; /* memory allocation pool */ struct pool pool; - /* symbol tables */ + /* symbols & symbol tables */ int sortlist_valid; + unsigned num_sorttab; /* number of symbols with addresses */ struct symt_ht** addr_sorttab; struct hash_table ht_symbols; + void (*loc_compute)(struct process* pcs, + const struct module* module, + const struct symt_function* func, + struct location* loc); /* types */ struct hash_table ht_types; @@ -277,71 +343,147 @@ struct module char* sources; }; -struct process +struct process { struct process* next; HANDLE handle; - char* search_path; + WCHAR* search_path; + + PSYMBOL_REGISTERED_CALLBACK64 reg_cb; + BOOL reg_is_unicode; + DWORD64 reg_user; struct module* lmodules; unsigned long dbg_hdr_addr; IMAGEHLP_STACK_FRAME ctx_frame; + + unsigned buffer_size; + void* buffer; +}; + +struct line_info +{ + unsigned long is_first : 1, + is_last : 1, + is_source_file : 1, + line_number; + union + { + unsigned long pc_offset; /* if is_source_file isn't set */ + unsigned source_file; /* if is_source_file is set */ + } u; +}; + +struct module_pair +{ + struct process* pcs; + struct module* requested; /* in: to module_get_debug() */ + struct module* effective; /* out: module with debug info */ +}; + +enum pdb_kind {PDB_JG, PDB_DS}; + +struct pdb_lookup +{ + const char* filename; + DWORD age; + enum pdb_kind kind; + union + { + struct + { + DWORD timestamp; + struct PDB_JG_TOC* toc; + } jg; + struct + { + GUID guid; + struct PDB_DS_TOC* toc; + } ds; + } u; }; /* dbghelp.c */ extern struct process* process_find_by_handle(HANDLE hProcess); extern HANDLE hMsvcrt; +extern BOOL validate_addr64(DWORD64 addr); +extern BOOL pcs_callback(const struct process* pcs, ULONG action, void* data); +extern void* fetch_buffer(struct process* pcs, unsigned size); /* elf_module.c */ -extern BOOL elf_load_debug_info(struct module* module); +#define ELF_NO_MAP ((const void*)0xffffffff) +typedef BOOL (*elf_enum_modules_cb)(const WCHAR*, unsigned long addr, void* user); +extern BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb, void*); +extern BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base, DWORD* size, DWORD* checksum); +struct elf_file_map; +extern BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap); extern struct module* - elf_load_module(struct process* pcs, const char* name); + elf_load_module(struct process* pcs, const WCHAR* name, unsigned long); extern BOOL elf_read_wine_loader_dbg_info(struct process* pcs); extern BOOL elf_synchronize_module_list(struct process* pcs); - +struct elf_thunk_area; +extern int elf_is_in_thunk_area(unsigned long addr, const struct elf_thunk_area* thunks); extern DWORD WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS* addr); /* module.c */ +extern const WCHAR S_ElfW[]; +extern const WCHAR S_WineLoaderW[]; +extern const WCHAR S_WinePThreadW[]; +extern const WCHAR S_WineKThreadW[]; +extern const WCHAR S_SlashW[]; + extern struct module* module_find_by_addr(const struct process* pcs, unsigned long addr, enum module_type type); extern struct module* module_find_by_name(const struct process* pcs, - const char* name, enum module_type type); + const WCHAR* name); extern struct module* - module_get_debug(const struct process* pcs, struct module*); + module_find_by_nameA(const struct process* pcs, + const char* name); extern struct module* - module_new(struct process* pcs, const char* name, - enum module_type type, unsigned long addr, - unsigned long size, unsigned long stamp, - unsigned long checksum); + module_is_already_loaded(const struct process* pcs, + const WCHAR* imgname); +extern BOOL module_get_debug(struct module_pair*); +extern struct module* + module_new(struct process* pcs, const WCHAR* name, + enum module_type type, BOOL virtual, + unsigned long addr, unsigned long size, + unsigned long stamp, unsigned long checksum); extern struct module* module_get_container(const struct process* pcs, const struct module* inner); extern struct module* module_get_containee(const struct process* pcs, const struct module* inner); +extern enum module_type + module_get_type_by_name(const WCHAR* name); extern void module_reset_debug_info(struct module* module); extern BOOL module_remove(struct process* pcs, struct module* module); +extern void module_set_module(struct module* module, const WCHAR* name); + /* msc.c */ extern BOOL pe_load_debug_directory(const struct process* pcs, - struct module* module, + struct module* module, const BYTE* mapping, const IMAGE_SECTION_HEADER* sectp, DWORD nsect, const IMAGE_DEBUG_DIRECTORY* dbg, int nDbg); +extern BOOL pdb_fetch_file_info(struct pdb_lookup* pdb_lookup); + /* pe_module.c */ +extern BOOL pe_load_nt_header(HANDLE hProc, DWORD base, IMAGE_NT_HEADERS* nth); extern struct module* - pe_load_module(struct process* pcs, char* name, - HANDLE hFile, DWORD base, DWORD size); + pe_load_native_module(struct process* pcs, const WCHAR* name, + HANDLE hFile, DWORD base, DWORD size); extern struct module* - pe_load_module_from_pcs(struct process* pcs, const char* name, - const char* mod_name, DWORD base, DWORD size); + pe_load_builtin_module(struct process* pcs, const WCHAR* name, + DWORD base, DWORD size); extern BOOL pe_load_debug_info(const struct process* pcs, struct module* module); /* source.c */ -extern unsigned source_new(struct module* module, const char* source); +extern unsigned source_new(struct module* module, const char* basedir, const char* source); extern const char* source_get(const struct module* module, unsigned idx); /* stabs.c */ @@ -349,24 +491,35 @@ extern BOOL stabs_parse(struct module* module, unsigned long load_offset const void* stabs, int stablen, const char* strs, int strtablen); +/* dwarf.c */ +extern BOOL dwarf2_parse(struct module* module, unsigned long load_offset, + const struct elf_thunk_area* thunks, + const unsigned char* debug, unsigned int debug_size, + const unsigned char* abbrev, unsigned int abbrev_size, + const unsigned char* str, unsigned int str_size, + const unsigned char* line, unsigned int line_size, + const unsigned char* loclist, unsigned int loclist_size); + /* symbol.c */ extern const char* symt_get_name(const struct symt* sym); extern int symt_cmp_addr(const void* p1, const void* p2); -extern int symt_find_nearest(struct module* module, DWORD addr); +extern void copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si); +extern struct symt_ht* + symt_find_nearest(struct module* module, DWORD addr); extern struct symt_compiland* - symt_new_compiland(struct module* module, - const char* filename); + symt_new_compiland(struct module* module, unsigned long address, + unsigned src_idx); extern struct symt_public* - symt_new_public(struct module* module, - struct symt_compiland* parent, + symt_new_public(struct module* module, + struct symt_compiland* parent, const char* typename, unsigned long address, unsigned size, BOOL in_code, BOOL is_func); extern struct symt_data* - symt_new_global_variable(struct module* module, + symt_new_global_variable(struct module* module, struct symt_compiland* parent, const char* name, unsigned is_static, - unsigned long addr, unsigned long size, + unsigned long addr, unsigned long size, struct symt* type); extern struct symt_function* symt_new_function(struct module* module, @@ -374,76 +527,83 @@ extern struct symt_function* const char* name, unsigned long addr, unsigned long size, struct symt* type); -extern BOOL symt_normalize_function(struct module* module, +extern BOOL symt_normalize_function(struct module* module, struct symt_function* func); extern void symt_add_func_line(struct module* module, - struct symt_function* func, - unsigned source_idx, int line_num, + struct symt_function* func, + unsigned source_idx, int line_num, unsigned long offset); extern struct symt_data* - symt_add_func_local(struct module* module, - struct symt_function* func, - int regno, int offset, + symt_add_func_local(struct module* module, + struct symt_function* func, + enum DataKind dt, const struct location* loc, struct symt_block* block, struct symt* type, const char* name); extern struct symt_block* - symt_open_func_block(struct module* module, + symt_open_func_block(struct module* module, struct symt_function* func, - struct symt_block* block, + struct symt_block* block, unsigned pc, unsigned len); extern struct symt_block* - symt_close_func_block(struct module* module, + symt_close_func_block(struct module* module, struct symt_function* func, struct symt_block* block, unsigned pc); extern struct symt_function_point* - symt_add_function_point(struct module* module, + symt_add_function_point(struct module* module, struct symt_function* func, - enum SymTagEnum point, - unsigned offset, const char* name); -extern BOOL symt_fill_func_line_info(struct module* module, - struct symt_function* func, + enum SymTagEnum point, + const struct location* loc, + const char* name); +extern BOOL symt_fill_func_line_info(const struct module* module, + const struct symt_function* func, DWORD addr, IMAGEHLP_LINE* line); -extern BOOL symt_get_func_line_next(struct module* module, PIMAGEHLP_LINE line); +extern BOOL symt_get_func_line_next(const struct module* module, PIMAGEHLP_LINE line); extern struct symt_thunk* - symt_new_thunk(struct module* module, + symt_new_thunk(struct module* module, struct symt_compiland* parent, const char* name, THUNK_ORDINAL ord, unsigned long addr, unsigned long size); +extern struct symt_data* + symt_new_constant(struct module* module, + struct symt_compiland* parent, + const char* name, struct symt* type, + const VARIANT* v); /* type.c */ extern void symt_init_basic(struct module* module); extern BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo); extern struct symt_basic* - symt_new_basic(struct module* module, enum BasicType, + symt_new_basic(struct module* module, enum BasicType, const char* typename, unsigned size); extern struct symt_udt* symt_new_udt(struct module* module, const char* typename, unsigned size, enum UdtKind kind); extern BOOL symt_set_udt_size(struct module* module, struct symt_udt* type, unsigned size); -extern BOOL symt_add_udt_element(struct module* module, - struct symt_udt* udt_type, +extern BOOL symt_add_udt_element(struct module* module, + struct symt_udt* udt_type, const char* name, - struct symt* elt_type, unsigned offset, + struct symt* elt_type, unsigned offset, unsigned size); extern struct symt_enum* symt_new_enum(struct module* module, const char* typename); -extern BOOL symt_add_enum_element(struct module* module, - struct symt_enum* enum_type, +extern BOOL symt_add_enum_element(struct module* module, + struct symt_enum* enum_type, const char* name, int value); extern struct symt_array* - symt_new_array(struct module* module, int min, int max, - struct symt* base); + symt_new_array(struct module* module, int min, int max, + struct symt* base, struct symt* index); extern struct symt_function_signature* - symt_new_function_signature(struct module* module, - struct symt* ret_type); + symt_new_function_signature(struct module* module, + struct symt* ret_type, + enum CV_call_e call_conv); extern BOOL symt_add_function_signature_parameter(struct module* module, struct symt_function_signature* sig, struct symt* param); extern struct symt_pointer* - symt_new_pointer(struct module* module, + symt_new_pointer(struct module* module, struct symt* ref_type); extern struct symt_typedef* - symt_new_typedef(struct module* module, struct symt* ref, + symt_new_typedef(struct module* module, struct symt* ref, const char* name); diff --git a/reactos/dll/win32/dbghelp/dwarf.c b/reactos/dll/win32/dbghelp/dwarf.c new file mode 100644 index 00000000000..66c761c3626 --- /dev/null +++ b/reactos/dll/win32/dbghelp/dwarf.c @@ -0,0 +1,2227 @@ +/* + * File dwarf.c - read dwarf2 information from the ELF modules + * + * Copyright (C) 2005, Raphael Junqueira + * Copyright (C) 2006, Eric Pouech + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "config.h" + +#include +#include +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef HAVE_SYS_MMAN_H +#include +#endif +#include +#include +#include +#ifdef HAVE_UNISTD_H +# include +#endif +#include +#ifndef PATH_MAX +#define PATH_MAX MAX_PATH +#endif +#include +#include + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "ole2.h" +#include "oleauto.h" + +#include "dbghelp_private.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_dwarf); + +/* FIXME: + * - Functions: + * o unspecified parameters + * o inlined functions + * o Debug{Start|End}Point + * o CFA + * - Udt + * o proper types loading (nesting) + */ + +#if 0 +static void dump(const void* ptr, unsigned len) +{ + int i, j; + BYTE msg[128]; + static const char hexof[] = "0123456789abcdef"; + const BYTE* x = (const BYTE*)ptr; + + for (i = 0; i < len; i += 16) + { + sprintf(msg, "%08x: ", i); + memset(msg + 10, ' ', 3 * 16 + 1 + 16); + for (j = 0; j < min(16, len - i); j++) + { + msg[10 + 3 * j + 0] = hexof[x[i + j] >> 4]; + msg[10 + 3 * j + 1] = hexof[x[i + j] & 15]; + msg[10 + 3 * j + 2] = ' '; + msg[10 + 3 * 16 + 1 + j] = (x[i + j] >= 0x20 && x[i + j] < 0x7f) ? + x[i + j] : '.'; + } + msg[10 + 3 * 16] = ' '; + msg[10 + 3 * 16 + 1 + 16] = '\0'; + TRACE("%s\n", msg); + } +} +#endif + +/** + * + * Main Specs: + * http://www.eagercon.com/dwarf/dwarf3std.htm + * http://www.eagercon.com/dwarf/dwarf-2.0.0.pdf + * + * dwarf2.h: http://www.hakpetzna.com/b/binutils/dwarf2_8h-source.html + * + * example of projects who do dwarf2 parsing: + * http://www.x86-64.org/cgi-bin/cvsweb.cgi/binutils.dead/binutils/readelf.c?rev=1.1.1.2 + * http://elis.ugent.be/diota/log/ltrace_elf.c + */ +#include "dwarf.h" + +/** + * Parsers + */ + +typedef struct dwarf2_abbrev_entry_attr_s +{ + unsigned long attribute; + unsigned long form; + struct dwarf2_abbrev_entry_attr_s* next; +} dwarf2_abbrev_entry_attr_t; + +typedef struct dwarf2_abbrev_entry_s +{ + unsigned long entry_code; + unsigned long tag; + unsigned char have_child; + unsigned num_attr; + dwarf2_abbrev_entry_attr_t* attrs; +} dwarf2_abbrev_entry_t; + +struct dwarf2_block +{ + unsigned size; + const unsigned char* ptr; +}; + +struct attribute +{ + unsigned long form; + union + { + unsigned long uvalue; + long svalue; + const char* string; + struct dwarf2_block block; + } u; +}; + +typedef struct dwarf2_debug_info_s +{ + const dwarf2_abbrev_entry_t*abbrev; + struct symt* symt; + const unsigned char** data; + struct vector children; +} dwarf2_debug_info_t; + +typedef struct dwarf2_section_s +{ + const unsigned char* address; + unsigned size; +} dwarf2_section_t; + +enum dwarf2_sections {section_debug, section_string, section_abbrev, section_line, section_max}; + +typedef struct dwarf2_traverse_context_s +{ + const unsigned char* data; + const unsigned char* start_data; + const unsigned char* end_data; + unsigned char word_size; +} dwarf2_traverse_context_t; + +typedef struct dwarf2_parse_context_s +{ + const dwarf2_section_t* sections; + unsigned section; + struct pool pool; + struct module* module; + const struct elf_thunk_area*thunks; + struct sparse_array abbrev_table; + struct sparse_array debug_info_table; + unsigned long load_offset; + unsigned long ref_offset; + unsigned char word_size; +} dwarf2_parse_context_t; + +/* stored in the dbghelp's module internal structure for later reuse */ +struct dwarf2_module_info_s +{ + dwarf2_section_t debug_loc; +}; + +#define loc_dwarf2_location_list (loc_user + 0) +#define loc_dwarf2_block (loc_user + 1) + +/* forward declarations */ +static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx, dwarf2_debug_info_t* entry); + +static unsigned char dwarf2_get_byte(const unsigned char* ptr) +{ + return *ptr; +} + +static unsigned char dwarf2_parse_byte(dwarf2_traverse_context_t* ctx) +{ + unsigned char uvalue = dwarf2_get_byte(ctx->data); + ctx->data += 1; + return uvalue; +} + +static unsigned short dwarf2_get_u2(const unsigned char* ptr) +{ + return *(const unsigned short*)ptr; +} + +static unsigned short dwarf2_parse_u2(dwarf2_traverse_context_t* ctx) +{ + unsigned short uvalue = dwarf2_get_u2(ctx->data); + ctx->data += 2; + return uvalue; +} + +static unsigned long dwarf2_get_u4(const unsigned char* ptr) +{ + return *(const unsigned long*)ptr; +} + +static unsigned long dwarf2_parse_u4(dwarf2_traverse_context_t* ctx) +{ + unsigned long uvalue = dwarf2_get_u4(ctx->data); + ctx->data += 4; + return uvalue; +} + +static unsigned long dwarf2_get_leb128_as_unsigned(const unsigned char* ptr, const unsigned char** end) +{ + unsigned long ret = 0; + unsigned char byte; + unsigned shift = 0; + + do + { + byte = dwarf2_get_byte(ptr++); + ret |= (byte & 0x7f) << shift; + shift += 7; + } while (byte & 0x80); + + if (end) *end = ptr; + return ret; +} + +static unsigned long dwarf2_leb128_as_unsigned(dwarf2_traverse_context_t* ctx) +{ + unsigned long ret; + + assert(ctx); + + ret = dwarf2_get_leb128_as_unsigned(ctx->data, &ctx->data); + + return ret; +} + +static long dwarf2_get_leb128_as_signed(const unsigned char* ptr, const unsigned char** end) +{ + long ret = 0; + unsigned char byte; + unsigned shift = 0; + const unsigned size = sizeof(int) * 8; + + do + { + byte = dwarf2_get_byte(ptr++); + ret |= (byte & 0x7f) << shift; + shift += 7; + } while (byte & 0x80); + if (end) *end = ptr; + + /* as spec: sign bit of byte is 2nd high order bit (80x40) + * -> 0x80 is used as flag. + */ + if ((shift < size) && (byte & 0x40)) + { + ret |= - (1 << shift); + } + return ret; +} + +static long dwarf2_leb128_as_signed(dwarf2_traverse_context_t* ctx) +{ + long ret = 0; + + assert(ctx); + + ret = dwarf2_get_leb128_as_signed(ctx->data, &ctx->data); + return ret; +} + +static unsigned dwarf2_leb128_length(const dwarf2_traverse_context_t* ctx) +{ + unsigned ret; + for (ret = 0; ctx->data[ret] & 0x80; ret++); + return ret + 1; +} + +static unsigned long dwarf2_get_addr(const unsigned char* ptr, unsigned word_size) +{ + unsigned long ret; + + switch (word_size) + { + case 4: + ret = dwarf2_get_u4(ptr); + break; + default: + FIXME("Unsupported Word Size %u\n", word_size); + ret = 0; + } + return ret; +} + +static unsigned long dwarf2_parse_addr(dwarf2_traverse_context_t* ctx) +{ + unsigned long ret = dwarf2_get_addr(ctx->data, ctx->word_size); + ctx->data += ctx->word_size; + return ret; +} + +static const char* dwarf2_debug_traverse_ctx(const dwarf2_traverse_context_t* ctx) +{ + return wine_dbg_sprintf("ctx(%p)", ctx->data); +} + +static const char* dwarf2_debug_ctx(const dwarf2_parse_context_t* ctx) +{ + return wine_dbg_sprintf("ctx(%p,%s)", + ctx, debugstr_w(ctx->module->module.ModuleName)); +} + +static const char* dwarf2_debug_di(const dwarf2_debug_info_t* di) +{ + return wine_dbg_sprintf("debug_info(abbrev:%p,symt:%p)", + di->abbrev, di->symt); +} + +static dwarf2_abbrev_entry_t* +dwarf2_abbrev_table_find_entry(const struct sparse_array* abbrev_table, + unsigned long entry_code) +{ + assert( NULL != abbrev_table ); + return sparse_array_find(abbrev_table, entry_code); +} + +static void dwarf2_parse_abbrev_set(dwarf2_traverse_context_t* abbrev_ctx, + struct sparse_array* abbrev_table, + struct pool* pool) +{ + unsigned long entry_code; + dwarf2_abbrev_entry_t* abbrev_entry; + dwarf2_abbrev_entry_attr_t* new = NULL; + dwarf2_abbrev_entry_attr_t* last = NULL; + unsigned long attribute; + unsigned long form; + + assert( NULL != abbrev_ctx ); + + TRACE("%s, end at %p\n", + dwarf2_debug_traverse_ctx(abbrev_ctx), abbrev_ctx->end_data); + + sparse_array_init(abbrev_table, sizeof(dwarf2_abbrev_entry_t), 32); + while (abbrev_ctx->data < abbrev_ctx->end_data) + { + TRACE("now at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx)); + entry_code = dwarf2_leb128_as_unsigned(abbrev_ctx); + TRACE("found entry_code %lu\n", entry_code); + if (!entry_code) + { + TRACE("NULL entry code at %s\n", dwarf2_debug_traverse_ctx(abbrev_ctx)); + break; + } + abbrev_entry = sparse_array_add(abbrev_table, entry_code, pool); + assert( NULL != abbrev_entry ); + + abbrev_entry->entry_code = entry_code; + abbrev_entry->tag = dwarf2_leb128_as_unsigned(abbrev_ctx); + abbrev_entry->have_child = dwarf2_parse_byte(abbrev_ctx); + abbrev_entry->attrs = NULL; + abbrev_entry->num_attr = 0; + + TRACE("table:(%p,#%u) entry_code(%lu) tag(0x%lx) have_child(%u) -> %p\n", + abbrev_table, sparse_array_length(abbrev_table), + entry_code, abbrev_entry->tag, abbrev_entry->have_child, abbrev_entry); + + last = NULL; + while (1) + { + attribute = dwarf2_leb128_as_unsigned(abbrev_ctx); + form = dwarf2_leb128_as_unsigned(abbrev_ctx); + if (!attribute) break; + + new = pool_alloc(pool, sizeof(dwarf2_abbrev_entry_attr_t)); + assert(new); + + new->attribute = attribute; + new->form = form; + new->next = NULL; + if (abbrev_entry->attrs) last->next = new; + else abbrev_entry->attrs = new; + last = new; + abbrev_entry->num_attr++; + } + } + TRACE("found %u entries\n", sparse_array_length(abbrev_table)); +} + +static void dwarf2_swallow_attribute(dwarf2_traverse_context_t* ctx, + const dwarf2_abbrev_entry_attr_t* abbrev_attr) +{ + unsigned step; + + TRACE("(attr:0x%lx,form:0x%lx)\n", abbrev_attr->attribute, abbrev_attr->form); + + switch (abbrev_attr->form) + { + case DW_FORM_ref_addr: + case DW_FORM_addr: step = ctx->word_size; break; + case DW_FORM_flag: + case DW_FORM_data1: + case DW_FORM_ref1: step = 1; break; + case DW_FORM_data2: + case DW_FORM_ref2: step = 2; break; + case DW_FORM_data4: + case DW_FORM_ref4: + case DW_FORM_strp: step = 4; break; + case DW_FORM_data8: + case DW_FORM_ref8: step = 8; break; + case DW_FORM_sdata: + case DW_FORM_ref_udata: + case DW_FORM_udata: step = dwarf2_leb128_length(ctx); break; + case DW_FORM_string: step = strlen((const char*)ctx->data) + 1; break; + case DW_FORM_block: step = dwarf2_leb128_as_unsigned(ctx); break; + case DW_FORM_block1: step = dwarf2_parse_byte(ctx); break; + case DW_FORM_block2: step = dwarf2_parse_u2(ctx); break; + case DW_FORM_block4: step = dwarf2_parse_u4(ctx); break; + default: + FIXME("Unhandled attribute form %lx\n", abbrev_attr->form); + return; + } + ctx->data += step; +} + +static void dwarf2_fill_attr(const dwarf2_parse_context_t* ctx, + const dwarf2_abbrev_entry_attr_t* abbrev_attr, + const unsigned char* data, + struct attribute* attr) +{ + attr->form = abbrev_attr->form; + switch (attr->form) + { + case DW_FORM_ref_addr: + case DW_FORM_addr: + attr->u.uvalue = dwarf2_get_addr(data, ctx->word_size); + TRACE("addr<0x%lx>\n", attr->u.uvalue); + break; + + case DW_FORM_flag: + attr->u.uvalue = dwarf2_get_byte(data); + TRACE("flag<0x%lx>\n", attr->u.uvalue); + break; + + case DW_FORM_data1: + attr->u.uvalue = dwarf2_get_byte(data); + TRACE("data1<%lu>\n", attr->u.uvalue); + break; + + case DW_FORM_data2: + attr->u.uvalue = dwarf2_get_u2(data); + TRACE("data2<%lu>\n", attr->u.uvalue); + break; + + case DW_FORM_data4: + attr->u.uvalue = dwarf2_get_u4(data); + TRACE("data4<%lu>\n", attr->u.uvalue); + break; + + case DW_FORM_data8: + FIXME("Unhandled 64bits support\n"); + break; + + case DW_FORM_ref1: + attr->u.uvalue = ctx->ref_offset + dwarf2_get_byte(data); + TRACE("ref1<0x%lx>\n", attr->u.uvalue); + break; + + case DW_FORM_ref2: + attr->u.uvalue = ctx->ref_offset + dwarf2_get_u2(data); + TRACE("ref2<0x%lx>\n", attr->u.uvalue); + break; + + case DW_FORM_ref4: + attr->u.uvalue = ctx->ref_offset + dwarf2_get_u4(data); + TRACE("ref4<0x%lx>\n", attr->u.uvalue); + break; + + case DW_FORM_ref8: + FIXME("Unhandled 64 bit support\n"); + break; + + case DW_FORM_sdata: + attr->u.svalue = dwarf2_get_leb128_as_signed(data, NULL); + break; + + case DW_FORM_ref_udata: + attr->u.uvalue = dwarf2_get_leb128_as_unsigned(data, NULL); + break; + + case DW_FORM_udata: + attr->u.uvalue = dwarf2_get_leb128_as_unsigned(data, NULL); + break; + + case DW_FORM_string: + attr->u.string = (const char *)data; + TRACE("string<%s>\n", attr->u.string); + break; + + case DW_FORM_strp: + { + unsigned long offset = dwarf2_get_u4(data); + attr->u.string = (const char*)ctx->sections[section_string].address + offset; + } + TRACE("strp<%s>\n", attr->u.string); + break; + + case DW_FORM_block: + attr->u.block.size = dwarf2_get_leb128_as_unsigned(data, &attr->u.block.ptr); + break; + + case DW_FORM_block1: + attr->u.block.size = dwarf2_get_byte(data); + attr->u.block.ptr = data + 1; + break; + + case DW_FORM_block2: + attr->u.block.size = dwarf2_get_u2(data); + attr->u.block.ptr = data + 2; + break; + + case DW_FORM_block4: + attr->u.block.size = dwarf2_get_u4(data); + attr->u.block.ptr = data + 4; + break; + + default: + FIXME("Unhandled attribute form %lx\n", abbrev_attr->form); + break; + } +} + +static BOOL dwarf2_find_attribute(const dwarf2_parse_context_t* ctx, + const dwarf2_debug_info_t* di, + unsigned at, struct attribute* attr) +{ + unsigned i, ai = 0; + dwarf2_abbrev_entry_attr_t* abbrev_attr; + dwarf2_abbrev_entry_attr_t* abstract_abbrev_attr; + + while (di) + { + abstract_abbrev_attr = NULL; + for (i = 0, abbrev_attr = di->abbrev->attrs; abbrev_attr; i++, abbrev_attr = abbrev_attr->next) + { + if (abbrev_attr->attribute == at) + { + dwarf2_fill_attr(ctx, abbrev_attr, di->data[i], attr); + return TRUE; + } + if (abbrev_attr->attribute == DW_AT_abstract_origin && + at != DW_AT_sibling) + { + abstract_abbrev_attr = abbrev_attr; + ai = i; + } + } + /* do we have an abstract origin debug entry to look into ? */ + if (!abstract_abbrev_attr) break; + dwarf2_fill_attr(ctx, abstract_abbrev_attr, di->data[ai], attr); + if (!(di = sparse_array_find(&ctx->debug_info_table, attr->u.uvalue))) + FIXME("Should have found the debug info entry\n"); + } + return FALSE; +} + +static void dwarf2_load_one_entry(dwarf2_parse_context_t*, dwarf2_debug_info_t*, + struct symt_compiland*); + +#define Wine_DW_no_register 0x7FFFFFFF + +static unsigned dwarf2_map_register(int regno) +{ + unsigned reg; + + switch (regno) + { + case Wine_DW_no_register: FIXME("What the heck map reg 0x%x\n",regno); reg = 0; break; + case 0: reg = CV_REG_EAX; break; + case 1: reg = CV_REG_ECX; break; + case 2: reg = CV_REG_EDX; break; + case 3: reg = CV_REG_EBX; break; + case 4: reg = CV_REG_ESP; break; + case 5: reg = CV_REG_EBP; break; + case 6: reg = CV_REG_ESI; break; + case 7: reg = CV_REG_EDI; break; + case 8: reg = CV_REG_EIP; break; + case 9: reg = CV_REG_EFLAGS; break; + case 10: reg = CV_REG_CS; break; + case 11: reg = CV_REG_SS; break; + case 12: reg = CV_REG_DS; break; + case 13: reg = CV_REG_ES; break; + case 14: reg = CV_REG_FS; break; + case 15: reg = CV_REG_GS; break; + case 16: case 17: case 18: case 19: + case 20: case 21: case 22: case 23: + reg = CV_REG_ST0 + regno - 16; break; + case 24: reg = CV_REG_CTRL; break; + case 25: reg = CV_REG_STAT; break; + case 26: reg = CV_REG_TAG; break; +/* +reg: fiseg 27 +reg: fioff 28 +reg: foseg 29 +reg: fooff 30 +reg: fop 31 +*/ + case 32: case 33: case 34: case 35: + case 36: case 37: case 38: case 39: + reg = CV_REG_XMM0 + regno - 32; break; + case 40: reg = CV_REG_MXCSR; break; + default: + FIXME("Don't know how to map register %d\n", regno); + return 0; + } + return reg; +} + +static enum location_error +compute_location(dwarf2_traverse_context_t* ctx, struct location* loc, + HANDLE hproc, const struct location* frame) +{ + unsigned long stack[64]; + unsigned stk; + unsigned char op; + BOOL piece_found = FALSE; + + stack[stk = 0] = 0; + + loc->kind = loc_absolute; + loc->reg = Wine_DW_no_register; + + while (ctx->data < ctx->end_data) + { + op = dwarf2_parse_byte(ctx); + switch (op) + { + case DW_OP_addr: stack[++stk] = dwarf2_parse_addr(ctx); break; + case DW_OP_const1u: stack[++stk] = dwarf2_parse_byte(ctx); break; + case DW_OP_const1s: stack[++stk] = (long)(signed char)dwarf2_parse_byte(ctx); break; + case DW_OP_const2u: stack[++stk] = dwarf2_parse_u2(ctx); break; + case DW_OP_const2s: stack[++stk] = (long)(short)dwarf2_parse_u2(ctx); break; + case DW_OP_const4u: stack[++stk] = dwarf2_parse_u4(ctx); break; + case DW_OP_const4s: stack[++stk] = dwarf2_parse_u4(ctx); break; + case DW_OP_constu: stack[++stk] = dwarf2_leb128_as_unsigned(ctx); break; + case DW_OP_consts: stack[++stk] = dwarf2_leb128_as_signed(ctx); break; + case DW_OP_plus_uconst: + stack[stk] += dwarf2_leb128_as_unsigned(ctx); break; + case DW_OP_reg0: case DW_OP_reg1: case DW_OP_reg2: case DW_OP_reg3: + case DW_OP_reg4: case DW_OP_reg5: case DW_OP_reg6: case DW_OP_reg7: + case DW_OP_reg8: case DW_OP_reg9: case DW_OP_reg10: case DW_OP_reg11: + case DW_OP_reg12: case DW_OP_reg13: case DW_OP_reg14: case DW_OP_reg15: + case DW_OP_reg16: case DW_OP_reg17: case DW_OP_reg18: case DW_OP_reg19: + case DW_OP_reg20: case DW_OP_reg21: case DW_OP_reg22: case DW_OP_reg23: + case DW_OP_reg24: case DW_OP_reg25: case DW_OP_reg26: case DW_OP_reg27: + case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31: + /* dbghelp APIs don't know how to cope with this anyway + * (for example 'long long' stored in two registers) + * FIXME: We should tell winedbg how to deal with it (sigh) + */ + if (!piece_found) + { + if (loc->reg != Wine_DW_no_register) + FIXME("Only supporting one reg (%d -> %d)\n", + loc->reg, dwarf2_map_register(op - DW_OP_reg0)); + loc->reg = dwarf2_map_register(op - DW_OP_reg0); + } + loc->kind = loc_register; + break; + case DW_OP_breg0: case DW_OP_breg1: case DW_OP_breg2: case DW_OP_breg3: + case DW_OP_breg4: case DW_OP_breg5: case DW_OP_breg6: case DW_OP_breg7: + case DW_OP_breg8: case DW_OP_breg9: case DW_OP_breg10: case DW_OP_breg11: + case DW_OP_breg12: case DW_OP_breg13: case DW_OP_breg14: case DW_OP_breg15: + case DW_OP_breg16: case DW_OP_breg17: case DW_OP_breg18: case DW_OP_breg19: + case DW_OP_breg20: case DW_OP_breg21: case DW_OP_breg22: case DW_OP_breg23: + case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26: case DW_OP_breg27: + case DW_OP_breg28: case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: + /* dbghelp APIs don't know how to cope with this anyway + * (for example 'long long' stored in two registers) + * FIXME: We should tell winedbg how to deal with it (sigh) + */ + if (!piece_found) + { + if (loc->reg != Wine_DW_no_register) + FIXME("Only supporting one reg (%d -> %d)\n", + loc->reg, dwarf2_map_register(op - DW_OP_breg0)); + loc->reg = dwarf2_map_register(op - DW_OP_breg0); + } + stack[++stk] = dwarf2_leb128_as_signed(ctx); + loc->kind = loc_regrel; + break; + case DW_OP_fbreg: + if (loc->reg != Wine_DW_no_register) + FIXME("Only supporting one reg (%d -> -2)\n", loc->reg); + if (frame && frame->kind == loc_register) + { + loc->kind = loc_regrel; + loc->reg = frame->reg; + stack[++stk] = dwarf2_leb128_as_signed(ctx); + } + else if (frame && frame->kind == loc_regrel) + { + loc->kind = loc_regrel; + loc->reg = frame->reg; + stack[++stk] = dwarf2_leb128_as_signed(ctx) + frame->offset; + } + else + { + /* FIXME: this could be later optimized by not recomputing + * this very location expression + */ + loc->kind = loc_dwarf2_block; + stack[++stk] = dwarf2_leb128_as_signed(ctx); + } + break; + case DW_OP_piece: + { + unsigned sz = dwarf2_leb128_as_unsigned(ctx); + WARN("Not handling OP_piece (size=%d)\n", sz); + piece_found = TRUE; + } + break; + case DW_OP_deref: + if (!stk) + { + FIXME("Unexpected empty stack\n"); + return loc_err_internal; + } + if (loc->reg != Wine_DW_no_register) + { + WARN("Too complex expression for deref\n"); + return loc_err_too_complex; + } + if (hproc) + { + DWORD addr = stack[stk--]; + DWORD deref; + + if (!ReadProcessMemory(hproc, (void*)addr, &deref, sizeof(deref), NULL)) + { + WARN("Couldn't read memory at %x\n", addr); + return loc_err_cant_read; + } + stack[++stk] = deref; + } + else + { + loc->kind = loc_dwarf2_block; + } + break; + default: + FIXME("Unhandled attr op: %x\n", op); + return loc_err_internal; + } + } + loc->offset = stack[stk]; + return 0; +} + +static BOOL dwarf2_compute_location_attr(dwarf2_parse_context_t* ctx, + const dwarf2_debug_info_t* di, + unsigned long dw, + struct location* loc, + const struct location* frame) +{ + struct attribute xloc; + + if (!dwarf2_find_attribute(ctx, di, dw, &xloc)) return FALSE; + + switch (xloc.form) + { + case DW_FORM_data1: case DW_FORM_data2: + case DW_FORM_udata: case DW_FORM_sdata: + loc->kind = loc_absolute; + loc->reg = 0; + loc->offset = xloc.u.uvalue; + return TRUE; + case DW_FORM_data4: case DW_FORM_data8: + loc->kind = loc_dwarf2_location_list; + loc->reg = Wine_DW_no_register; + loc->offset = xloc.u.uvalue; + return TRUE; + } + + /* assume we have a block form */ + + if (xloc.u.block.size) + { + dwarf2_traverse_context_t lctx; + enum location_error err; + + lctx.data = xloc.u.block.ptr; + lctx.end_data = xloc.u.block.ptr + xloc.u.block.size; + lctx.word_size = ctx->word_size; + + err = compute_location(&lctx, loc, NULL, frame); + if (err < 0) + { + loc->kind = loc_error; + loc->reg = err; + } + else if (loc->kind == loc_dwarf2_block) + { + unsigned* ptr = pool_alloc(&ctx->module->pool, + sizeof(unsigned) + xloc.u.block.size); + *ptr = xloc.u.block.size; + memcpy(ptr + 1, xloc.u.block.ptr, xloc.u.block.size); + loc->offset = (unsigned long)ptr; + } + } + return TRUE; +} + +static struct symt* dwarf2_lookup_type(dwarf2_parse_context_t* ctx, + const dwarf2_debug_info_t* di) +{ + struct attribute attr; + + if (dwarf2_find_attribute(ctx, di, DW_AT_type, &attr)) + { + dwarf2_debug_info_t* type; + + type = sparse_array_find(&ctx->debug_info_table, attr.u.uvalue); + if (!type) FIXME("Unable to find back reference to type %lx\n", attr.u.uvalue); + if (!type->symt) + { + /* load the debug info entity */ + dwarf2_load_one_entry(ctx, type, NULL); + } + return type->symt; + } + return NULL; +} + +/****************************************************************** + * dwarf2_read_one_debug_info + * + * Loads into memory one debug info entry, and recursively its children (if any) + */ +static BOOL dwarf2_read_one_debug_info(dwarf2_parse_context_t* ctx, + dwarf2_traverse_context_t* traverse, + dwarf2_debug_info_t** pdi) +{ + const dwarf2_abbrev_entry_t*abbrev; + unsigned long entry_code; + unsigned long offset; + dwarf2_debug_info_t* di; + dwarf2_debug_info_t* child; + dwarf2_debug_info_t** where; + dwarf2_abbrev_entry_attr_t* attr; + unsigned i; + struct attribute sibling; + + offset = traverse->data - ctx->sections[ctx->section].address; + entry_code = dwarf2_leb128_as_unsigned(traverse); + TRACE("found entry_code %lu at 0x%lx\n", entry_code, offset); + if (!entry_code) + { + *pdi = NULL; + return TRUE; + } + abbrev = dwarf2_abbrev_table_find_entry(&ctx->abbrev_table, entry_code); + if (!abbrev) + { + WARN("Cannot find abbrev entry for %lu at 0x%lx\n", entry_code, offset); + return FALSE; + } + di = sparse_array_add(&ctx->debug_info_table, offset, &ctx->pool); + if (!di) return FALSE; + di->abbrev = abbrev; + di->symt = NULL; + + if (abbrev->num_attr) + { + di->data = pool_alloc(&ctx->pool, abbrev->num_attr * sizeof(const char*)); + for (i = 0, attr = abbrev->attrs; attr; i++, attr = attr->next) + { + di->data[i] = traverse->data; + dwarf2_swallow_attribute(traverse, attr); + } + } + else di->data = NULL; + if (abbrev->have_child) + { + vector_init(&di->children, sizeof(dwarf2_debug_info_t*), 16); + while (traverse->data < traverse->end_data) + { + if (!dwarf2_read_one_debug_info(ctx, traverse, &child)) return FALSE; + if (!child) break; + where = vector_add(&di->children, &ctx->pool); + if (!where) return FALSE; + *where = child; + } + } + if (dwarf2_find_attribute(ctx, di, DW_AT_sibling, &sibling) && + traverse->data != ctx->sections[ctx->section].address + sibling.u.uvalue) + { + WARN("setting cursor for %s to next sibling <0x%lx>\n", + dwarf2_debug_traverse_ctx(traverse), sibling.u.uvalue); + traverse->data = ctx->sections[ctx->section].address + sibling.u.uvalue; + } + *pdi = di; + return TRUE; +} + +static struct symt* dwarf2_parse_base_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct attribute name; + struct attribute size; + struct attribute encoding; + enum BasicType bt; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) + name.u.string = NULL; + if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0; + if (!dwarf2_find_attribute(ctx, di, DW_AT_encoding, &encoding)) encoding.u.uvalue = DW_ATE_void; + + switch (encoding.u.uvalue) + { + case DW_ATE_void: bt = btVoid; break; + case DW_ATE_address: bt = btULong; break; + case DW_ATE_boolean: bt = btBool; break; + case DW_ATE_complex_float: bt = btComplex; break; + case DW_ATE_float: bt = btFloat; break; + case DW_ATE_signed: bt = btInt; break; + case DW_ATE_unsigned: bt = btUInt; break; + case DW_ATE_signed_char: bt = btChar; break; + case DW_ATE_unsigned_char: bt = btChar; break; + default: bt = btNoType; break; + } + di->symt = &symt_new_basic(ctx->module, bt, name.u.string, size.u.uvalue)->symt; + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + return di->symt; +} + +static struct symt* dwarf2_parse_typedef(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type; + struct attribute name; + + if (di->symt) return di->symt; + + TRACE("%s, for %lu\n", dwarf2_debug_ctx(ctx), di->abbrev->entry_code); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL; + ref_type = dwarf2_lookup_type(ctx, di); + + if (name.u.string) + di->symt = &symt_new_typedef(ctx->module, ref_type, name.u.string)->symt; + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + return di->symt; +} + +static struct symt* dwarf2_parse_pointer_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type; + struct attribute size; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0; + if (!(ref_type = dwarf2_lookup_type(ctx, di))) + ref_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt; + + di->symt = &symt_new_pointer(ctx->module, ref_type)->symt; + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + return di->symt; +} + +static struct symt* dwarf2_parse_array_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type; + struct symt* idx_type = NULL; + struct attribute min, max, cnt; + dwarf2_debug_info_t* child; + int i; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!di->abbrev->have_child) + { + FIXME("array without range information\n"); + return NULL; + } + ref_type = dwarf2_lookup_type(ctx, di); + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + switch (child->abbrev->tag) + { + case DW_TAG_subrange_type: + idx_type = dwarf2_lookup_type(ctx, child); + if (!dwarf2_find_attribute(ctx, child, DW_AT_lower_bound, &min)) + min.u.uvalue = 0; + if (!dwarf2_find_attribute(ctx, child, DW_AT_upper_bound, &max)) + max.u.uvalue = 0; + if (dwarf2_find_attribute(ctx, child, DW_AT_count, &cnt)) + max.u.uvalue = min.u.uvalue + cnt.u.uvalue; + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + break; + } + } + di->symt = &symt_new_array(ctx->module, min.u.uvalue, max.u.uvalue, ref_type, idx_type)->symt; + return di->symt; +} + +static struct symt* dwarf2_parse_const_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + ref_type = dwarf2_lookup_type(ctx, di); + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + di->symt = ref_type; + + return ref_type; +} + +static struct symt* dwarf2_parse_volatile_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + ref_type = dwarf2_lookup_type(ctx, di); + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + di->symt = ref_type; + + return ref_type; +} + +static struct symt* dwarf2_parse_reference_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ref_type = NULL; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + ref_type = dwarf2_lookup_type(ctx, di); + /* FIXME: for now, we hard-wire C++ references to pointers */ + di->symt = &symt_new_pointer(ctx->module, ref_type)->symt; + + if (di->abbrev->have_child) FIXME("Unsupported children\n"); + + return di->symt; +} + +static void dwarf2_parse_udt_member(dwarf2_parse_context_t* ctx, + const dwarf2_debug_info_t* di, + struct symt_udt* parent) +{ + struct symt* elt_type; + struct attribute name; + struct attribute bit_size; + struct attribute bit_offset; + struct location loc; + + assert(parent); + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL; + elt_type = dwarf2_lookup_type(ctx, di); + if (dwarf2_compute_location_attr(ctx, di, DW_AT_data_member_location, &loc, NULL)) + { + if (loc.kind != loc_absolute) + { + FIXME("Found register, while not expecting it\n"); + loc.offset = 0; + } + else + TRACE("found member_location at %s -> %lu\n", + dwarf2_debug_ctx(ctx), loc.offset); + } + else + loc.offset = 0; + if (!dwarf2_find_attribute(ctx, di, DW_AT_bit_size, &bit_size)) + bit_size.u.uvalue = 0; + if (dwarf2_find_attribute(ctx, di, DW_AT_bit_offset, &bit_offset)) + { + /* FIXME: we should only do this when implementation is LSB (which is + * the case on i386 processors) + */ + struct attribute nbytes; + if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &nbytes)) + { + DWORD64 size; + nbytes.u.uvalue = symt_get_info(elt_type, TI_GET_LENGTH, &size) ? (unsigned long)size : 0; + } + bit_offset.u.uvalue = nbytes.u.uvalue * 8 - bit_offset.u.uvalue - bit_size.u.uvalue; + } + else bit_offset.u.uvalue = 0; + symt_add_udt_element(ctx->module, parent, name.u.string, elt_type, + (loc.offset << 3) + bit_offset.u.uvalue, + bit_size.u.uvalue); + + if (di->abbrev->have_child) FIXME("Unsupported children\n"); +} + +static struct symt* dwarf2_parse_udt_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di, + enum UdtKind udt) +{ + struct attribute name; + struct attribute size; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL; + if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0; + + di->symt = &symt_new_udt(ctx->module, name.u.string, size.u.uvalue, udt)->symt; + + if (di->abbrev->have_child) /** any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_member: + /* FIXME: should I follow the sibling stuff ?? */ + dwarf2_parse_udt_member(ctx, child, (struct symt_udt*)di->symt); + break; + case DW_TAG_enumeration_type: + dwarf2_parse_enumeration_type(ctx, child); + break; + case DW_TAG_structure_type: + case DW_TAG_class_type: + case DW_TAG_union_type: + /* FIXME: we need to handle nested udt definitions */ + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + break; + } + } + } + + return di->symt; +} + +static void dwarf2_parse_enumerator(dwarf2_parse_context_t* ctx, + const dwarf2_debug_info_t* di, + struct symt_enum* parent) +{ + struct attribute name; + struct attribute value; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) return; + if (!dwarf2_find_attribute(ctx, di, DW_AT_const_value, &value)) value.u.svalue = 0; + symt_add_enum_element(ctx->module, parent, name.u.string, value.u.svalue); + + if (di->abbrev->have_child) FIXME("Unsupported children\n"); +} + +static struct symt* dwarf2_parse_enumeration_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct attribute name; + struct attribute size; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL; + if (!dwarf2_find_attribute(ctx, di, DW_AT_byte_size, &size)) size.u.uvalue = 0; + + di->symt = &symt_new_enum(ctx->module, name.u.string)->symt; + + if (di->abbrev->have_child) /* any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + /* FIXME: should we use the sibling stuff ?? */ + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_enumerator: + dwarf2_parse_enumerator(ctx, child, (struct symt_enum*)di->symt); + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + di->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + } + } + } + return di->symt; +} + +/* structure used to pass information around when parsing a subprogram */ +typedef struct dwarf2_subprogram_s +{ + dwarf2_parse_context_t* ctx; + struct symt_compiland* compiland; + struct symt_function* func; + BOOL non_computed_variable; + struct location frame; +} dwarf2_subprogram_t; + +/****************************************************************** + * dwarf2_parse_variable + * + * Parses any variable (parameter, local/global variable) + */ +static void dwarf2_parse_variable(dwarf2_subprogram_t* subpgm, + struct symt_block* block, + dwarf2_debug_info_t* di) +{ + struct symt* param_type; + struct attribute name, value; + struct location loc; + BOOL is_pmt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di)); + + is_pmt = !block && di->abbrev->tag == DW_TAG_formal_parameter; + param_type = dwarf2_lookup_type(subpgm->ctx, di); + + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_name, &name)) { + /* cannot do much without the name, the functions below won't like it. */ + return; + } + if (dwarf2_compute_location_attr(subpgm->ctx, di, DW_AT_location, + &loc, &subpgm->frame)) + { + struct attribute ext; + + TRACE("found parameter %s (kind=%d, offset=%ld, reg=%d) at %s\n", + name.u.string, loc.kind, loc.offset, loc.reg, + dwarf2_debug_ctx(subpgm->ctx)); + + switch (loc.kind) + { + case loc_absolute: + /* it's a global variable */ + /* FIXME: we don't handle its scope yet */ + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_external, &ext)) + ext.u.uvalue = 0; + symt_new_global_variable(subpgm->ctx->module, subpgm->compiland, + name.u.string, !ext.u.uvalue, + subpgm->ctx->load_offset + loc.offset, + 0, param_type); + break; + default: + subpgm->non_computed_variable = TRUE; + /* fall through */ + case loc_register: + case loc_regrel: + /* either a pmt/variable relative to frame pointer or + * pmt/variable in a register + */ + assert(subpgm->func); + symt_add_func_local(subpgm->ctx->module, subpgm->func, + is_pmt ? DataIsParam : DataIsLocal, + &loc, block, param_type, name.u.string); + break; + } + } + else if (dwarf2_find_attribute(subpgm->ctx, di, DW_AT_const_value, &value)) + { + VARIANT v; + if (subpgm->func) WARN("Unsupported constant %s in function\n", name.u.string); + if (is_pmt) FIXME("Unsupported constant (parameter) %s in function\n", name.u.string); + switch (value.form) + { + case DW_FORM_data1: + case DW_FORM_data2: + case DW_FORM_data4: + case DW_FORM_udata: + v.n1.n2.vt = VT_UI4; + v.n1.n2.n3.lVal = value.u.uvalue; + break; + + case DW_FORM_sdata: + v.n1.n2.vt = VT_I4; + v.n1.n2.n3.lVal = value.u.svalue; + break; + + case DW_FORM_strp: + case DW_FORM_string: + /* FIXME: native doesn't report const strings from here !! + * however, the value of the string is in the code somewhere + */ + v.n1.n2.vt = VT_I1 | VT_BYREF; + v.n1.n2.n3.byref = pool_strdup(&subpgm->ctx->module->pool, value.u.string); + break; + + case DW_FORM_data8: + case DW_FORM_block: + case DW_FORM_block1: + case DW_FORM_block2: + case DW_FORM_block4: + + default: + FIXME("Unsupported form for const value %s (%lx)\n", + name.u.string, value.form); + v.n1.n2.vt = VT_EMPTY; + } + di->symt = &symt_new_constant(subpgm->ctx->module, subpgm->compiland, + name.u.string, param_type, &v)->symt; + } + if (is_pmt && subpgm->func && subpgm->func->type) + symt_add_function_signature_parameter(subpgm->ctx->module, + (struct symt_function_signature*)subpgm->func->type, + param_type); + + if (di->abbrev->have_child) FIXME("Unsupported children\n"); +} + +static void dwarf2_parse_subprogram_label(dwarf2_subprogram_t* subpgm, + const dwarf2_debug_info_t* di) +{ + struct attribute name; + struct attribute low_pc; + struct location loc; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0; + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_name, &name)) + name.u.string = NULL; + + loc.kind = loc_absolute; + loc.offset = subpgm->ctx->load_offset + low_pc.u.uvalue; + symt_add_function_point(subpgm->ctx->module, subpgm->func, SymTagLabel, + &loc, name.u.string); +} + +static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm, + struct symt_block* parent_block, + const dwarf2_debug_info_t* di); + +static void dwarf2_parse_inlined_subroutine(dwarf2_subprogram_t* subpgm, + struct symt_block* parent_block, + const dwarf2_debug_info_t* di) +{ + struct symt_block* block; + struct attribute low_pc; + struct attribute high_pc; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0; + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_high_pc, &high_pc)) high_pc.u.uvalue = 0; + + block = symt_open_func_block(subpgm->ctx->module, subpgm->func, parent_block, + subpgm->ctx->load_offset + low_pc.u.uvalue - subpgm->func->address, + high_pc.u.uvalue - low_pc.u.uvalue); + + if (di->abbrev->have_child) /** any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_formal_parameter: + case DW_TAG_variable: + dwarf2_parse_variable(subpgm, block, child); + break; + case DW_TAG_lexical_block: + dwarf2_parse_subprogram_block(subpgm, block, child); + break; + case DW_TAG_inlined_subroutine: + dwarf2_parse_inlined_subroutine(subpgm, block, child); + break; + case DW_TAG_label: + dwarf2_parse_subprogram_label(subpgm, child); + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx), + dwarf2_debug_di(di)); + } + } + } + symt_close_func_block(subpgm->ctx->module, subpgm->func, block, 0); +} + +static void dwarf2_parse_subprogram_block(dwarf2_subprogram_t* subpgm, + struct symt_block* parent_block, + const dwarf2_debug_info_t* di) +{ + struct symt_block* block; + struct attribute low_pc; + struct attribute high_pc; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_low_pc, &low_pc)) + low_pc.u.uvalue = 0; + if (!dwarf2_find_attribute(subpgm->ctx, di, DW_AT_high_pc, &high_pc)) + high_pc.u.uvalue = 0; + + block = symt_open_func_block(subpgm->ctx->module, subpgm->func, parent_block, + subpgm->ctx->load_offset + low_pc.u.uvalue - subpgm->func->address, + high_pc.u.uvalue - low_pc.u.uvalue); + + if (di->abbrev->have_child) /** any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_inlined_subroutine: + dwarf2_parse_inlined_subroutine(subpgm, block, child); + break; + case DW_TAG_variable: + dwarf2_parse_variable(subpgm, block, child); + break; + case DW_TAG_lexical_block: + dwarf2_parse_subprogram_block(subpgm, block, child); + break; + case DW_TAG_subprogram: + /* FIXME: likely a declaration (to be checked) + * skip it for now + */ + break; + case DW_TAG_formal_parameter: + /* FIXME: likely elements for exception handling (GCC flavor) + * Skip it for now + */ + break; + case DW_TAG_label: + dwarf2_parse_subprogram_label(subpgm, child); + break; + case DW_TAG_class_type: + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_enumeration_type: + case DW_TAG_typedef: + /* the type referred to will be loaded when we need it, so skip it */ + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + child->abbrev->tag, dwarf2_debug_ctx(subpgm->ctx), dwarf2_debug_di(di)); + } + } + } + + symt_close_func_block(subpgm->ctx->module, subpgm->func, block, 0); +} + +static struct symt* dwarf2_parse_subprogram(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di, + struct symt_compiland* compiland) +{ + struct attribute name; + struct attribute low_pc; + struct attribute high_pc; + struct attribute is_decl; + struct attribute inline_flags; + struct symt* ret_type; + struct symt_function_signature* sig_type; + dwarf2_subprogram_t subpgm; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!dwarf2_find_attribute(ctx, di, DW_AT_name, &name)) name.u.string = NULL; + /* if it's an abstract representation of an inline function, there should be + * a concrete object that we'll handle + */ + if (dwarf2_find_attribute(ctx, di, DW_AT_inline, &inline_flags)) + { + TRACE("Function %s declared as inlined (%ld)... skipping\n", + name.u.string ? name.u.string : "(null)", inline_flags.u.uvalue); + return NULL; + } + + if (!dwarf2_find_attribute(ctx, di, DW_AT_low_pc, &low_pc)) low_pc.u.uvalue = 0; + if (!dwarf2_find_attribute(ctx, di, DW_AT_high_pc, &high_pc)) high_pc.u.uvalue = 0; + /* As functions (defined as inline assembly) get debug info with dwarf + * (not the case for stabs), we just drop Wine's thunks here... + * Actual thunks will be created in elf_module from the symbol table + */ + if (elf_is_in_thunk_area(ctx->load_offset + low_pc.u.uvalue, + ctx->thunks) >= 0) + return NULL; + if (!dwarf2_find_attribute(ctx, di, DW_AT_declaration, &is_decl)) + is_decl.u.uvalue = 0; + + if (!(ret_type = dwarf2_lookup_type(ctx, di))) + ret_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt; + + /* FIXME: assuming C source code */ + sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C); + if (!is_decl.u.uvalue) + { + subpgm.func = symt_new_function(ctx->module, compiland, name.u.string, + ctx->load_offset + low_pc.u.uvalue, + high_pc.u.uvalue - low_pc.u.uvalue, + &sig_type->symt); + di->symt = &subpgm.func->symt; + } + else subpgm.func = NULL; + + subpgm.ctx = ctx; + subpgm.compiland = compiland; + if (!dwarf2_compute_location_attr(ctx, di, DW_AT_frame_base, + &subpgm.frame, NULL)) + { + /* on stack !! */ + subpgm.frame.kind = loc_regrel; + subpgm.frame.reg = 0; + subpgm.frame.offset = 0; + } + subpgm.non_computed_variable = FALSE; + + if (di->abbrev->have_child) /** any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_variable: + case DW_TAG_formal_parameter: + dwarf2_parse_variable(&subpgm, NULL, child); + break; + case DW_TAG_lexical_block: + dwarf2_parse_subprogram_block(&subpgm, NULL, child); + break; + case DW_TAG_inlined_subroutine: + dwarf2_parse_inlined_subroutine(&subpgm, NULL, child); + break; + case DW_TAG_subprogram: + /* FIXME: likely a declaration (to be checked) + * skip it for now + */ + break; + case DW_TAG_label: + dwarf2_parse_subprogram_label(&subpgm, child); + break; + case DW_TAG_class_type: + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_enumeration_type: + case DW_TAG_typedef: + /* the type referred to will be loaded when we need it, so skip it */ + break; + case DW_TAG_unspecified_parameters: + /* FIXME: no support in dbghelp's internals so far */ + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %s\n", + child->abbrev->tag, dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + } + } + } + + if (subpgm.non_computed_variable || subpgm.frame.kind >= loc_user) + { + symt_add_function_point(ctx->module, subpgm.func, SymTagCustom, + &subpgm.frame, NULL); + } + symt_normalize_function(subpgm.ctx->module, subpgm.func); + + return di->symt; +} + +static struct symt* dwarf2_parse_subroutine_type(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di) +{ + struct symt* ret_type; + struct symt_function_signature* sig_type; + + if (di->symt) return di->symt; + + TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di)); + + if (!(ret_type = dwarf2_lookup_type(ctx, di))) + ret_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt; + + /* FIXME: assuming C source code */ + sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C); + + if (di->abbrev->have_child) /** any interest to not have child ? */ + { + dwarf2_debug_info_t* child; + int i; + + for (i=0; ichildren); i++) + { + child = *(dwarf2_debug_info_t**)vector_at(&di->children, i); + + switch (child->abbrev->tag) + { + case DW_TAG_formal_parameter: + symt_add_function_signature_parameter(ctx->module, sig_type, + dwarf2_lookup_type(ctx, child)); + break; + case DW_TAG_unspecified_parameters: + WARN("Unsupported unspecified parameters\n"); + break; + } + } + } + + return di->symt = &sig_type->symt; +} + +static void dwarf2_load_one_entry(dwarf2_parse_context_t* ctx, + dwarf2_debug_info_t* di, + struct symt_compiland* compiland) +{ + switch (di->abbrev->tag) + { + case DW_TAG_typedef: + dwarf2_parse_typedef(ctx, di); + break; + case DW_TAG_base_type: + dwarf2_parse_base_type(ctx, di); + break; + case DW_TAG_pointer_type: + dwarf2_parse_pointer_type(ctx, di); + break; + case DW_TAG_class_type: + dwarf2_parse_udt_type(ctx, di, UdtClass); + break; + case DW_TAG_structure_type: + dwarf2_parse_udt_type(ctx, di, UdtStruct); + break; + case DW_TAG_union_type: + dwarf2_parse_udt_type(ctx, di, UdtUnion); + break; + case DW_TAG_array_type: + dwarf2_parse_array_type(ctx, di); + break; + case DW_TAG_const_type: + dwarf2_parse_const_type(ctx, di); + break; + case DW_TAG_volatile_type: + dwarf2_parse_volatile_type(ctx, di); + break; + case DW_TAG_reference_type: + dwarf2_parse_reference_type(ctx, di); + break; + case DW_TAG_enumeration_type: + dwarf2_parse_enumeration_type(ctx, di); + break; + case DW_TAG_subprogram: + dwarf2_parse_subprogram(ctx, di, compiland); + break; + case DW_TAG_subroutine_type: + dwarf2_parse_subroutine_type(ctx, di); + break; + case DW_TAG_variable: + { + dwarf2_subprogram_t subpgm; + + subpgm.ctx = ctx; + subpgm.compiland = compiland; + subpgm.func = NULL; + subpgm.frame.kind = loc_absolute; + subpgm.frame.offset = 0; + subpgm.frame.reg = Wine_DW_no_register; + dwarf2_parse_variable(&subpgm, NULL, di); + } + break; + default: + FIXME("Unhandled Tag type 0x%lx at %s, for %lu\n", + di->abbrev->tag, dwarf2_debug_ctx(ctx), di->abbrev->entry_code); + } +} + +static void dwarf2_set_line_number(struct module* module, unsigned long address, + const struct vector* v, unsigned file, unsigned line) +{ + struct symt_function* func; + struct symt_ht* symt; + unsigned* psrc; + + if (!file || !(psrc = vector_at(v, file - 1))) return; + + TRACE("%s %lx %s %u\n", + debugstr_w(module->module.ModuleName), address, source_get(module, *psrc), line); + if (!(symt = symt_find_nearest(module, address)) || + symt->symt.tag != SymTagFunction) return; + func = (struct symt_function*)symt; + symt_add_func_line(module, func, *psrc, line, address - func->address); +} + +static BOOL dwarf2_parse_line_numbers(const dwarf2_section_t* sections, + dwarf2_parse_context_t* ctx, + const char* compile_dir, + unsigned long offset) +{ + dwarf2_traverse_context_t traverse; + unsigned long length; + unsigned version, header_len, insn_size, default_stmt; + unsigned line_range, opcode_base; + int line_base; + const unsigned char* opcode_len; + struct vector dirs; + struct vector files; + const char** p; + + /* section with line numbers stripped */ + if (sections[section_line].address == ELF_NO_MAP) + return FALSE; + + traverse.data = sections[section_line].address + offset; + traverse.start_data = traverse.data; + traverse.end_data = traverse.data + 4; + traverse.word_size = ctx->word_size; + + length = dwarf2_parse_u4(&traverse); + traverse.end_data = traverse.start_data + length; + + version = dwarf2_parse_u2(&traverse); + header_len = dwarf2_parse_u4(&traverse); + insn_size = dwarf2_parse_byte(&traverse); + default_stmt = dwarf2_parse_byte(&traverse); + line_base = (signed char)dwarf2_parse_byte(&traverse); + line_range = dwarf2_parse_byte(&traverse); + opcode_base = dwarf2_parse_byte(&traverse); + + opcode_len = traverse.data; + traverse.data += opcode_base - 1; + + vector_init(&dirs, sizeof(const char*), 4); + p = vector_add(&dirs, &ctx->pool); + *p = compile_dir ? compile_dir : "."; + while (*traverse.data) + { + const char* rel = (const char*)traverse.data; + unsigned rellen = strlen(rel); + TRACE("Got include %s\n", rel); + traverse.data += rellen + 1; + p = vector_add(&dirs, &ctx->pool); + + if (*rel == '/' || !compile_dir) + *p = rel; + else + { + /* include directory relative to compile directory */ + unsigned baselen = strlen(compile_dir); + char* tmp = pool_alloc(&ctx->pool, baselen + 1 + rellen + 1); + strcpy(tmp, compile_dir); + if (tmp[baselen - 1] != '/') tmp[baselen++] = '/'; + strcpy(&tmp[baselen], rel); + *p = tmp; + } + + } + traverse.data++; + + vector_init(&files, sizeof(unsigned), 16); + while (*traverse.data) + { + unsigned int dir_index, mod_time, length; + const char* name; + const char* dir; + unsigned* psrc; + + name = (const char*)traverse.data; + traverse.data += strlen(name) + 1; + dir_index = dwarf2_leb128_as_unsigned(&traverse); + mod_time = dwarf2_leb128_as_unsigned(&traverse); + length = dwarf2_leb128_as_unsigned(&traverse); + dir = *(const char**)vector_at(&dirs, dir_index); + TRACE("Got file %s/%s (%u,%u)\n", dir, name, mod_time, length); + psrc = vector_add(&files, &ctx->pool); + *psrc = source_new(ctx->module, dir, name); + } + traverse.data++; + + while (traverse.data < traverse.end_data) + { + unsigned long address = 0; + unsigned file = 1; + unsigned line = 1; + unsigned is_stmt = default_stmt; + BOOL basic_block = FALSE, end_sequence = FALSE; + unsigned opcode, extopcode, i; + + while (!end_sequence) + { + opcode = dwarf2_parse_byte(&traverse); + TRACE("Got opcode %x\n", opcode); + + if (opcode >= opcode_base) + { + unsigned delta = opcode - opcode_base; + + address += (delta / line_range) * insn_size; + line += line_base + (delta % line_range); + basic_block = TRUE; + dwarf2_set_line_number(ctx->module, address, &files, file, line); + } + else + { + switch (opcode) + { + case DW_LNS_copy: + basic_block = FALSE; + dwarf2_set_line_number(ctx->module, address, &files, file, line); + break; + case DW_LNS_advance_pc: + address += insn_size * dwarf2_leb128_as_unsigned(&traverse); + break; + case DW_LNS_advance_line: + line += dwarf2_leb128_as_signed(&traverse); + break; + case DW_LNS_set_file: + file = dwarf2_leb128_as_unsigned(&traverse); + break; + case DW_LNS_set_column: + dwarf2_leb128_as_unsigned(&traverse); + break; + case DW_LNS_negate_stmt: + is_stmt = !is_stmt; + break; + case DW_LNS_set_basic_block: + basic_block = 1; + break; + case DW_LNS_const_add_pc: + address += ((255 - opcode_base) / line_range) * insn_size; + break; + case DW_LNS_fixed_advance_pc: + address += dwarf2_parse_u2(&traverse); + break; + case DW_LNS_extended_op: + dwarf2_leb128_as_unsigned(&traverse); + extopcode = dwarf2_parse_byte(&traverse); + switch (extopcode) + { + case DW_LNE_end_sequence: + dwarf2_set_line_number(ctx->module, address, &files, file, line); + end_sequence = TRUE; + break; + case DW_LNE_set_address: + address = ctx->load_offset + dwarf2_parse_addr(&traverse); + break; + case DW_LNE_define_file: + FIXME("not handled %s\n", traverse.data); + traverse.data += strlen((const char *)traverse.data) + 1; + dwarf2_leb128_as_unsigned(&traverse); + dwarf2_leb128_as_unsigned(&traverse); + dwarf2_leb128_as_unsigned(&traverse); + break; + default: + FIXME("Unsupported extended opcode %x\n", extopcode); + break; + } + break; + default: + WARN("Unsupported opcode %x\n", opcode); + for (i = 0; i < opcode_len[opcode]; i++) + dwarf2_leb128_as_unsigned(&traverse); + break; + } + } + } + } + return TRUE; +} + +static BOOL dwarf2_parse_compilation_unit(const dwarf2_section_t* sections, + const dwarf2_comp_unit_t* comp_unit, + struct module* module, + const struct elf_thunk_area* thunks, + const unsigned char* comp_unit_cursor, + unsigned long load_offset) +{ + dwarf2_parse_context_t ctx; + dwarf2_traverse_context_t traverse; + dwarf2_traverse_context_t abbrev_ctx; + dwarf2_debug_info_t* di; + BOOL ret = FALSE; + + TRACE("Compilation Unit Header found at 0x%x:\n", + comp_unit_cursor - sections[section_debug].address); + TRACE("- length: %lu\n", comp_unit->length); + TRACE("- version: %u\n", comp_unit->version); + TRACE("- abbrev_offset: %lu\n", comp_unit->abbrev_offset); + TRACE("- word_size: %u\n", comp_unit->word_size); + + if (comp_unit->version != 2) + { + WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n", + comp_unit->version); + return FALSE; + } + + pool_init(&ctx.pool, 65536); + ctx.sections = sections; + ctx.section = section_debug; + ctx.module = module; + ctx.word_size = comp_unit->word_size; + ctx.thunks = thunks; + ctx.load_offset = load_offset; + ctx.ref_offset = comp_unit_cursor - sections[section_debug].address; + + traverse.start_data = comp_unit_cursor + sizeof(dwarf2_comp_unit_stream_t); + traverse.data = traverse.start_data; + traverse.word_size = comp_unit->word_size; + traverse.end_data = comp_unit_cursor + comp_unit->length + sizeof(unsigned); + + abbrev_ctx.start_data = sections[section_abbrev].address + comp_unit->abbrev_offset; + abbrev_ctx.data = abbrev_ctx.start_data; + abbrev_ctx.end_data = sections[section_abbrev].address + sections[section_abbrev].size; + abbrev_ctx.word_size = comp_unit->word_size; + dwarf2_parse_abbrev_set(&abbrev_ctx, &ctx.abbrev_table, &ctx.pool); + + sparse_array_init(&ctx.debug_info_table, sizeof(dwarf2_debug_info_t), 128); + dwarf2_read_one_debug_info(&ctx, &traverse, &di); + + if (di->abbrev->tag == DW_TAG_compile_unit) + { + struct attribute name; + dwarf2_debug_info_t** pdi = NULL; + struct attribute stmt_list, low_pc; + struct attribute comp_dir; + + if (!dwarf2_find_attribute(&ctx, di, DW_AT_name, &name)) + name.u.string = NULL; + + /* get working directory of current compilation unit */ + if (!dwarf2_find_attribute(&ctx, di, DW_AT_comp_dir, &comp_dir)) + comp_dir.u.string = NULL; + + if (!dwarf2_find_attribute(&ctx, di, DW_AT_low_pc, &low_pc)) + low_pc.u.uvalue = 0; + di->symt = &symt_new_compiland(module, + ctx.load_offset + low_pc.u.uvalue, + source_new(module, comp_dir.u.string, name.u.string))->symt; + + if (di->abbrev->have_child) + { + int i; + for (i=0; ichildren); i++) + { + pdi = vector_at(&di->children, i); + dwarf2_load_one_entry(&ctx, *pdi, (struct symt_compiland*)di->symt); + } + } + if (dwarf2_find_attribute(&ctx, di, DW_AT_stmt_list, &stmt_list)) + { + if (dwarf2_parse_line_numbers(sections, &ctx, comp_dir.u.string, stmt_list.u.uvalue)) + module->module.LineNumbers = TRUE; + } + ret = TRUE; + } + else FIXME("Should have a compilation unit here\n"); + pool_destroy(&ctx.pool); + return ret; +} + +static BOOL dwarf2_lookup_loclist(const struct module* module, const BYTE* start, + unsigned long ip, + dwarf2_traverse_context_t* lctx) +{ + DWORD beg, end; + const BYTE* ptr = start; + DWORD len; + + while (ptr < module->dwarf2_info->debug_loc.address + module->dwarf2_info->debug_loc.size) + { + beg = dwarf2_get_u4(ptr); ptr += 4; + end = dwarf2_get_u4(ptr); ptr += 4; + if (!beg && !end) break; + len = dwarf2_get_u2(ptr); ptr += 2; + + if (beg <= ip && ip < end) + { + lctx->data = ptr; + lctx->end_data = ptr + len; + lctx->word_size = 4; /* FIXME word size !!! */ + return TRUE; + } + ptr += len; + } + WARN("Couldn't find ip in location list\n"); + return FALSE; +} + +static enum location_error loc_compute_frame(struct process* pcs, + const struct module* module, + const struct symt_function* func, + DWORD ip, struct location* frame) +{ + struct symt** psym = NULL; + struct location* pframe; + dwarf2_traverse_context_t lctx; + enum location_error err; + int i; + + for (i=0; ivchildren); i++) + { + psym = vector_at(&func->vchildren, i); + if ((*psym)->tag == SymTagCustom) + { + pframe = &((struct symt_function_point*)*psym)->loc; + + /* First, recompute the frame information, if needed */ + switch (pframe->kind) + { + case loc_regrel: + case loc_register: + *frame = *pframe; + break; + case loc_dwarf2_location_list: + WARN("Searching loclist for %s\n", func->hash_elt.name); + if (!dwarf2_lookup_loclist(module, + module->dwarf2_info->debug_loc.address + pframe->offset, + ip, &lctx)) + return loc_err_out_of_scope; + if ((err = compute_location(&lctx, frame, pcs->handle, NULL)) < 0) return err; + if (frame->kind >= loc_user) + { + WARN("Couldn't compute runtime frame location\n"); + return loc_err_too_complex; + } + break; + default: + WARN("Unsupported frame kind %d\n", pframe->kind); + return loc_err_internal; + } + return 0; + } + } + WARN("Couldn't find Custom function point, whilst location list offset is searched\n"); + return loc_err_internal; +} + +static void dwarf2_location_compute(struct process* pcs, + const struct module* module, + const struct symt_function* func, + struct location* loc) +{ + struct location frame; + DWORD ip; + int err; + dwarf2_traverse_context_t lctx; + + if (!func->container || func->container->tag != SymTagCompiland) + { + WARN("We'd expect function %s's container to exist and be a compiland\n", func->hash_elt.name); + err = loc_err_internal; + } + else + { + /* instruction pointer relative to compiland's start */ + ip = pcs->ctx_frame.InstructionOffset - ((struct symt_compiland*)func->container)->address; + + if ((err = loc_compute_frame(pcs, module, func, ip, &frame)) == 0) + { + switch (loc->kind) + { + case loc_dwarf2_location_list: + /* Then, if the variable has a location list, find it !! */ + if (dwarf2_lookup_loclist(module, + module->dwarf2_info->debug_loc.address + loc->offset, + ip, &lctx)) + goto do_compute; + err = loc_err_out_of_scope; + break; + case loc_dwarf2_block: + /* or if we have a copy of an existing block, get ready for it */ + { + unsigned* ptr = (unsigned*)loc->offset; + + lctx.data = (const BYTE*)(ptr + 1); + lctx.end_data = lctx.data + *ptr; + lctx.word_size = 4; /* FIXME !! */ + } + do_compute: + /* now get the variable */ + err = compute_location(&lctx, loc, pcs->handle, &frame); + break; + case loc_register: + case loc_regrel: + /* nothing to do */ + break; + default: + WARN("Unsupported local kind %d\n", loc->kind); + err = loc_err_internal; + } + } + } + if (err < 0) + { + loc->kind = loc_register; + loc->reg = err; + } +} + +BOOL dwarf2_parse(struct module* module, unsigned long load_offset, + const struct elf_thunk_area* thunks, + const unsigned char* debug, unsigned int debug_size, + const unsigned char* abbrev, unsigned int abbrev_size, + const unsigned char* str, unsigned int str_size, + const unsigned char* line, unsigned int line_size, + const unsigned char* loclist, unsigned int loclist_size) +{ + dwarf2_section_t section[section_max]; + unsigned char* ptr; + const unsigned char*comp_unit_cursor = debug; + const unsigned char*end_debug = debug + debug_size; + + module->loc_compute = dwarf2_location_compute; + + section[section_debug].address = debug; + section[section_debug].size = debug_size; + section[section_abbrev].address = abbrev; + section[section_abbrev].size = abbrev_size; + section[section_string].address = str; + section[section_string].size = str_size; + section[section_line].address = line; + section[section_line].size = line_size; + + if (loclist_size) + { + /* initialize the dwarf2 specific info block for this module. + * As we'll need later on the .debug_loc section content, we copy it in + * the module structure for later reuse + */ + module->dwarf2_info = HeapAlloc(GetProcessHeap(), 0, sizeof(*module->dwarf2_info) + loclist_size); + if (!module->dwarf2_info) return FALSE; + ptr = (unsigned char*)(module->dwarf2_info + 1); + memcpy(ptr, loclist, loclist_size); + module->dwarf2_info->debug_loc.address = ptr; + module->dwarf2_info->debug_loc.size = loclist_size; + } + + while (comp_unit_cursor < end_debug) + { + const dwarf2_comp_unit_stream_t* comp_unit_stream; + dwarf2_comp_unit_t comp_unit; + + comp_unit_stream = (const dwarf2_comp_unit_stream_t*) comp_unit_cursor; + comp_unit.length = *(const unsigned long*) comp_unit_stream->length; + comp_unit.version = *(const unsigned short*) comp_unit_stream->version; + comp_unit.abbrev_offset = *(const unsigned long*) comp_unit_stream->abbrev_offset; + comp_unit.word_size = *(const unsigned char*) comp_unit_stream->word_size; + + dwarf2_parse_compilation_unit(section, &comp_unit, module, + thunks, comp_unit_cursor, load_offset); + comp_unit_cursor += comp_unit.length + sizeof(unsigned); + } + module->module.SymType = SymDia; + module->module.CVSig = 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24); + /* FIXME: we could have a finer grain here */ + module->module.GlobalSymbols = TRUE; + module->module.TypeInfo = TRUE; + module->module.SourceIndexed = TRUE; + module->module.Publics = TRUE; + return TRUE; +} diff --git a/reactos/dll/win32/dbghelp/dwarf.h b/reactos/dll/win32/dbghelp/dwarf.h new file mode 100644 index 00000000000..c03799ef9ca --- /dev/null +++ b/reactos/dll/win32/dbghelp/dwarf.h @@ -0,0 +1,403 @@ +/* + * dwarf2 definitions + * + * Copyright (C) 2005, Raphael Junqueira + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +typedef struct +{ + unsigned char length[4]; + unsigned char version[2]; + unsigned char abbrev_offset[4]; + unsigned char word_size[1]; +} dwarf2_comp_unit_stream_t; + +typedef struct +{ + unsigned long length; + unsigned short version; + unsigned long abbrev_offset; + unsigned char word_size; +} dwarf2_comp_unit_t; + +typedef struct +{ + unsigned int length; + unsigned short version; + unsigned int prologue_length; + unsigned char min_insn_length; + unsigned char default_is_stmt; + int line_base; + unsigned char line_range; + unsigned char opcode_base; +} dwarf2_line_info_t; + +typedef enum dwarf_tag_e +{ + DW_TAG_padding = 0x00, + DW_TAG_array_type = 0x01, + DW_TAG_class_type = 0x02, + DW_TAG_entry_point = 0x03, + DW_TAG_enumeration_type = 0x04, + DW_TAG_formal_parameter = 0x05, + DW_TAG_imported_declaration = 0x08, + DW_TAG_label = 0x0a, + DW_TAG_lexical_block = 0x0b, + DW_TAG_member = 0x0d, + DW_TAG_pointer_type = 0x0f, + DW_TAG_reference_type = 0x10, + DW_TAG_compile_unit = 0x11, + DW_TAG_string_type = 0x12, + DW_TAG_structure_type = 0x13, + DW_TAG_subroutine_type = 0x15, + DW_TAG_typedef = 0x16, + DW_TAG_union_type = 0x17, + DW_TAG_unspecified_parameters = 0x18, + DW_TAG_variant = 0x19, + DW_TAG_common_block = 0x1a, + DW_TAG_common_inclusion = 0x1b, + DW_TAG_inheritance = 0x1c, + DW_TAG_inlined_subroutine = 0x1d, + DW_TAG_module = 0x1e, + DW_TAG_ptr_to_member_type = 0x1f, + DW_TAG_set_type = 0x20, + DW_TAG_subrange_type = 0x21, + DW_TAG_with_stmt = 0x22, + DW_TAG_access_declaration = 0x23, + DW_TAG_base_type = 0x24, + DW_TAG_catch_block = 0x25, + DW_TAG_const_type = 0x26, + DW_TAG_constant = 0x27, + DW_TAG_enumerator = 0x28, + DW_TAG_file_type = 0x29, + DW_TAG_friend = 0x2a, + DW_TAG_namelist = 0x2b, + DW_TAG_namelist_item = 0x2c, + DW_TAG_packed_type = 0x2d, + DW_TAG_subprogram = 0x2e, + DW_TAG_template_type_param = 0x2f, + DW_TAG_template_value_param = 0x30, + DW_TAG_thrown_type = 0x31, + DW_TAG_try_block = 0x32, + DW_TAG_variant_part = 0x33, + DW_TAG_variable = 0x34, + DW_TAG_volatile_type = 0x35, + /** extensions */ + DW_TAG_MIPS_loop = 0x4081, + DW_TAG_format_label = 0x4101, + DW_TAG_function_template = 0x4102, + DW_TAG_class_template = 0x4103 +} dwarf_tag_t; + +typedef enum dwarf_attribute_e +{ + DW_AT_sibling = 0x01, + DW_AT_location = 0x02, + DW_AT_name = 0x03, + DW_AT_ordering = 0x09, + DW_AT_subscr_data = 0x0a, + DW_AT_byte_size = 0x0b, + DW_AT_bit_offset = 0x0c, + DW_AT_bit_size = 0x0d, + DW_AT_element_list = 0x0f, + DW_AT_stmt_list = 0x10, + DW_AT_low_pc = 0x11, + DW_AT_high_pc = 0x12, + DW_AT_language = 0x13, + DW_AT_member = 0x14, + DW_AT_discr = 0x15, + DW_AT_discr_value = 0x16, + DW_AT_visibility = 0x17, + DW_AT_import = 0x18, + DW_AT_string_length = 0x19, + DW_AT_common_reference = 0x1a, + DW_AT_comp_dir = 0x1b, + DW_AT_const_value = 0x1c, + DW_AT_containing_type = 0x1d, + DW_AT_default_value = 0x1e, + DW_AT_inline = 0x20, + DW_AT_is_optional = 0x21, + DW_AT_lower_bound = 0x22, + DW_AT_producer = 0x25, + DW_AT_prototyped = 0x27, + DW_AT_return_addr = 0x2a, + DW_AT_start_scope = 0x2c, + DW_AT_stride_size = 0x2e, + DW_AT_upper_bound = 0x2f, + DW_AT_abstract_origin = 0x31, + DW_AT_accessibility = 0x32, + DW_AT_address_class = 0x33, + DW_AT_artificial = 0x34, + DW_AT_base_types = 0x35, + DW_AT_calling_convention = 0x36, + DW_AT_count = 0x37, + DW_AT_data_member_location = 0x38, + DW_AT_decl_column = 0x39, + DW_AT_decl_file = 0x3a, + DW_AT_decl_line = 0x3b, + DW_AT_declaration = 0x3c, + DW_AT_discr_list = 0x3d, + DW_AT_encoding = 0x3e, + DW_AT_external = 0x3f, + DW_AT_frame_base = 0x40, + DW_AT_friend = 0x41, + DW_AT_identifier_case = 0x42, + DW_AT_macro_info = 0x43, + DW_AT_namelist_items = 0x44, + DW_AT_priority = 0x45, + DW_AT_segment = 0x46, + DW_AT_specification = 0x47, + DW_AT_static_link = 0x48, + DW_AT_type = 0x49, + DW_AT_use_location = 0x4a, + DW_AT_variable_parameter = 0x4b, + DW_AT_virtuality = 0x4c, + DW_AT_vtable_elem_location = 0x4d, + + DW_AT_ranges = 0x55, + /* extensions */ + DW_AT_MIPS_fde = 0x2001, + DW_AT_MIPS_loop_begin = 0x2002, + DW_AT_MIPS_tail_loop_begin = 0x2003, + DW_AT_MIPS_epilog_begin = 0x2004, + DW_AT_MIPS_loop_unroll_factor = 0x2005, + DW_AT_MIPS_software_pipeline_depth = 0x2006, + DW_AT_MIPS_linkage_name = 0x2007, + DW_AT_MIPS_stride = 0x2008, + DW_AT_MIPS_abstract_name = 0x2009, + DW_AT_MIPS_clone_origin = 0x200a, + DW_AT_MIPS_has_inlines = 0x200b, + DW_AT_sf_names = 0x2101, + DW_AT_src_info = 0x2102, + DW_AT_mac_info = 0x2103, + DW_AT_src_coords = 0x2104, + DW_AT_body_begin = 0x2105, + DW_AT_body_end = 0x2106 +} dwarf_attribute_t; + +typedef enum dwarf_form_e +{ + DW_FORM_addr = 0x01, + DW_FORM_block2 = 0x03, + DW_FORM_block4 = 0x04, + DW_FORM_data2 = 0x05, + DW_FORM_data4 = 0x06, + DW_FORM_data8 = 0x07, + DW_FORM_string = 0x08, + DW_FORM_block = 0x09, + DW_FORM_block1 = 0x0a, + DW_FORM_data1 = 0x0b, + DW_FORM_flag = 0x0c, + DW_FORM_sdata = 0x0d, + DW_FORM_strp = 0x0e, + DW_FORM_udata = 0x0f, + DW_FORM_ref_addr = 0x10, + DW_FORM_ref1 = 0x11, + DW_FORM_ref2 = 0x12, + DW_FORM_ref4 = 0x13, + DW_FORM_ref8 = 0x14, + DW_FORM_ref_udata = 0x15, + DW_FORM_indirect = 0x16 +} dwarf_form_t; + +/** type encoding */ +typedef enum dwarf_type_e +{ + DW_ATE_void = 0x0, + DW_ATE_address = 0x1, + DW_ATE_boolean = 0x2, + DW_ATE_complex_float = 0x3, + DW_ATE_float = 0x4, + DW_ATE_signed = 0x5, + DW_ATE_signed_char = 0x6, + DW_ATE_unsigned = 0x7, + DW_ATE_unsigned_char = 0x8 +} dwarf_type_t; + +typedef enum dwarf_operation_e +{ + DW_OP_addr = 0x03, + DW_OP_deref = 0x06, + DW_OP_const1u = 0x08, + DW_OP_const1s = 0x09, + DW_OP_const2u = 0x0a, + DW_OP_const2s = 0x0b, + DW_OP_const4u = 0x0c, + DW_OP_const4s = 0x0d, + DW_OP_const8u = 0x0e, + DW_OP_const8s = 0x0f, + DW_OP_constu = 0x10, + DW_OP_consts = 0x11, + DW_OP_dup = 0x12, + DW_OP_drop = 0x13, + DW_OP_over = 0x14, + DW_OP_pick = 0x15, + DW_OP_swap = 0x16, + DW_OP_rot = 0x17, + DW_OP_xderef = 0x18, + DW_OP_abs = 0x19, + DW_OP_and = 0x1a, + DW_OP_div = 0x1b, + DW_OP_minus = 0x1c, + DW_OP_mod = 0x1d, + DW_OP_mul = 0x1e, + DW_OP_neg = 0x1f, + DW_OP_not = 0x20, + DW_OP_or = 0x21, + DW_OP_plus = 0x22, + DW_OP_plus_uconst = 0x23, + DW_OP_shl = 0x24, + DW_OP_shr = 0x25, + DW_OP_shra = 0x26, + DW_OP_xor = 0x27, + DW_OP_bra = 0x28, + DW_OP_eq = 0x29, + DW_OP_ge = 0x2a, + DW_OP_gt = 0x2b, + DW_OP_le = 0x2c, + DW_OP_lt = 0x2d, + DW_OP_ne = 0x2e, + DW_OP_skip = 0x2f, + DW_OP_lit0 = 0x30, + DW_OP_lit1 = 0x31, + DW_OP_lit2 = 0x32, + DW_OP_lit3 = 0x33, + DW_OP_lit4 = 0x34, + DW_OP_lit5 = 0x35, + DW_OP_lit6 = 0x36, + DW_OP_lit7 = 0x37, + DW_OP_lit8 = 0x38, + DW_OP_lit9 = 0x39, + DW_OP_lit10 = 0x3a, + DW_OP_lit11 = 0x3b, + DW_OP_lit12 = 0x3c, + DW_OP_lit13 = 0x3d, + DW_OP_lit14 = 0x3e, + DW_OP_lit15 = 0x3f, + DW_OP_lit16 = 0x40, + DW_OP_lit17 = 0x41, + DW_OP_lit18 = 0x42, + DW_OP_lit19 = 0x43, + DW_OP_lit20 = 0x44, + DW_OP_lit21 = 0x45, + DW_OP_lit22 = 0x46, + DW_OP_lit23 = 0x47, + DW_OP_lit24 = 0x48, + DW_OP_lit25 = 0x49, + DW_OP_lit26 = 0x4a, + DW_OP_lit27 = 0x4b, + DW_OP_lit28 = 0x4c, + DW_OP_lit29 = 0x4d, + DW_OP_lit30 = 0x4e, + DW_OP_lit31 = 0x4f, + DW_OP_reg0 = 0x50, + DW_OP_reg1 = 0x51, + DW_OP_reg2 = 0x52, + DW_OP_reg3 = 0x53, + DW_OP_reg4 = 0x54, + DW_OP_reg5 = 0x55, + DW_OP_reg6 = 0x56, + DW_OP_reg7 = 0x57, + DW_OP_reg8 = 0x58, + DW_OP_reg9 = 0x59, + DW_OP_reg10 = 0x5a, + DW_OP_reg11 = 0x5b, + DW_OP_reg12 = 0x5c, + DW_OP_reg13 = 0x5d, + DW_OP_reg14 = 0x5e, + DW_OP_reg15 = 0x5f, + DW_OP_reg16 = 0x60, + DW_OP_reg17 = 0x61, + DW_OP_reg18 = 0x62, + DW_OP_reg19 = 0x63, + DW_OP_reg20 = 0x64, + DW_OP_reg21 = 0x65, + DW_OP_reg22 = 0x66, + DW_OP_reg23 = 0x67, + DW_OP_reg24 = 0x68, + DW_OP_reg25 = 0x69, + DW_OP_reg26 = 0x6a, + DW_OP_reg27 = 0x6b, + DW_OP_reg28 = 0x6c, + DW_OP_reg29 = 0x6d, + DW_OP_reg30 = 0x6e, + DW_OP_reg31 = 0x6f, + DW_OP_breg0 = 0x70, + DW_OP_breg1 = 0x71, + DW_OP_breg2 = 0x72, + DW_OP_breg3 = 0x73, + DW_OP_breg4 = 0x74, + DW_OP_breg5 = 0x75, + DW_OP_breg6 = 0x76, + DW_OP_breg7 = 0x77, + DW_OP_breg8 = 0x78, + DW_OP_breg9 = 0x79, + DW_OP_breg10 = 0x7a, + DW_OP_breg11 = 0x7b, + DW_OP_breg12 = 0x7c, + DW_OP_breg13 = 0x7d, + DW_OP_breg14 = 0x7e, + DW_OP_breg15 = 0x7f, + DW_OP_breg16 = 0x80, + DW_OP_breg17 = 0x81, + DW_OP_breg18 = 0x82, + DW_OP_breg19 = 0x83, + DW_OP_breg20 = 0x84, + DW_OP_breg21 = 0x85, + DW_OP_breg22 = 0x86, + DW_OP_breg23 = 0x87, + DW_OP_breg24 = 0x88, + DW_OP_breg25 = 0x89, + DW_OP_breg26 = 0x8a, + DW_OP_breg27 = 0x8b, + DW_OP_breg28 = 0x8c, + DW_OP_breg29 = 0x8d, + DW_OP_breg30 = 0x8e, + DW_OP_breg31 = 0x8f, + DW_OP_regx = 0x90, + DW_OP_fbreg = 0x91, + DW_OP_bregx = 0x92, + DW_OP_piece = 0x93, + DW_OP_deref_size = 0x94, + DW_OP_xderef_size = 0x95, + DW_OP_nop = 0x96 +} dwarf_operation_t; + +enum dwarf_calling_convention +{ + DW_CC_normal = 0x1, + DW_CC_program = 0x2, + DW_CC_nocall = 0x3 +}; + +#define DW_CC_lo_user 0x40 +#define DW_CC_hi_user 0xff + +#define DW_LNS_extended_op 0x00 +#define DW_LNS_copy 0x01 +#define DW_LNS_advance_pc 0x02 +#define DW_LNS_advance_line 0x03 +#define DW_LNS_set_file 0x04 +#define DW_LNS_set_column 0x05 +#define DW_LNS_negate_stmt 0x06 +#define DW_LNS_set_basic_block 0x07 +#define DW_LNS_const_add_pc 0x08 +#define DW_LNS_fixed_advance_pc 0x09 + +#define DW_LNE_end_sequence 0x01 +#define DW_LNE_set_address 0x02 +#define DW_LNE_define_file 0x03 diff --git a/reactos/dll/win32/dbghelp/elf_module.c b/reactos/dll/win32/dbghelp/elf_module.c index ac7fafef9da..30b7a3c0102 100644 --- a/reactos/dll/win32/dbghelp/elf_module.c +++ b/reactos/dll/win32/dbghelp/elf_module.c @@ -2,7 +2,7 @@ * File elf.c - processing of ELF files * * Copyright (C) 1996, Eric Youngdale. - * 1999-2004 Eric Pouech + * 1999-2007 Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -16,15 +16,25 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" +#include "wine/port.h" + +#if defined(__svr4__) || defined(__sun) +#define __ELF__ 1 +/* large files are not supported by libelf */ +#undef _FILE_OFFSET_BITS +#define _FILE_OFFSET_BITS 32 +#endif #include #include #include -#include +#ifdef HAVE_SYS_STAT_H +# include +#endif #include #ifdef HAVE_SYS_MMAN_H #include @@ -38,10 +48,6 @@ #include "dbghelp_private.h" -#if defined(__svr4__) || defined(__sun) -#define __ELF__ -#endif - #ifdef HAVE_ELF_H # include #endif @@ -66,10 +72,9 @@ # include #endif +#include "wine/library.h" #include "wine/debug.h" -WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); - struct elf_module_info { unsigned long elf_addr; @@ -81,23 +86,51 @@ struct elf_module_info #define ELF_INFO_DEBUG_HEADER 0x0001 #define ELF_INFO_MODULE 0x0002 +#define ELF_INFO_NAME 0x0004 + +WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); struct elf_info { unsigned flags; /* IN one (or several) of the ELF_INFO constants */ unsigned long dbg_hdr_addr; /* OUT address of debug header (if ELF_INFO_DEBUG_HEADER is set) */ struct module* module; /* OUT loaded module (if ELF_INFO_MODULE is set) */ + const WCHAR* module_name; /* OUT found module name (if ELF_INFO_NAME is set) */ +}; + +/* structure holding information while handling an ELF image + * allows one by one section mapping for memory savings + */ +struct elf_file_map +{ + Elf32_Ehdr elfhdr; + size_t elf_size; + size_t elf_start; + struct + { + Elf32_Shdr shdr; + const char* mapped; + }* sect; + int fd; + const char* shstrtab; + struct elf_file_map* alternate; /* another ELF file (linked to this one) */ +}; + +struct elf_section_map +{ + struct elf_file_map* fmap; + long sidx; }; struct symtab_elt { struct hash_table_elt ht_elt; const Elf32_Sym* symp; - const char* filename; + struct symt_compiland* compiland; unsigned used; }; -struct thunk_area +struct elf_thunk_area { const char* symname; THUNK_ORDINAL ordinal; @@ -105,29 +138,254 @@ struct thunk_area unsigned long rva_end; }; +/****************************************************************** + * elf_map_section + * + * Maps a single section into memory from an ELF file + */ +static const char* elf_map_section(struct elf_section_map* esm) +{ + unsigned pgsz = getpagesize(); + unsigned ofst, size; + + if (esm->sidx < 0 || esm->sidx >= esm->fmap->elfhdr.e_shnum || + esm->fmap->sect[esm->sidx].shdr.sh_type == SHT_NOBITS) + return ELF_NO_MAP; + + /* align required information on page size (we assume pagesize is a power of 2) */ + ofst = esm->fmap->sect[esm->sidx].shdr.sh_offset & ~(pgsz - 1); + size = ((esm->fmap->sect[esm->sidx].shdr.sh_offset + + esm->fmap->sect[esm->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst; + esm->fmap->sect[esm->sidx].mapped = mmap(NULL, size, PROT_READ, MAP_PRIVATE, + esm->fmap->fd, ofst); + if (esm->fmap->sect[esm->sidx].mapped == ELF_NO_MAP) return ELF_NO_MAP; + return esm->fmap->sect[esm->sidx].mapped + (esm->fmap->sect[esm->sidx].shdr.sh_offset & (pgsz - 1)); +} + +/****************************************************************** + * elf_find_section + * + * Finds a section by name (and type) into memory from an ELF file + * or its alternate if any + */ +static BOOL elf_find_section(struct elf_file_map* fmap, const char* name, + unsigned sht, struct elf_section_map* esm) +{ + unsigned i; + + while (fmap) + { + if (fmap->shstrtab == ELF_NO_MAP) + { + struct elf_section_map hdr_esm = {fmap, fmap->elfhdr.e_shstrndx}; + if ((fmap->shstrtab = elf_map_section(&hdr_esm)) == ELF_NO_MAP) break; + } + for (i = 0; i < fmap->elfhdr.e_shnum; i++) + { + if (strcmp(fmap->shstrtab + fmap->sect[i].shdr.sh_name, name) == 0 && + (sht == SHT_NULL || sht == fmap->sect[i].shdr.sh_type)) + { + esm->fmap = fmap; + esm->sidx = i; + return TRUE; + } + } + fmap = fmap->alternate; + } + esm->fmap = NULL; + esm->sidx = -1; + return FALSE; +} + +/****************************************************************** + * elf_unmap_section + * + * Unmaps a single section from memory + */ +static void elf_unmap_section(struct elf_section_map* esm) +{ + if (esm->sidx >= 0 && esm->sidx < esm->fmap->elfhdr.e_shnum && esm->fmap->sect[esm->sidx].mapped != ELF_NO_MAP) + { + unsigned pgsz = getpagesize(); + unsigned ofst, size; + + ofst = esm->fmap->sect[esm->sidx].shdr.sh_offset & ~(pgsz - 1); + size = ((esm->fmap->sect[esm->sidx].shdr.sh_offset + + esm->fmap->sect[esm->sidx].shdr.sh_size + pgsz - 1) & ~(pgsz - 1)) - ofst; + if (munmap((char*)esm->fmap->sect[esm->sidx].mapped, size) < 0) + WARN("Couldn't unmap the section\n"); + esm->fmap->sect[esm->sidx].mapped = ELF_NO_MAP; + } +} + +static void elf_end_find(struct elf_file_map* fmap) +{ + struct elf_section_map esm; + + while (fmap) + { + esm.fmap = fmap; + esm.sidx = fmap->elfhdr.e_shstrndx; + elf_unmap_section(&esm); + fmap->shstrtab = ELF_NO_MAP; + fmap = fmap->alternate; + } +} + +/****************************************************************** + * elf_get_map_size + * + * Get the size of an ELF section + */ +static inline unsigned elf_get_map_size(struct elf_section_map* esm) +{ + if (esm->sidx < 0 || esm->sidx >= esm->fmap->elfhdr.e_shnum) + return 0; + return esm->fmap->sect[esm->sidx].shdr.sh_size; +} + +/****************************************************************** + * elf_map_file + * + * Maps an ELF file into memory (and checks it's a real ELF file) + */ +static BOOL elf_map_file(const WCHAR* filenameW, struct elf_file_map* fmap) +{ + static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 }; + struct stat statbuf; + int i; + Elf32_Phdr phdr; + unsigned tmp, page_mask = getpagesize() - 1; + char* filename; + unsigned len; + BOOL ret = FALSE; + + len = WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, NULL, 0, NULL, NULL); + if (!(filename = HeapAlloc(GetProcessHeap(), 0, len))) return FALSE; + WideCharToMultiByte(CP_UNIXCP, 0, filenameW, -1, filename, len, NULL, NULL); + + fmap->fd = -1; + fmap->shstrtab = ELF_NO_MAP; + fmap->alternate = NULL; + + /* check that the file exists, and that the module hasn't been loaded yet */ + if (stat(filename, &statbuf) == -1 || S_ISDIR(statbuf.st_mode)) goto done; + + /* Now open the file, so that we can mmap() it. */ + if ((fmap->fd = open(filename, O_RDONLY)) == -1) goto done; + + if (read(fmap->fd, &fmap->elfhdr, sizeof(fmap->elfhdr)) != sizeof(fmap->elfhdr)) + goto done; + /* and check for an ELF header */ + if (memcmp(fmap->elfhdr.e_ident, + elf_signature, sizeof(elf_signature))) goto done; + + fmap->sect = HeapAlloc(GetProcessHeap(), 0, + fmap->elfhdr.e_shnum * sizeof(fmap->sect[0])); + if (!fmap->sect) goto done; + + lseek(fmap->fd, fmap->elfhdr.e_shoff, SEEK_SET); + for (i = 0; i < fmap->elfhdr.e_shnum; i++) + { + read(fmap->fd, &fmap->sect[i].shdr, sizeof(fmap->sect[i].shdr)); + fmap->sect[i].mapped = ELF_NO_MAP; + } + + /* grab size of module once loaded in memory */ + lseek(fmap->fd, fmap->elfhdr.e_phoff, SEEK_SET); + fmap->elf_size = 0; + fmap->elf_start = ~0L; + for (i = 0; i < fmap->elfhdr.e_phnum; i++) + { + if (read(fmap->fd, &phdr, sizeof(phdr)) == sizeof(phdr) && + phdr.p_type == PT_LOAD) + { + tmp = (phdr.p_vaddr + phdr.p_memsz + page_mask) & ~page_mask; + if (fmap->elf_size < tmp) fmap->elf_size = tmp; + if (phdr.p_vaddr < fmap->elf_start) fmap->elf_start = phdr.p_vaddr; + } + } + /* if non relocatable ELF, then remove fixed address from computation + * otherwise, all addresses are zero based and start has no effect + */ + fmap->elf_size -= fmap->elf_start; + ret = TRUE; +done: + HeapFree(GetProcessHeap(), 0, filename); + return ret; +} + +/****************************************************************** + * elf_unmap_file + * + * Unmaps an ELF file from memory (previously mapped with elf_map_file) + */ +static void elf_unmap_file(struct elf_file_map* fmap) +{ + while (fmap) + { + if (fmap->fd != -1) + { + struct elf_section_map esm; + esm.fmap = fmap; + for (esm.sidx = 0; esm.sidx < fmap->elfhdr.e_shnum; esm.sidx++) + { + elf_unmap_section(&esm); + } + HeapFree(GetProcessHeap(), 0, fmap->sect); + close(fmap->fd); + } + fmap = fmap->alternate; + } +} + +/****************************************************************** + * elf_is_in_thunk_area + * + * Check whether an address lies within one of the thunk area we + * know of. + */ +int elf_is_in_thunk_area(unsigned long addr, + const struct elf_thunk_area* thunks) +{ + unsigned i; + + for (i = 0; thunks[i].symname; i++) + { + if (addr >= thunks[i].rva_start && addr < thunks[i].rva_end) + return i; + } + return -1; +} + /****************************************************************** * elf_hash_symtab * * creating an internal hash table to ease use ELF symtab information lookup */ -static void elf_hash_symtab(const struct module* module, struct pool* pool, - struct hash_table* ht_symtab, const char* map_addr, - const Elf32_Shdr* symtab, const Elf32_Shdr* strtab, - unsigned num_areas, struct thunk_area* thunks) +static void elf_hash_symtab(struct module* module, struct pool* pool, + struct hash_table* ht_symtab, struct elf_file_map* fmap, + struct elf_thunk_area* thunks) { int i, j, nsym; const char* strp; const char* symname; - const char* filename = NULL; + struct symt_compiland* compiland = NULL; const char* ptr; const Elf32_Sym* symp; struct symtab_elt* ste; + struct elf_section_map esm, esm_str; - symp = (const Elf32_Sym*)(map_addr + symtab->sh_offset); - nsym = symtab->sh_size / sizeof(*symp); - strp = (const char*)(map_addr + strtab->sh_offset); + if (!elf_find_section(fmap, ".symtab", SHT_SYMTAB, &esm) && + !elf_find_section(fmap, ".dynsym", SHT_DYNSYM, &esm)) return; + if ((symp = (const Elf32_Sym*)elf_map_section(&esm)) == ELF_NO_MAP) return; + esm_str.fmap = fmap; + esm_str.sidx = fmap->sect[esm.sidx].shdr.sh_link; + if ((strp = elf_map_section(&esm_str)) == ELF_NO_MAP) return; - for (j = 0; j < num_areas; j++) + nsym = elf_get_map_size(&esm) / sizeof(*symp); + + for (j = 0; thunks[j].symname; j++) thunks[j].rva_start = thunks[j].rva_end = 0; for (i = 0; i < nsym; i++, symp++) @@ -135,28 +393,40 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool, /* Ignore certain types of entries which really aren't of that much * interest. */ - if (ELF32_ST_TYPE(symp->st_info) == STT_SECTION || symp->st_shndx == SHN_UNDEF) + if ((ELF32_ST_TYPE(symp->st_info) != STT_NOTYPE && + ELF32_ST_TYPE(symp->st_info) != STT_FILE && + ELF32_ST_TYPE(symp->st_info) != STT_OBJECT && + ELF32_ST_TYPE(symp->st_info) != STT_FUNC) || + symp->st_shndx == SHN_UNDEF) { continue; } symname = strp + symp->st_name; - if (ELF32_ST_TYPE(symp->st_info) == STT_FILE) + /* handle some specific symtab (that we'll throw away when done) */ + switch (ELF32_ST_TYPE(symp->st_info)) { - filename = symname; + case STT_FILE: + if (symname) + compiland = symt_new_compiland(module, symp->st_value, + source_new(module, NULL, symname)); + else + compiland = NULL; + continue; + case STT_NOTYPE: + /* we are only interested in wine markers inserted by winebuild */ + for (j = 0; thunks[j].symname; j++) + { + if (!strcmp(symname, thunks[j].symname)) + { + thunks[j].rva_start = symp->st_value; + thunks[j].rva_end = symp->st_value + symp->st_size; + break; + } + } continue; } - for (j = 0; j < num_areas; j++) - { - if (!strcmp(symname, thunks[j].symname)) - { - thunks[j].rva_start = symp->st_value; - thunks[j].rva_end = symp->st_value + symp->st_size; - break; - } - } - if (j < num_areas) continue; /* FIXME: we don't need to handle them (GCC internals) * Moreover, they screw up our symbol lookup :-/ @@ -165,7 +435,8 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool, continue; ste = pool_alloc(pool, sizeof(*ste)); - /* GCC seems to emit, in some cases, a .+ suffix. + ste->ht_elt.name = symname; + /* GCC emits, in some cases, a .+ suffix. * This is used for static variable inside functions, so * that we can have several such variables with same name in * the same compilation unit @@ -173,10 +444,9 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool, * of it in stabs parsing) */ ptr = symname + strlen(symname) - 1; - ste->ht_elt.name = symname; if (isdigit(*ptr)) { - while (*ptr >= '0' && *ptr <= '9' && ptr >= symname) ptr--; + while (isdigit(*ptr) && ptr >= symname) ptr--; if (ptr > symname && *ptr == '.') { char* n = pool_alloc(pool, ptr - symname + 1); @@ -186,10 +456,14 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool, } } ste->symp = symp; - ste->filename = filename; + ste->compiland = compiland; ste->used = 0; hash_table_add(ht_symtab, &ste->ht_elt); } + /* as we added in the ht_symtab pointers to the symbols themselves, + * we cannot unmap yet the sections, it will be done when we're over + * with this ELF file + */ } /****************************************************************** @@ -197,7 +471,7 @@ static void elf_hash_symtab(const struct module* module, struct pool* pool, * * lookup a symbol by name in our internal hash table for the symtab */ -static const Elf32_Sym* elf_lookup_symtab(const struct module* module, +static const Elf32_Sym* elf_lookup_symtab(const struct module* module, const struct hash_table* ht_symtab, const char* name, struct symt* compiland) { @@ -209,7 +483,7 @@ static const Elf32_Sym* elf_lookup_symtab(const struct module* module, const char* compiland_basename; const char* base; - /* we need weak match up (at least) when symbols of same name, + /* we need weak match up (at least) when symbols of same name, * defined several times in different compilation units, * are merged in a single one (hence a different filename for c.u.) */ @@ -221,29 +495,31 @@ static const Elf32_Sym* elf_lookup_symtab(const struct module* module, if (!compiland_basename++) compiland_basename = compiland_name; } else compiland_name = compiland_basename = NULL; - + hash_table_iter_init(ht_symtab, &hti, name); while ((ste = hash_table_iter_up(&hti))) { if (ste->used || strcmp(ste->ht_elt.name, name)) continue; weak_result = ste; - if ((ste->filename && !compiland_name) || (!ste->filename && compiland_name)) + if ((ste->compiland && !compiland_name) || (!ste->compiland && compiland_name)) continue; - if (ste->filename && compiland_name) + if (ste->compiland && compiland_name) { - if (strcmp(ste->filename, compiland_name)) + const char* filename = source_get(module, ste->compiland->source); + if (strcmp(filename, compiland_name)) { - base = strrchr(ste->filename, '/'); - if (!base++) base = ste->filename; + base = strrchr(filename, '/'); + if (!base++) base = filename; if (strcmp(base, compiland_basename)) continue; } } if (result) { FIXME("Already found symbol %s (%s) in symtab %s @%08x and %s @%08x\n", - name, compiland_name, result->filename, result->symp->st_value, - ste->filename, ste->symp->st_value); + name, compiland_name, + source_get(module, result->compiland->source), (unsigned int)result->symp->st_value, + source_get(module, ste->compiland->source), (unsigned int)ste->symp->st_value); } else { @@ -253,8 +529,8 @@ static const Elf32_Sym* elf_lookup_symtab(const struct module* module, } if (!result && !(result = weak_result)) { - FIXME("Couldn't find symbol %s.%s in symtab\n", - module->module.ModuleName, name); + FIXME("Couldn't find symbol %s!%s in symtab\n", + debugstr_w(module->module.ModuleName), name); return NULL; } return result->symp; @@ -285,31 +561,50 @@ static void elf_finish_stabs_info(struct module* module, struct hash_table* symt { break; } - symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, + symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, ((struct symt_function*)sym)->container); if (symp) { + if (((struct symt_function*)sym)->address != module->elf_info->elf_addr && + ((struct symt_function*)sym)->address != module->elf_info->elf_addr + symp->st_value) + FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n", + sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name, + ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value); + if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size) + FIXME("Changing size for %p/%s!%s from %08lx to %08x\n", + sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name, + ((struct symt_function*)sym)->size, (unsigned int)symp->st_size); + ((struct symt_function*)sym)->address = module->elf_info->elf_addr + symp->st_value; ((struct symt_function*)sym)->size = symp->st_size; - } else FIXME("Couldn't find %s\n", sym->hash_elt.name); + } else + FIXME("Couldn't find %s!%s\n", + debugstr_w(module->module.ModuleName), sym->hash_elt.name); break; case SymTagData: switch (((struct symt_data*)sym)->kind) { case DataIsGlobal: case DataIsFileStatic: - if (((struct symt_data*)sym)->u.address != module->elf_info->elf_addr) + if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr) break; - symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, + symp = elf_lookup_symtab(module, symtab, sym->hash_elt.name, ((struct symt_data*)sym)->container); if (symp) { - ((struct symt_data*)sym)->u.address = module->elf_info->elf_addr + + if (((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr && + ((struct symt_data*)sym)->u.var.offset != module->elf_info->elf_addr + symp->st_value) + FIXME("Changing address for %p/%s!%s from %08lx to %08lx\n", + sym, debugstr_w(module->module.ModuleName), sym->hash_elt.name, + ((struct symt_function*)sym)->address, module->elf_info->elf_addr + symp->st_value); + ((struct symt_data*)sym)->u.var.offset = module->elf_info->elf_addr + symp->st_value; ((struct symt_data*)sym)->kind = (ELF32_ST_BIND(symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal; - } + } else + FIXME("Couldn't find %s!%s\n", + debugstr_w(module->module.ModuleName), sym->hash_elt.name); break; default:; } @@ -329,68 +624,54 @@ static void elf_finish_stabs_info(struct module* module, struct hash_table* symt * creating the thunk objects for a wine native DLL */ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symtab, - unsigned num_areas, struct thunk_area* thunks) + const struct elf_thunk_area* thunks) { int j; - struct symt_compiland* compiland = NULL; - const char* compiland_name = NULL; struct hash_table_iter hti; struct symtab_elt* ste; DWORD addr; - int idx; + struct symt_ht* symt; hash_table_iter_init(ht_symtab, &hti, NULL); while ((ste = hash_table_iter_up(&hti))) { if (ste->used) continue; - /* FIXME: this is not a good idea anyway... we are creating several - * compiland objects for a same compilation unit - * We try to cache the last compiland used, but it's not enough - * (we should here only create compilands if they are not yet - * defined) - */ - if (!compiland_name || compiland_name != ste->filename) - compiland = symt_new_compiland(module, - compiland_name = ste->filename); - addr = module->elf_info->elf_addr + ste->symp->st_value; - for (j = 0; j < num_areas; j++) + j = elf_is_in_thunk_area(ste->symp->st_value, thunks); + if (j >= 0) /* thunk found */ { - if (ste->symp->st_value >= thunks[j].rva_start && - ste->symp->st_value < thunks[j].rva_end) - break; - } - if (j < num_areas) /* thunk found */ - { - symt_new_thunk(module, compiland, ste->ht_elt.name, thunks[j].ordinal, + symt_new_thunk(module, ste->compiland, ste->ht_elt.name, thunks[j].ordinal, addr, ste->symp->st_size); } else { ULONG64 ref_addr; - idx = symt_find_nearest(module, addr); - if (idx != -1) - symt_get_info(&module->addr_sorttab[idx]->symt, - TI_GET_ADDRESS, &ref_addr); - if (idx == -1 || addr != ref_addr) + symt = symt_find_nearest(module, addr); + if (symt) + symt_get_info(&symt->symt, TI_GET_ADDRESS, &ref_addr); + if (!symt || addr != ref_addr) { /* creating public symbols for all the ELF symbols which haven't been * used yet (ie we have no debug information on them) * That's the case, for example, of the .spec.c files */ - if (ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC) + switch (ELF32_ST_TYPE(ste->symp->st_info)) { - symt_new_function(module, compiland, ste->ht_elt.name, + case STT_FUNC: + symt_new_function(module, ste->compiland, ste->ht_elt.name, addr, ste->symp->st_size, NULL); - } - else - { - symt_new_global_variable(module, compiland, ste->ht_elt.name, + break; + case STT_OBJECT: + symt_new_global_variable(module, ste->compiland, ste->ht_elt.name, ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL, addr, ste->symp->st_size, NULL); + break; + default: + FIXME("Shouldn't happen\n"); + break; } /* FIXME: this is a hack !!! * we are adding new symbols, but as we're parsing a symbol table @@ -401,27 +682,27 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt */ module->sortlist_valid = TRUE; } - else if (strcmp(ste->ht_elt.name, module->addr_sorttab[idx]->hash_elt.name)) + else if (strcmp(ste->ht_elt.name, symt->hash_elt.name)) { - ULONG64 xaddr = 0; - DWORD xsize = 0, kind = -1; + ULONG64 xaddr = 0, xsize = 0; + DWORD kind = -1; - symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_ADDRESS, &xaddr); - symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_LENGTH, &xsize); - symt_get_info(&module->addr_sorttab[idx]->symt, TI_GET_DATAKIND, &kind); + symt_get_info(&symt->symt, TI_GET_ADDRESS, &xaddr); + symt_get_info(&symt->symt, TI_GET_LENGTH, &xsize); + symt_get_info(&symt->symt, TI_GET_DATAKIND, &kind); /* If none of symbols has a correct size, we consider they are both markers * Hence, we can silence this warning - * Also, we check that we don't have two symbols, one local, the other + * Also, we check that we don't have two symbols, one local, the other * global which is legal */ if ((xsize || ste->symp->st_size) && (kind == (ELF32_ST_BIND(ste->symp->st_info) == STB_LOCAL) ? DataIsFileStatic : DataIsGlobal)) - FIXME("Duplicate in %s: %s<%08lx-%08x> %s<%s-%08lx>\n", - module->module.ModuleName, - ste->ht_elt.name, addr, ste->symp->st_size, - module->addr_sorttab[idx]->hash_elt.name, - wine_dbgstr_longlong(xaddr), xsize); + FIXME("Duplicate in %s: %s<%08x-%08x> %s<%s-%s>\n", + debugstr_w(module->module.ModuleName), + ste->ht_elt.name, addr, (unsigned int)ste->symp->st_size, + symt->hash_elt.name, + wine_dbgstr_longlong(xaddr), wine_dbgstr_longlong(xsize)); } } } @@ -437,8 +718,6 @@ static int elf_new_wine_thunks(struct module* module, struct hash_table* ht_symt */ static int elf_new_public_symbols(struct module* module, struct hash_table* symtab) { - struct symt_compiland* compiland = NULL; - const char* compiland_name = NULL; struct hash_table_iter hti; struct symtab_elt* ste; @@ -449,19 +728,9 @@ static int elf_new_public_symbols(struct module* module, struct hash_table* symt hash_table_iter_init(symtab, &hti, NULL); while ((ste = hash_table_iter_up(&hti))) { - /* FIXME: this is not a good idea anyway... we are creating several - * compiland objects for a same compilation unit - * We try to cache the last compiland used, but it's not enough - * (we should here only create compilands if they are not yet - * defined) - */ - if (!compiland_name || compiland_name != ste->filename) - compiland = symt_new_compiland(module, - compiland_name = ste->filename); - - symt_new_public(module, compiland, ste->ht_elt.name, + symt_new_public(module, ste->compiland, ste->ht_elt.name, module->elf_info->elf_addr + ste->symp->st_value, - ste->symp->st_size, TRUE /* FIXME */, + ste->symp->st_size, TRUE /* FIXME */, ELF32_ST_TYPE(ste->symp->st_info) == STT_FUNC); } return TRUE; @@ -527,7 +796,7 @@ static int elf_new_public_symbols(struct module* module, struct hash_table* symt /* using byte-swap instructions. */ -static DWORD calc_crc32(const unsigned char *buf, size_t len) +static DWORD calc_crc32(struct elf_file_map* fmap) { #define UPDC32(octet,crc) (crc_32_tab[((crc) ^ (octet)) & 0xff] ^ ((crc) >> 8)) static const DWORD crc_32_tab[] = @@ -576,177 +845,271 @@ static DWORD calc_crc32(const unsigned char *buf, size_t len) 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d }; - size_t i; - DWORD crc = ~0; - for(i = 0; i < len; i++) - crc = UPDC32(buf[i], crc); + int i, r; + unsigned char buffer[256]; + DWORD crc = ~0; + + lseek(fmap->fd, 0, SEEK_SET); + while ((r = read(fmap->fd, buffer, sizeof(buffer))) > 0) + { + for (i = 0; i < r; i++) crc = UPDC32(buffer[i], crc); + } return ~crc; #undef UPDC32 } +static BOOL elf_check_debug_link(const WCHAR* file, struct elf_file_map* fmap, DWORD crc) +{ + BOOL ret; + if (!elf_map_file(file, fmap)) return FALSE; + if (!(ret = crc == calc_crc32(fmap))) + { + WARN("Bad CRC for file %s (got %08x while expecting %08x)\n", + debugstr_w(file), calc_crc32(fmap), crc); + elf_unmap_file(fmap); + } + return ret; +} /****************************************************************** - * elf_load_debug_info_from_file + * elf_locate_debug_link * - * Loads the symbolic information from ELF module stored in 'file' + * Locate a filename from a .gnu_debuglink section, using the same + * strategy as gdb: + * "If the full name of the directory containing the executable is + * execdir, and the executable has a debug link that specifies the + * name debugfile, then GDB will automatically search for the + * debugging information file in three places: + * - the directory containing the executable file (that is, it + * will look for a file named `execdir/debugfile', + * - a subdirectory of that directory named `.debug' (that is, the + * file `execdir/.debug/debugfile', and + * - a subdirectory of the global debug file directory that includes + * the executable's full path, and the name from the link (that is, + * the file `globaldebugdir/execdir/debugfile', where globaldebugdir + * is the global debug file directory, and execdir has been turned + * into a relative path)." (from GDB manual) + */ +static BOOL elf_locate_debug_link(struct elf_file_map* fmap, const char* filename, + const WCHAR* loaded_file, DWORD crc) +{ + static const WCHAR globalDebugDirW[] = {'/','u','s','r','/','l','i','b','/','d','e','b','u','g','/'}; + static const WCHAR dotDebugW[] = {'.','d','e','b','u','g','/'}; + const size_t globalDebugDirLen = sizeof(globalDebugDirW) / sizeof(WCHAR); + size_t filename_len; + WCHAR* p = NULL; + WCHAR* slash; + struct elf_file_map* fmap_link = NULL; + + fmap_link = HeapAlloc(GetProcessHeap(), 0, sizeof(*fmap_link)); + if (!fmap_link) return FALSE; + + filename_len = MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, NULL, 0); + p = HeapAlloc(GetProcessHeap(), 0, + (globalDebugDirLen + strlenW(loaded_file) + 6 + 1 + filename_len + 1) * sizeof(WCHAR)); + if (!p) goto found; + + /* we prebuild the string with "execdir" */ + strcpyW(p, loaded_file); + slash = strrchrW(p, '/'); + if (slash == NULL) slash = p; else slash++; + + /* testing execdir/filename */ + MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len); + if (elf_check_debug_link(p, fmap_link, crc)) goto found; + + /* testing execdir/.debug/filename */ + memcpy(slash, dotDebugW, sizeof(dotDebugW)); + MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash + sizeof(dotDebugW) / sizeof(WCHAR), filename_len); + if (elf_check_debug_link(p, fmap_link, crc)) goto found; + + /* testing globaldebugdir/execdir/filename */ + memmove(p + globalDebugDirLen, p, (slash - p) * sizeof(WCHAR)); + memcpy(p, globalDebugDirW, globalDebugDirLen * sizeof(WCHAR)); + slash += globalDebugDirLen; + MultiByteToWideChar(CP_UNIXCP, 0, filename, -1, slash, filename_len); + if (elf_check_debug_link(p, fmap_link, crc)) goto found; + + /* finally testing filename */ + if (elf_check_debug_link(slash, fmap_link, crc)) goto found; + + + WARN("Couldn't locate or map %s\n", filename); + HeapFree(GetProcessHeap(), 0, p); + HeapFree(GetProcessHeap(), 0, fmap_link); + return FALSE; + +found: + TRACE("Located debug information file %s at %s\n", filename, debugstr_w(p)); + HeapFree(GetProcessHeap(), 0, p); + fmap->alternate = fmap_link; + return TRUE; +} + +/****************************************************************** + * elf_debuglink_parse + * + * Parses a .gnu_debuglink section and loads the debug info from + * the external file specified there. + */ +static BOOL elf_debuglink_parse(struct elf_file_map* fmap, struct module* module, + const BYTE* debuglink) +{ + /* The content of a debug link section is: + * 1/ a NULL terminated string, containing the file name for the + * debug info + * 2/ padding on 4 byte boundary + * 3/ CRC of the linked ELF file + */ + const char* dbg_link = (const char*)debuglink; + DWORD crc; + + crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3)); + return elf_locate_debug_link(fmap, dbg_link, module->module.LoadedImageName, crc); +} + +/****************************************************************** + * elf_load_debug_info_from_map + * + * Loads the symbolic information from ELF module which mapping is described + * in fmap * the module has been loaded at 'load_offset' address, so symbols' address - * relocation is performed. crc optionally points to the CRC of the debug file - * to load. + * relocation is performed. + * CRC is checked if fmap->with_crc is TRUE * returns * 0 if the file doesn't contain symbolic info (or this info cannot be * read or parsed) * 1 on success */ -static BOOL elf_load_debug_info_from_file( - struct module* module, const char* file, struct pool* pool, - struct hash_table* ht_symtab, const DWORD *crc) +static BOOL elf_load_debug_info_from_map(struct module* module, + struct elf_file_map* fmap, + struct pool* pool, + struct hash_table* ht_symtab) { - BOOL ret = FALSE; - char* addr = (char*)0xffffffff; - int fd = -1; - struct stat statbuf; - const Elf32_Ehdr* ehptr; - const Elf32_Shdr* spnt; - const char* shstrtab; - int i; - int symtab_sect, dynsym_sect, stab_sect, stabstr_sect, debug_sect, debuglink_sect; - struct thunk_area thunks[] = + BOOL ret = FALSE, lret; + struct elf_thunk_area thunks[] = { {"__wine_spec_import_thunks", THUNK_ORDINAL_NOTYPE, 0, 0}, /* inter DLL calls */ {"__wine_spec_delayed_import_loaders", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */ {"__wine_spec_delayed_import_thunks", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */ {"__wine_delay_load", THUNK_ORDINAL_LOAD, 0, 0}, /* delayed inter DLL calls */ {"__wine_spec_thunk_text_16", -16, 0, 0}, /* 16 => 32 thunks */ - {"__wine_spec_thunk_data_16", -16, 0, 0}, /* 16 => 32 thunks */ {"__wine_spec_thunk_text_32", -32, 0, 0}, /* 32 => 16 thunks */ - {"__wine_spec_thunk_data_32", -32, 0, 0}, /* 32 => 16 thunks */ + {NULL, 0, 0, 0} }; - if (module->type != DMT_ELF || !module->elf_info) - { - ERR("Bad elf module '%s'\n", module->module.LoadedImageName); - return FALSE; - } - - TRACE("%s\n", file); - /* check that the file exists, and that the module hasn't been loaded yet */ - if (stat(file, &statbuf) == -1) goto leave; - if (S_ISDIR(statbuf.st_mode)) goto leave; - - /* - * Now open the file, so that we can mmap() it. - */ - if ((fd = open(file, O_RDONLY)) == -1) goto leave; - - /* - * Now mmap() the file. - */ - addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); - if (addr == (char*)0xffffffff) goto leave; - - if (crc && (*crc != calc_crc32(addr, statbuf.st_size))) - { - ERR("Bad CRC for file %s\n", file); - /* we don't tolerate mis-matched files */ - goto leave; - } - - /* - * Next, we need to find a few of the internal ELF headers within - * this thing. We need the main executable header, and the section - * table. - */ - ehptr = (Elf32_Ehdr*)addr; - spnt = (Elf32_Shdr*)(addr + ehptr->e_shoff); - shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset); - - symtab_sect = dynsym_sect = stab_sect = stabstr_sect = debug_sect = debuglink_sect = -1; - - for (i = 0; i < ehptr->e_shnum; i++) - { - if (strcmp(shstrtab + spnt[i].sh_name, ".stab") == 0) - stab_sect = i; - if (strcmp(shstrtab + spnt[i].sh_name, ".stabstr") == 0) - stabstr_sect = i; - if (strcmp(shstrtab + spnt[i].sh_name, ".debug_info") == 0) - debug_sect = i; - if (strcmp(shstrtab + spnt[i].sh_name, ".gnu_debuglink") == 0) - debuglink_sect = i; - if ((strcmp(shstrtab + spnt[i].sh_name, ".symtab") == 0) && - (spnt[i].sh_type == SHT_SYMTAB)) - symtab_sect = i; - if ((strcmp(shstrtab + spnt[i].sh_name, ".dynsym") == 0) && - (spnt[i].sh_type == SHT_DYNSYM)) - dynsym_sect = i; - } - - if (symtab_sect == -1) - { - /* if we don't have a symtab but a dynsym, process the dynsym - * section instead. It'll contain less (relevant) information, - * but it'll be better than nothing - */ - if (dynsym_sect == -1) goto leave; - symtab_sect = dynsym_sect; - } - module->module.SymType = SymExport; /* create a hash table for the symtab */ - elf_hash_symtab(module, pool, ht_symtab, addr, - spnt + symtab_sect, spnt + spnt[symtab_sect].sh_link, - sizeof(thunks) / sizeof(thunks[0]), thunks); + elf_hash_symtab(module, pool, ht_symtab, fmap, thunks); if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY)) { - if (stab_sect != -1 && stabstr_sect != -1) + struct elf_section_map stab_sect, stabstr_sect; + struct elf_section_map debug_sect, debug_str_sect, debug_abbrev_sect, + debug_line_sect, debug_loclist_sect; + struct elf_section_map debuglink_sect; + + /* if present, add the .gnu_debuglink file as an alternate to current one */ + if (elf_find_section(fmap, ".gnu_debuglink", SHT_NULL, &debuglink_sect)) { - /* OK, now just parse all of the stabs. */ - ret = stabs_parse(module, module->elf_info->elf_addr, - addr + spnt[stab_sect].sh_offset, - spnt[stab_sect].sh_size, - addr + spnt[stabstr_sect].sh_offset, - spnt[stabstr_sect].sh_size); - if (!ret) + const BYTE* dbg_link; + + dbg_link = (const BYTE*)elf_map_section(&debuglink_sect); + if (dbg_link != ELF_NO_MAP) { - WARN("Couldn't read correctly read stabs\n"); - goto leave; + lret = elf_debuglink_parse(fmap, module, dbg_link); + if (!lret) + WARN("Couldn't load linked debug file for %s\n", + debugstr_w(module->module.ModuleName)); + ret = ret || lret; } - /* and fill in the missing information for stabs */ - elf_finish_stabs_info(module, ht_symtab); + elf_unmap_section(&debuglink_sect); } - else if (debug_sect != -1) + if (elf_find_section(fmap, ".stab", SHT_NULL, &stab_sect) && + elf_find_section(fmap, ".stabstr", SHT_NULL, &stabstr_sect)) + { + const char* stab; + const char* stabstr; + + stab = elf_map_section(&stab_sect); + stabstr = elf_map_section(&stabstr_sect); + if (stab != ELF_NO_MAP && stabstr != ELF_NO_MAP) + { + /* OK, now just parse all of the stabs. */ + lret = stabs_parse(module, module->elf_info->elf_addr, + stab, elf_get_map_size(&stab_sect), + stabstr, elf_get_map_size(&stabstr_sect)); + if (lret) + /* and fill in the missing information for stabs */ + elf_finish_stabs_info(module, ht_symtab); + else + WARN("Couldn't correctly read stabs\n"); + ret = ret || lret; + } + else lret = FALSE; + elf_unmap_section(&stab_sect); + elf_unmap_section(&stabstr_sect); + } + if (elf_find_section(fmap, ".debug_info", SHT_NULL, &debug_sect)) { /* Dwarf 2 debug information */ - FIXME("Unsupported Dwarf2 information for %s\n", module->module.ModuleName); - } - else if (debuglink_sect != -1) - { - DWORD crc; - const char * file = (const char *)(addr + spnt[debuglink_sect].sh_offset); - /* crc is stored after the null terminated file string rounded - * up to the next 4 byte boundary */ - crc = *(const DWORD *)(file + ((DWORD_PTR)(strlen(file) + 4) & ~3)); - ret = elf_load_debug_info_from_file(module, file, pool, ht_symtab, &crc); - if (!ret) - WARN("Couldn't load linked debug file %s\n", file); + const BYTE* dw2_debug; + const BYTE* dw2_debug_abbrev; + const BYTE* dw2_debug_str; + const BYTE* dw2_debug_line; + const BYTE* dw2_debug_loclist; + + /* debug info might have a different base address than .so file + * when elf file is prelinked after splitting off debug info + * adjust symbol base addresses accordingly + */ + unsigned long load_offset = module->elf_info->elf_addr + + fmap->elf_start - debug_sect.fmap->elf_start; + + TRACE("Loading Dwarf2 information for %s\n", debugstr_w(module->module.ModuleName)); + + elf_find_section(fmap, ".debug_str", SHT_NULL, &debug_str_sect); + elf_find_section(fmap, ".debug_abbrev", SHT_NULL, &debug_abbrev_sect); + elf_find_section(fmap, ".debug_line", SHT_NULL, &debug_line_sect); + elf_find_section(fmap, ".debug_loc", SHT_NULL, &debug_loclist_sect); + + dw2_debug = (const BYTE*)elf_map_section(&debug_sect); + dw2_debug_abbrev = (const BYTE*)elf_map_section(&debug_abbrev_sect); + dw2_debug_str = (const BYTE*)elf_map_section(&debug_str_sect); + dw2_debug_line = (const BYTE*)elf_map_section(&debug_line_sect); + dw2_debug_loclist = (const BYTE*)elf_map_section(&debug_loclist_sect); + if (dw2_debug != ELF_NO_MAP && dw2_debug_abbrev != ELF_NO_MAP && dw2_debug_str != ELF_NO_MAP) + { + /* OK, now just parse dwarf2 debug infos. */ + lret = dwarf2_parse(module, load_offset, thunks, + dw2_debug, elf_get_map_size(&debug_sect), + dw2_debug_abbrev, elf_get_map_size(&debug_abbrev_sect), + dw2_debug_str, elf_get_map_size(&debug_str_sect), + dw2_debug_line, elf_get_map_size(&debug_line_sect), + dw2_debug_loclist, elf_get_map_size(&debug_loclist_sect)); + + if (!lret) + WARN("Couldn't correctly read dwarf2\n"); + ret = ret || lret; + } + elf_unmap_section(&debug_sect); + elf_unmap_section(&debug_abbrev_sect); + elf_unmap_section(&debug_str_sect); + elf_unmap_section(&debug_line_sect); + elf_unmap_section(&debug_loclist_sect); } } - if (strstr(module->module.ModuleName, "") || - !strcmp(module->module.ModuleName, "")) + if (strstrW(module->module.ModuleName, S_ElfW) || + !strcmpW(module->module.ModuleName, S_WineLoaderW)) { /* add the thunks for native libraries */ if (!(dbghelp_options & SYMOPT_PUBLICS_ONLY)) - elf_new_wine_thunks(module, ht_symtab, - sizeof(thunks) / sizeof(thunks[0]), thunks); + elf_new_wine_thunks(module, ht_symtab, thunks); } /* add all the public symbols from symtab */ if (elf_new_public_symbols(module, ht_symtab) && !ret) ret = TRUE; -leave: - if (addr != (char*)0xffffffff) munmap(addr, statbuf.st_size); - if (fd != -1) close(fd); - return ret; } @@ -755,44 +1118,51 @@ leave: * * Loads ELF debugging information from the module image file. */ -BOOL elf_load_debug_info(struct module* module) +BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap) { - BOOL ret; - struct pool pool; - struct hash_table ht_symtab; + BOOL ret = TRUE; + struct pool pool; + struct hash_table ht_symtab; + struct elf_file_map my_fmap; + + if (module->type != DMT_ELF || !module->elf_info) + { + ERR("Bad elf module '%s'\n", debugstr_w(module->module.LoadedImageName)); + return FALSE; + } pool_init(&pool, 65536); hash_table_init(&pool, &ht_symtab, 256); - ret = elf_load_debug_info_from_file(module, - module->module.LoadedImageName, &pool, &ht_symtab, NULL); + if (!fmap) + { + fmap = &my_fmap; + ret = elf_map_file(module->module.LoadedImageName, fmap); + } + if (ret) + ret = elf_load_debug_info_from_map(module, fmap, &pool, &ht_symtab); pool_destroy(&pool); - + if (fmap == &my_fmap) elf_unmap_file(fmap); return ret; } - /****************************************************************** - * is_dt_flag_valid - * returns true iff the section tag is valid + * elf_fetch_file_info + * + * Gathers some more information for an ELF module from a given file */ -static unsigned is_dt_flag_valid(unsigned d_tag) +BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base, + DWORD* size, DWORD* checksum) { -#ifndef DT_PROCNUM -#define DT_PROCNUM 0 -#endif -#ifndef DT_EXTRANUM -#define DT_EXTRANUM 0 -#endif - return (d_tag >= 0 && d_tag < DT_NUM + DT_PROCNUM + DT_EXTRANUM) -#if defined(DT_LOOS) && defined(DT_HIOS) - || (d_tag >= DT_LOOS && d_tag < DT_HIOS) -#endif -#if defined(DT_LOPROC) && defined(DT_HIPROC) - || (d_tag >= DT_LOPROC && d_tag < DT_HIPROC) -#endif - ; + struct elf_file_map fmap; + + if (!elf_map_file(name, &fmap)) return FALSE; + if (base) *base = fmap.elf_start; + *size = fmap.elf_size; + *checksum = calc_crc32(&fmap); + elf_unmap_file(&fmap); + return TRUE; } /****************************************************************** @@ -806,94 +1176,55 @@ static unsigned is_dt_flag_valid(unsigned d_tag) * read or parsed) * 1 on success */ -static BOOL elf_load_file(struct process* pcs, const char* filename, +static BOOL elf_load_file(struct process* pcs, const WCHAR* filename, unsigned long load_offset, struct elf_info* elf_info) { - static const BYTE elf_signature[4] = { ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3 }; BOOL ret = FALSE; - const char* addr = (char*)0xffffffff; - int fd = -1; - struct stat statbuf; - const Elf32_Ehdr* ehptr; - const Elf32_Shdr* spnt; - const Elf32_Phdr* ppnt; - const char* shstrtab; - int i; - DWORD size, start; - unsigned tmp, page_mask = getpagesize() - 1; + struct elf_file_map fmap; - TRACE("Processing elf file '%s' at %08lx\n", filename, load_offset); + TRACE("Processing elf file '%s' at %08lx\n", debugstr_w(filename), load_offset); - /* check that the file exists, and that the module hasn't been loaded yet */ - if (stat(filename, &statbuf) == -1) goto leave; - - /* Now open the file, so that we can mmap() it. */ - if ((fd = open(filename, O_RDONLY)) == -1) goto leave; - - /* Now mmap() the file. */ - addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); - if (addr == (char*)-1) goto leave; + if (!elf_map_file(filename, &fmap)) goto leave; /* Next, we need to find a few of the internal ELF headers within * this thing. We need the main executable header, and the section * table. */ - ehptr = (const Elf32_Ehdr*)addr; - if (memcmp(ehptr->e_ident, elf_signature, sizeof(elf_signature))) goto leave; - - spnt = (const Elf32_Shdr*)(addr + ehptr->e_shoff); - shstrtab = (addr + spnt[ehptr->e_shstrndx].sh_offset); - - /* grab size of module once loaded in memory */ - ppnt = (const Elf32_Phdr*)(addr + ehptr->e_phoff); - size = 0; start = ~0L; - - for (i = 0; i < ehptr->e_phnum; i++) - { - if (ppnt[i].p_type == PT_LOAD) - { - tmp = (ppnt[i].p_vaddr + ppnt[i].p_memsz + page_mask) & ~page_mask; - if (size < tmp) size = tmp; - if (ppnt[i].p_vaddr < start) start = ppnt[i].p_vaddr; - } - } - - /* if non relocatable ELF, then remove fixed address from computation - * otherwise, all addresses are zero based and start has no effect - */ - size -= start; - if (!start && !load_offset) + if (!fmap.elf_start && !load_offset) ERR("Relocatable ELF %s, but no load address. Loading at 0x0000000\n", - filename); - if (start && load_offset) + debugstr_w(filename)); + if (fmap.elf_start && load_offset) { WARN("Non-relocatable ELF %s, but load address of 0x%08lx supplied. " - "Assuming load address is corrupt\n", filename, load_offset); + "Assuming load address is corrupt\n", debugstr_w(filename), load_offset); load_offset = 0; } if (elf_info->flags & ELF_INFO_DEBUG_HEADER) { - for (i = 0; i < ehptr->e_shnum; i++) - { - if (strcmp(shstrtab + spnt[i].sh_name, ".dynamic") == 0 && - spnt[i].sh_type == SHT_DYNAMIC) - { - Elf32_Dyn dyn; - char* ptr = (char*)spnt[i].sh_addr; - unsigned long len; + struct elf_section_map esm; - do + if (elf_find_section(&fmap, ".dynamic", SHT_DYNAMIC, &esm)) + { + Elf32_Dyn dyn; + char* ptr = (char*)fmap.sect[esm.sidx].shdr.sh_addr; + unsigned long len; + + do + { + if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) || + len != sizeof(dyn)) + goto leave; + if (dyn.d_tag == DT_DEBUG) { - if (!ReadProcessMemory(pcs->handle, ptr, &dyn, sizeof(dyn), &len) || - len != sizeof(dyn) || !is_dt_flag_valid(dyn.d_tag)) - dyn.d_tag = DT_NULL; - ptr += sizeof(dyn); - } while (dyn.d_tag != DT_DEBUG && dyn.d_tag != DT_NULL); - if (dyn.d_tag == DT_NULL) goto leave; - elf_info->dbg_hdr_addr = dyn.d_un.d_ptr; - } + elf_info->dbg_hdr_addr = dyn.d_un.d_ptr; + break; + } + ptr += sizeof(dyn); + } while (dyn.d_tag != DT_NULL); + if (dyn.d_tag == DT_NULL) goto leave; } + elf_end_find(&fmap); } if (elf_info->flags & ELF_INFO_MODULE) @@ -901,9 +1232,9 @@ static BOOL elf_load_file(struct process* pcs, const char* filename, struct elf_module_info *elf_module_info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct elf_module_info)); if (!elf_module_info) goto leave; - elf_info->module = module_new(pcs, filename, DMT_ELF, - (load_offset) ? load_offset : start, - size, 0, 0); + elf_info->module = module_new(pcs, filename, DMT_ELF, FALSE, + (load_offset) ? load_offset : fmap.elf_start, + fmap.elf_size, 0, calc_crc32(&fmap)); if (!elf_info->module) { HeapFree(GetProcessHeap(), 0, elf_module_info); @@ -917,15 +1248,25 @@ static BOOL elf_load_file(struct process* pcs, const char* filename, elf_info->module->module.SymType = SymDeferred; ret = TRUE; } - else ret = elf_load_debug_info(elf_info->module); + else ret = elf_load_debug_info(elf_info->module, &fmap); elf_info->module->elf_info->elf_mark = 1; elf_info->module->elf_info->elf_loader = 0; } else ret = TRUE; + if (elf_info->flags & ELF_INFO_NAME) + { + WCHAR* ptr; + ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR)); + if (ptr) + { + strcpyW(ptr, filename); + elf_info->module_name = ptr; + } + else ret = FALSE; + } leave: - if (addr != (char*)0xffffffff) munmap((void*)addr, statbuf.st_size); - if (fd != -1) close(fd); + elf_unmap_file(&fmap); return ret; } @@ -935,34 +1276,73 @@ leave: * tries to load an ELF file from a set of paths (separated by ':') */ static BOOL elf_load_file_from_path(HANDLE hProcess, - const char* filename, + const WCHAR* filename, unsigned long load_offset, const char* path, struct elf_info* elf_info) { BOOL ret = FALSE; - char *s, *t, *fn; - char* paths = NULL; + WCHAR *s, *t, *fn; + WCHAR* pathW = NULL; + unsigned len; if (!path) return FALSE; - paths = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(path) + 1), path); - for (s = paths; s && *s; s = (t) ? (t+1) : NULL) + len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0); + pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); + if (!pathW) return FALSE; + MultiByteToWideChar(CP_UNIXCP, 0, path, -1, pathW, len); + + for (s = pathW; s && *s; s = (t) ? (t+1) : NULL) { - t = strchr(s, ':'); + t = strchrW(s, ':'); if (t) *t = '\0'; - fn = HeapAlloc(GetProcessHeap(), 0, strlen(filename) + 1 + strlen(s) + 1); + fn = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1 + lstrlenW(s) + 1) * sizeof(WCHAR)); if (!fn) break; - strcpy(fn, s); - strcat(fn, "/"); - strcat(fn, filename); + strcpyW(fn, s); + strcatW(fn, S_SlashW); + strcatW(fn, filename); ret = elf_load_file(hProcess, fn, load_offset, elf_info); HeapFree(GetProcessHeap(), 0, fn); if (ret) break; s = (t) ? (t+1) : NULL; } - HeapFree(GetProcessHeap(), 0, paths); + HeapFree(GetProcessHeap(), 0, pathW); + return ret; +} + +/****************************************************************** + * elf_load_file_from_dll_path + * + * Tries to load an ELF file from the dll path + */ +static BOOL elf_load_file_from_dll_path(HANDLE hProcess, + const WCHAR* filename, + unsigned long load_offset, + struct elf_info* elf_info) +{ + BOOL ret = FALSE; + unsigned int index = 0; + const char *path; + + while (!ret && (path = wine_dll_enum_load_path( index++ ))) + { + WCHAR *name; + unsigned len; + + len = MultiByteToWideChar(CP_UNIXCP, 0, path, -1, NULL, 0); + + name = HeapAlloc( GetProcessHeap(), 0, + (len + lstrlenW(filename) + 2) * sizeof(WCHAR) ); + + if (!name) break; + MultiByteToWideChar(CP_UNIXCP, 0, path, -1, name, len); + strcatW( name, S_SlashW ); + strcatW( name, filename ); + ret = elf_load_file(hProcess, name, load_offset, elf_info); + HeapFree( GetProcessHeap(), 0, name ); + } return ret; } @@ -971,65 +1351,57 @@ static BOOL elf_load_file_from_path(HANDLE hProcess, * * lookup a file in standard ELF locations, and if found, load it */ -static BOOL elf_search_and_load_file(struct process* pcs, const char* filename, +static BOOL elf_search_and_load_file(struct process* pcs, const WCHAR* filename, unsigned long load_offset, struct elf_info* elf_info) { BOOL ret = FALSE; struct module* module; + static WCHAR S_libstdcPPW[] = {'l','i','b','s','t','d','c','+','+','\0'}; if (filename == NULL || *filename == '\0') return FALSE; - if ((module = module_find_by_name(pcs, filename, DMT_ELF))) + if ((module = module_is_already_loaded(pcs, filename))) { elf_info->module = module; module->elf_info->elf_mark = 1; return module->module.SymType; } - if (strstr(filename, "libstdc++")) return FALSE; /* We know we can't do it */ + if (strstrW(filename, S_libstdcPPW)) return FALSE; /* We know we can't do it */ ret = elf_load_file(pcs, filename, load_offset, elf_info); /* if relative pathname, try some absolute base dirs */ - if (!ret && !strchr(filename, '/')) + if (!ret && !strchrW(filename, '/')) { ret = elf_load_file_from_path(pcs, filename, load_offset, getenv("PATH"), elf_info) || elf_load_file_from_path(pcs, filename, load_offset, - getenv("LD_LIBRARY_PATH"), elf_info) || - elf_load_file_from_path(pcs, filename, load_offset, - getenv("WINEDLLPATH"), elf_info); + getenv("LD_LIBRARY_PATH"), elf_info); + if (!ret) ret = elf_load_file_from_dll_path(pcs, filename, load_offset, elf_info); } - + return ret; } /****************************************************************** - * elf_synchronize_module_list + * elf_enum_modules_internal * - * this functions rescans the debuggee module's list and synchronizes it with - * the one from 'pcs', ie: - * - if a module is in debuggee and not in pcs, it's loaded into pcs - * - if a module is in pcs and not in debuggee, it's unloaded from pcs + * Enumerate ELF modules from a running process */ -BOOL elf_synchronize_module_list(struct process* pcs) +static BOOL elf_enum_modules_internal(const struct process* pcs, + const WCHAR* main_name, + elf_enum_modules_cb cb, void* user) { struct r_debug dbg_hdr; void* lm_addr; struct link_map lm; char bufstr[256]; - struct elf_info elf_info; - struct module* module; + WCHAR bufstrW[MAX_PATH]; if (!pcs->dbg_hdr_addr || !ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr), NULL)) return FALSE; - for (module = pcs->lmodules; module; module = module->next) - { - if (module->type == DMT_ELF) module->elf_info->elf_mark = 0; - } - - elf_info.flags = ELF_INFO_MODULE; /* Now walk the linked list. In all known ELF implementations, * the dynamic loader maintains this linked list for us. In some * cases the first entry doesn't appear with a name, in other cases it @@ -1045,24 +1417,99 @@ BOOL elf_synchronize_module_list(struct process* pcs) ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL)) { bufstr[sizeof(bufstr) - 1] = '\0'; - elf_search_and_load_file(pcs, bufstr, (unsigned long)lm.l_addr, - &elf_info); + MultiByteToWideChar(CP_UNIXCP, 0, bufstr, -1, bufstrW, sizeof(bufstrW) / sizeof(WCHAR)); + if (main_name && !bufstrW[0]) strcpyW(bufstrW, main_name); + if (!cb(bufstrW, (unsigned long)lm.l_addr, user)) break; } } + return TRUE; +} + +struct elf_sync +{ + struct process* pcs; + struct elf_info elf_info; +}; + +static BOOL elf_enum_sync_cb(const WCHAR* name, unsigned long addr, void* user) +{ + struct elf_sync* es = user; + + elf_search_and_load_file(es->pcs, name, addr, &es->elf_info); + return TRUE; +} + +/****************************************************************** + * elf_synchronize_module_list + * + * this functions rescans the debuggee module's list and synchronizes it with + * the one from 'pcs', ie: + * - if a module is in debuggee and not in pcs, it's loaded into pcs + * - if a module is in pcs and not in debuggee, it's unloaded from pcs + */ +BOOL elf_synchronize_module_list(struct process* pcs) +{ + struct module* module; + struct elf_sync es; for (module = pcs->lmodules; module; module = module->next) { - if (module->type == DMT_ELF && !module->elf_info->elf_mark && - !module->elf_info->elf_loader) + if (module->type == DMT_ELF && !module->is_virtual) + module->elf_info->elf_mark = 0; + } + + es.pcs = pcs; + es.elf_info.flags = ELF_INFO_MODULE; + if (!elf_enum_modules_internal(pcs, NULL, elf_enum_sync_cb, &es)) + return FALSE; + + module = pcs->lmodules; + while (module) + { + if (module->type == DMT_ELF && !module->is_virtual && + !module->elf_info->elf_mark && !module->elf_info->elf_loader) { module_remove(pcs, module); /* restart all over */ module = pcs->lmodules; } + else module = module->next; } return TRUE; } +/****************************************************************** + * elf_search_loader + * + * Lookup in a running ELF process the loader, and sets its ELF link + * address (for accessing the list of loaded .so libs) in pcs. + * If flags is ELF_INFO_MODULE, the module for the loader is also + * added as a module into pcs. + */ +static BOOL elf_search_loader(struct process* pcs, struct elf_info* elf_info) +{ + BOOL ret; + const char* ptr; + + /* All binaries are loaded with WINELOADER (if run from tree) or by the + * main executable (either wine-kthread or wine-pthread) + * FIXME: the heuristic used to know whether we need to load wine-pthread + * or wine-kthread is not 100% safe + */ + if ((ptr = getenv("WINELOADER"))) + { + WCHAR tmp[MAX_PATH]; + MultiByteToWideChar(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp) / sizeof(WCHAR)); + ret = elf_search_and_load_file(pcs, tmp, 0, elf_info); + } + else + { + ret = elf_search_and_load_file(pcs, S_WineKThreadW, 0, elf_info) || + elf_search_and_load_file(pcs, S_WinePThreadW, 0, elf_info); + } + return ret; +} + /****************************************************************** * elf_read_wine_loader_dbg_info * @@ -1070,27 +1517,68 @@ BOOL elf_synchronize_module_list(struct process* pcs) */ BOOL elf_read_wine_loader_dbg_info(struct process* pcs) { - const char* ptr; + struct elf_info elf_info; + + elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE; + if (!elf_search_loader(pcs, &elf_info)) return FALSE; + elf_info.module->elf_info->elf_loader = 1; + module_set_module(elf_info.module, S_WineLoaderW); + return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0; +} + +/****************************************************************** + * elf_enum_modules + * + * Enumerates the ELF loaded modules from a running target (hProc) + * This function doesn't require that someone has called SymInitialize + * on this very process. + */ +BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user) +{ + struct process pcs; struct elf_info elf_info; BOOL ret; - elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_MODULE; - /* All binaries are loaded with WINELOADER (if run from tree) or by the - * main executable (either wine-kthread or wine-pthread) - * Note: the heuristic use to know whether we need to load wine-pthread or - * wine-kthread is not 100% safe + memset(&pcs, 0, sizeof(pcs)); + pcs.handle = hProc; + elf_info.flags = ELF_INFO_DEBUG_HEADER | ELF_INFO_NAME; + if (!elf_search_loader(&pcs, &elf_info)) return FALSE; + pcs.dbg_hdr_addr = elf_info.dbg_hdr_addr; + ret = elf_enum_modules_internal(&pcs, elf_info.module_name, cb, user); + HeapFree(GetProcessHeap(), 0, (char*)elf_info.module_name); + return ret; +} + +struct elf_load +{ + struct process* pcs; + struct elf_info elf_info; + const WCHAR* name; + BOOL ret; +}; + +/****************************************************************** + * elf_load_cb + * + * Callback for elf_load_module, used to walk the list of loaded + * modules. + */ +static BOOL elf_load_cb(const WCHAR* name, unsigned long addr, void* user) +{ + struct elf_load* el = user; + const WCHAR* p; + + /* memcmp is needed for matches when bufstr contains also version information + * el->name: libc.so, name: libc.so.6.0 */ - if ((ptr = getenv("WINELOADER"))) - ret = elf_search_and_load_file(pcs, ptr, 0, &elf_info); - else + p = strrchrW(name, '/'); + if (!p++) p = name; + if (!memcmp(p, el->name, lstrlenW(el->name) * sizeof(WCHAR))) { - ret = elf_search_and_load_file(pcs, "wine-kthread", 0, &elf_info) || - elf_search_and_load_file(pcs, "wine-pthread", 0, &elf_info); + el->ret = elf_search_and_load_file(el->pcs, name, addr, &el->elf_info); + return FALSE; } - if (!ret) return FALSE; - elf_info.module->elf_info->elf_loader = 1; - strcpy(elf_info.module->module.ModuleName, ""); - return (pcs->dbg_hdr_addr = elf_info.dbg_hdr_addr) != 0; + return TRUE; } /****************************************************************** @@ -1100,56 +1588,36 @@ BOOL elf_read_wine_loader_dbg_info(struct process* pcs) * Also, find module real name and load address from * the real loaded modules list in pcs address space */ -struct module* elf_load_module(struct process* pcs, const char* name) +struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr) { - struct elf_info elf_info; - BOOL ret = FALSE; - const char* p; - const char* xname; - struct r_debug dbg_hdr; - void* lm_addr; - struct link_map lm; - char bufstr[256]; + struct elf_load el; - TRACE("(%p %s)\n", pcs, name); + TRACE("(%p %s %08lx)\n", pcs, debugstr_w(name), addr); - elf_info.flags = ELF_INFO_MODULE; + el.elf_info.flags = ELF_INFO_MODULE; + el.ret = FALSE; - /* do only the lookup from the filename, not the path (as we lookup module name - * in the process' loaded module list) - */ - xname = strrchr(name, '/'); - if (!xname++) xname = name; - - if (!ReadProcessMemory(pcs->handle, (void*)pcs->dbg_hdr_addr, &dbg_hdr, sizeof(dbg_hdr), NULL)) - return NULL; - - for (lm_addr = (void*)dbg_hdr.r_map; lm_addr; lm_addr = (void*)lm.l_next) + if (pcs->dbg_hdr_addr) /* we're debugging a life target */ { - if (!ReadProcessMemory(pcs->handle, lm_addr, &lm, sizeof(lm), NULL)) - return NULL; + el.pcs = pcs; + /* do only the lookup from the filename, not the path (as we lookup module + * name in the process' loaded module list) + */ + el.name = strrchrW(name, '/'); + if (!el.name++) el.name = name; + el.ret = FALSE; - if (lm.l_prev != NULL && /* skip first entry, normally debuggee itself */ - lm.l_name != NULL && - ReadProcessMemory(pcs->handle, lm.l_name, bufstr, sizeof(bufstr), NULL)) - { - bufstr[sizeof(bufstr) - 1] = '\0'; - /* memcmp is needed for matches when bufstr contains also version information - * name: libc.so, bufstr: libc.so.6.0 - */ - p = strrchr(bufstr, '/'); - if (!p++) p = bufstr; - if (!memcmp(p, xname, strlen(xname))) - { - ret = elf_search_and_load_file(pcs, bufstr, - (unsigned long)lm.l_addr, &elf_info); - break; - } - } + if (!elf_enum_modules_internal(pcs, NULL, elf_load_cb, &el)) + return NULL; } - if (!lm_addr || !ret) return NULL; - assert(elf_info.module); - return elf_info.module; + else if (addr) + { + el.name = name; + el.ret = elf_search_and_load_file(pcs, el.name, addr, &el.elf_info); + } + if (!el.ret) return NULL; + assert(el.elf_info.module); + return el.elf_info.module; } #else /* !__ELF__ */ @@ -1159,18 +1627,35 @@ BOOL elf_synchronize_module_list(struct process* pcs) return FALSE; } +BOOL elf_fetch_file_info(const WCHAR* name, DWORD* base, + DWORD* size, DWORD* checksum) +{ + return FALSE; +} + BOOL elf_read_wine_loader_dbg_info(struct process* pcs) { return FALSE; } -struct module* elf_load_module(struct process* pcs, const char* name) +BOOL elf_enum_modules(HANDLE hProc, elf_enum_modules_cb cb, void* user) +{ + return FALSE; +} + +struct module* elf_load_module(struct process* pcs, const WCHAR* name, unsigned long addr) { return NULL; } -BOOL elf_load_debug_info(struct module* module) +BOOL elf_load_debug_info(struct module* module, struct elf_file_map* fmap) { return FALSE; } + +int elf_is_in_thunk_area(unsigned long addr, + const struct elf_thunk_area* thunks) +{ + return -1; +} #endif /* __ELF__ */ diff --git a/reactos/dll/win32/dbghelp/image.c b/reactos/dll/win32/dbghelp/image.c index ff8319a46bd..ef94ef66386 100644 --- a/reactos/dll/win32/dbghelp/image.c +++ b/reactos/dll/win32/dbghelp/image.c @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -24,7 +24,6 @@ #include #include "dbghelp_private.h" -#include "winreg.h" #include "winternl.h" #include "wine/debug.h" @@ -42,10 +41,10 @@ DWORD WINAPI GetTimestampForLoadedLibrary(HMODULE Module) /*********************************************************************** * MapDebugInformation (DBGHELP.@) */ -PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE FileHandle, LPSTR FileName, - LPSTR SymbolPath, DWORD ImageBase) +PIMAGE_DEBUG_INFORMATION WINAPI MapDebugInformation(HANDLE FileHandle, PCSTR FileName, + PCSTR SymbolPath, ULONG ImageBase) { - FIXME("(%p, %s, %s, 0x%08lx): stub\n", FileHandle, FileName, SymbolPath, ImageBase); + FIXME("(%p, %s, %s, 0x%08x): stub\n", FileHandle, FileName, SymbolPath, ImageBase); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return NULL; } diff --git a/reactos/dll/win32/dbghelp/memory.c b/reactos/dll/win32/dbghelp/memory.c index ebf58400458..6f64016dabe 100644 --- a/reactos/dll/win32/dbghelp/memory.c +++ b/reactos/dll/win32/dbghelp/memory.c @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -39,12 +39,12 @@ DWORD WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS* addr) { case AddrMode1616: if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) - return (le.HighWord.Bits.BaseHi << 24) + + return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + LOWORD(addr->Offset); break; case AddrMode1632: if (GetThreadSelectorEntry(hThread, addr->Segment, &le)) - return (le.HighWord.Bits.BaseHi << 24) + + return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + addr->Offset; break; case AddrModeReal: @@ -55,7 +55,7 @@ DWORD WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS* addr) FIXME("Unsupported (yet) mode (%x)\n", addr->Mode); return 0; } - FIXME("Failed to linearize address %04x:%08lx (mode %x)\n", + FIXME("Failed to linearize address %04x:%08x (mode %x)\n", addr->Segment, addr->Offset, addr->Mode); return 0; } diff --git a/reactos/dll/win32/dbghelp/minidump.c b/reactos/dll/win32/dbghelp/minidump.c index be35ce57d40..e8daedad3b2 100644 --- a/reactos/dll/win32/dbghelp/minidump.c +++ b/reactos/dll/win32/dbghelp/minidump.c @@ -1,7 +1,7 @@ /* * File minidump.c - management of dumps (read & write) * - * Copyright (C) 2004, Eric Pouech + * Copyright (C) 2004-2005, Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include @@ -23,75 +23,473 @@ #define NONAMELESSUNION #define NONAMELESSSTRUCT +#include "ntstatus.h" +#define WIN32_NO_STATUS #include "dbghelp_private.h" +#include "winternl.h" +#include "psapi.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); -#if 0 -/* hard to see how we can generate this very easily (how to grab latest exception - * in a process ?) +struct dump_memory +{ + ULONG base; + ULONG size; + ULONG rva; +}; + +struct dump_module +{ + unsigned is_elf; + ULONG base; + ULONG size; + DWORD timestamp; + DWORD checksum; + WCHAR name[MAX_PATH]; +}; + +struct dump_context +{ + /* process & thread information */ + HANDLE hProcess; + DWORD pid; + void* pcs_buffer; + SYSTEM_PROCESS_INFORMATION* spi; + /* module information */ + struct dump_module* module; + unsigned num_module; + /* exception information */ + /* output information */ + MINIDUMP_TYPE type; + HANDLE hFile; + RVA rva; + struct dump_memory* mem; + unsigned num_mem; + /* callback information */ + MINIDUMP_CALLBACK_INFORMATION* cb; +}; + +/****************************************************************** + * fetch_process_info + * + * reads system wide process information, and make spi point to the record + * for process of id 'pid' */ -static void DumpException(struct process* pcs, HANDLE hFile, RVA* rva) +static BOOL fetch_process_info(struct dump_context* dc) +{ + ULONG buf_size = 0x1000; + NTSTATUS nts; + + dc->pcs_buffer = NULL; + if (!(dc->pcs_buffer = HeapAlloc(GetProcessHeap(), 0, buf_size))) return FALSE; + for (;;) + { + nts = NtQuerySystemInformation(SystemProcessInformation, + dc->pcs_buffer, buf_size, NULL); + if (nts != STATUS_INFO_LENGTH_MISMATCH) break; + dc->pcs_buffer = HeapReAlloc(GetProcessHeap(), 0, dc->pcs_buffer, + buf_size *= 2); + if (!dc->pcs_buffer) return FALSE; + } + + if (nts == STATUS_SUCCESS) + { + dc->spi = dc->pcs_buffer; + for (;;) + { + if (dc->spi->dwProcessID == dc->pid) return TRUE; + if (!dc->spi->dwOffset) break; + dc->spi = (SYSTEM_PROCESS_INFORMATION*) + ((char*)dc->spi + dc->spi->dwOffset); + } + } + HeapFree(GetProcessHeap(), 0, dc->pcs_buffer); + dc->pcs_buffer = NULL; + dc->spi = NULL; + return FALSE; +} + +static void fetch_thread_stack(struct dump_context* dc, const void* teb_addr, + const CONTEXT* ctx, MINIDUMP_MEMORY_DESCRIPTOR* mmd) +{ + NT_TIB tib; + + if (ReadProcessMemory(dc->hProcess, teb_addr, &tib, sizeof(tib), NULL)) + { +#ifdef __i386__ + /* limiting the stack dumping to the size actually used */ + if (ctx->Esp) + mmd->StartOfMemoryRange = (ctx->Esp - 4); + else + mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit; +#elif defined(__powerpc__) + if (ctx->Iar) + mmd->StartOfMemoryRange = ctx->Iar - 4; + else + mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit; +#elif defined(__x86_64__) + if (ctx->Rsp) + mmd->StartOfMemoryRange = (ctx->Rsp - 8); + else + mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit; +#else +#error unsupported CPU +#endif + mmd->Memory.DataSize = (ULONG_PTR)tib.StackBase - mmd->StartOfMemoryRange; + } +} + +/****************************************************************** + * fetch_thread_info + * + * fetches some information about thread of id 'tid' + */ +static BOOL fetch_thread_info(struct dump_context* dc, int thd_idx, + const MINIDUMP_EXCEPTION_INFORMATION* except, + MINIDUMP_THREAD* mdThd, CONTEXT* ctx) +{ + DWORD tid = dc->spi->ti[thd_idx].dwThreadID; + HANDLE hThread; + THREAD_BASIC_INFORMATION tbi; + + memset(ctx, 0, sizeof(*ctx)); + + mdThd->ThreadId = dc->spi->ti[thd_idx].dwThreadID; + mdThd->SuspendCount = 0; + mdThd->Teb = 0; + mdThd->Stack.StartOfMemoryRange = 0; + mdThd->Stack.Memory.DataSize = 0; + mdThd->Stack.Memory.Rva = 0; + mdThd->ThreadContext.DataSize = 0; + mdThd->ThreadContext.Rva = 0; + mdThd->PriorityClass = dc->spi->ti[thd_idx].dwBasePriority; /* FIXME */ + mdThd->Priority = dc->spi->ti[thd_idx].dwCurrentPriority; + + if ((hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, tid)) == NULL) + { + FIXME("Couldn't open thread %u (%u)\n", + dc->spi->ti[thd_idx].dwThreadID, GetLastError()); + return FALSE; + } + + if (NtQueryInformationThread(hThread, ThreadBasicInformation, + &tbi, sizeof(tbi), NULL) == STATUS_SUCCESS) + { + mdThd->Teb = (ULONG_PTR)tbi.TebBaseAddress; + if (tbi.ExitStatus == STILL_ACTIVE) + { + if (tid != GetCurrentThreadId() && + (mdThd->SuspendCount = SuspendThread(hThread)) != (DWORD)-1) + { + mdThd->SuspendCount--; + ctx->ContextFlags = CONTEXT_FULL; + if (!GetThreadContext(hThread, ctx)) + memset(ctx, 0, sizeof(*ctx)); + + fetch_thread_stack(dc, tbi.TebBaseAddress, ctx, &mdThd->Stack); + ResumeThread(hThread); + } + else if (tid == GetCurrentThreadId() && except) + { + CONTEXT lctx, *pctx; + if (except->ClientPointers) + { + EXCEPTION_POINTERS ep; + + ReadProcessMemory(dc->hProcess, except->ExceptionPointers, + &ep, sizeof(ep), NULL); + ReadProcessMemory(dc->hProcess, ep.ContextRecord, + &ctx, sizeof(ctx), NULL); + pctx = &lctx; + } + else pctx = except->ExceptionPointers->ContextRecord; + fetch_thread_stack(dc, tbi.TebBaseAddress, pctx, &mdThd->Stack); + } + } + } + CloseHandle(hThread); + return TRUE; +} + +/****************************************************************** + * add_module + * + * Add a module to a dump context + */ +static BOOL add_module(struct dump_context* dc, const WCHAR* name, + DWORD base, DWORD size, DWORD timestamp, DWORD checksum, + BOOL is_elf) +{ + if (!dc->module) + dc->module = HeapAlloc(GetProcessHeap(), 0, + ++dc->num_module * sizeof(*dc->module)); + else + dc->module = HeapReAlloc(GetProcessHeap(), 0, dc->module, + ++dc->num_module * sizeof(*dc->module)); + if (!dc->module) return FALSE; + if (is_elf || + !GetModuleFileNameExW(dc->hProcess, (HMODULE)base, + dc->module[dc->num_module - 1].name, + sizeof(dc->module[dc->num_module - 1].name) / sizeof(WCHAR))) + lstrcpynW(dc->module[dc->num_module - 1].name, name, + sizeof(dc->module[dc->num_module - 1].name) / sizeof(WCHAR)); + dc->module[dc->num_module - 1].base = base; + dc->module[dc->num_module - 1].size = size; + dc->module[dc->num_module - 1].timestamp = timestamp; + dc->module[dc->num_module - 1].checksum = checksum; + dc->module[dc->num_module - 1].is_elf = is_elf; + + return TRUE; +} + +/****************************************************************** + * fetch_pe_module_info_cb + * + * Callback for accumulating in dump_context a PE modules set + */ +static BOOL WINAPI fetch_pe_module_info_cb(PCWSTR name, DWORD64 base, ULONG size, + PVOID user) +{ + struct dump_context* dc = (struct dump_context*)user; + IMAGE_NT_HEADERS nth; + + if (!validate_addr64(base)) return FALSE; + + if (pe_load_nt_header(dc->hProcess, base, &nth)) + add_module((struct dump_context*)user, name, base, size, + nth.FileHeader.TimeDateStamp, nth.OptionalHeader.CheckSum, + FALSE); + return TRUE; +} + +/****************************************************************** + * fetch_elf_module_info_cb + * + * Callback for accumulating in dump_context an ELF modules set + */ +static BOOL fetch_elf_module_info_cb(const WCHAR* name, unsigned long base, + void* user) +{ + struct dump_context* dc = (struct dump_context*)user; + DWORD rbase, size, checksum; + + /* FIXME: there's no relevant timestamp on ELF modules */ + /* NB: if we have a non-null base from the live-target use it (whenever + * the ELF module is relocatable or not). If we have a null base (ELF + * module isn't relocatable) then grab its base address from ELF file + */ + if (!elf_fetch_file_info(name, &rbase, &size, &checksum)) + size = checksum = 0; + add_module(dc, name, base ? base : rbase, size, 0 /* FIXME */, checksum, TRUE); + return TRUE; +} + +static void fetch_module_info(struct dump_context* dc) +{ + EnumerateLoadedModulesW64(dc->hProcess, fetch_pe_module_info_cb, dc); + /* Since we include ELF modules in a separate stream from the regular PE ones, + * we can always include those ELF modules (they don't eat lots of space) + * And it's always a good idea to have a trace of the loaded ELF modules for + * a given application in a post mortem debugging condition. + */ + elf_enum_modules(dc->hProcess, fetch_elf_module_info_cb, dc); +} + +/****************************************************************** + * add_memory_block + * + * Add a memory block to be dumped in a minidump + * If rva is non 0, it's the rva in the minidump where has to be stored + * also the rva of the memory block when written (this allows to reference + * a memory block from outside the list of memory blocks). + */ +static void add_memory_block(struct dump_context* dc, ULONG64 base, ULONG size, ULONG rva) +{ + if (dc->mem) + dc->mem = HeapReAlloc(GetProcessHeap(), 0, dc->mem, + ++dc->num_mem * sizeof(*dc->mem)); + else + dc->mem = HeapAlloc(GetProcessHeap(), 0, ++dc->num_mem * sizeof(*dc->mem)); + if (dc->mem) + { + dc->mem[dc->num_mem - 1].base = base; + dc->mem[dc->num_mem - 1].size = size; + dc->mem[dc->num_mem - 1].rva = rva; + } + else dc->num_mem = 0; +} + +/****************************************************************** + * writeat + * + * Writes a chunk of data at a given position in the minidump + */ +static void writeat(struct dump_context* dc, RVA rva, const void* data, unsigned size) +{ + DWORD written; + + SetFilePointer(dc->hFile, rva, NULL, FILE_BEGIN); + WriteFile(dc->hFile, data, size, &written, NULL); +} + +/****************************************************************** + * append + * + * writes a new chunk of data to the minidump, increasing the current + * rva in dc + */ +static void append(struct dump_context* dc, void* data, unsigned size) +{ + writeat(dc, dc->rva, data, size); + dc->rva += size; +} + +/****************************************************************** + * dump_exception_info + * + * Write in File the exception information from pcs + */ +static void dump_exception_info(struct dump_context* dc, + const MINIDUMP_EXCEPTION_INFORMATION* except) { MINIDUMP_EXCEPTION_STREAM mdExcpt; + EXCEPTION_RECORD rec, *prec; + CONTEXT ctx, *pctx; + int i; - mdExcpt.ThreadId = DEBUG_CurrThread->tid; + mdExcpt.ThreadId = except->ThreadId; mdExcpt.__alignment = 0; - mdExcpt.ExceptionRecord. + if (except->ClientPointers) + { + EXCEPTION_POINTERS ep; - ULONG ExceptionCode; - ULONG ExceptionFlags; - ULONGLONG ExceptionRecord; - ULONGLONG ExceptionAddress; - ULONG NumberParameters; - ULONG __unusedAlignment; - ULONGLONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; + ReadProcessMemory(dc->hProcess, + except->ExceptionPointers, &ep, sizeof(ep), NULL); + ReadProcessMemory(dc->hProcess, + ep.ExceptionRecord, &rec, sizeof(rec), NULL); + ReadProcessMemory(dc->hProcess, + ep.ContextRecord, &ctx, sizeof(ctx), NULL); + prec = &rec; + pctx = &ctx; + } + else + { + prec = except->ExceptionPointers->ExceptionRecord; + pctx = except->ExceptionPointers->ContextRecord; + } + mdExcpt.ExceptionRecord.ExceptionCode = prec->ExceptionCode; + mdExcpt.ExceptionRecord.ExceptionFlags = prec->ExceptionFlags; + mdExcpt.ExceptionRecord.ExceptionRecord = (DWORD_PTR)prec->ExceptionRecord; + mdExcpt.ExceptionRecord.ExceptionAddress = (DWORD_PTR)prec->ExceptionAddress; + mdExcpt.ExceptionRecord.NumberParameters = prec->NumberParameters; + mdExcpt.ExceptionRecord.__unusedAlignment = 0; + for (i = 0; i < mdExcpt.ExceptionRecord.NumberParameters; i++) + mdExcpt.ExceptionRecord.ExceptionInformation[i] = (DWORD_PTR)prec->ExceptionInformation[i]; + mdExcpt.ThreadContext.DataSize = sizeof(*pctx); + mdExcpt.ThreadContext.Rva = dc->rva + sizeof(mdExcpt); + + append(dc, &mdExcpt, sizeof(mdExcpt)); + append(dc, pctx, sizeof(*pctx)); } -#endif /****************************************************************** * dump_modules * * Write in File the modules from pcs */ -static void dump_modules(struct process* pcs, HANDLE hFile, RVA* rva) +static void dump_modules(struct dump_context* dc, BOOL dump_elf) { MINIDUMP_MODULE mdModule; MINIDUMP_MODULE_LIST mdModuleList; - DWORD written; - struct module* module = NULL; + char tmp[1024]; + MINIDUMP_STRING* ms = (MINIDUMP_STRING*)tmp; + ULONG i, nmod; + RVA rva_base; + DWORD flags_out; + + for (i = nmod = 0; i < dc->num_module; i++) + { + if ((dc->module[i].is_elf && dump_elf) || + (!dc->module[i].is_elf && !dump_elf)) + nmod++; + } mdModuleList.NumberOfModules = 0; - for (module = pcs->lmodules; module; module = module->next) - mdModuleList.NumberOfModules++; - WriteFile(hFile, &mdModuleList.NumberOfModules, - sizeof(mdModuleList.NumberOfModules), &written, NULL); - *rva += sizeof(mdModuleList.NumberOfModules) + - sizeof(mdModule) * mdModuleList.NumberOfModules; - for (module = pcs->lmodules; module; module = module->next) + /* reserve space for mdModuleList + * FIXME: since we don't support 0 length arrays, we cannot use the + * size of mdModuleList + * FIXME: if we don't ask for all modules in cb, we'll get a hole in the file + */ + rva_base = dc->rva; + dc->rva += sizeof(mdModuleList.NumberOfModules) + sizeof(mdModule) * nmod; + for (i = 0; i < dc->num_module; i++) { - mdModule.BaseOfImage = (DWORD)module->module.BaseOfImage; - mdModule.SizeOfImage = module->module.ImageSize; - mdModule.CheckSum = module->module.CheckSum; - mdModule.TimeDateStamp = module->module.TimeDateStamp; - mdModule.ModuleNameRva = *rva; - *rva += strlen(module->module.ModuleName) + 1; - memset(&mdModule.VersionInfo, 0, sizeof(mdModule.VersionInfo)); /* FIXME */ - mdModule.CvRecord.DataSize = 0; /* FIXME */ - mdModule.CvRecord.Rva = 0; /* FIXME */ - mdModule.MiscRecord.DataSize = 0; /* FIXME */ - mdModule.MiscRecord.Rva = 0; /* FIXME */ - mdModule.Reserved0 = 0; - mdModule.Reserved1 = 0; - WriteFile(hFile, &mdModule, sizeof(mdModule), &written, NULL); - } - for (module = pcs->lmodules; module; module = module->next) - { - WriteFile(hFile, module->module.ModuleName, - strlen(module->module.ModuleName) + 1, &written, NULL); - FIXME("CV and misc records not written\n"); + if ((dc->module[i].is_elf && !dump_elf) || + (!dc->module[i].is_elf && dump_elf)) + continue; + + flags_out = ModuleWriteModule | ModuleWriteMiscRecord | ModuleWriteCvRecord; + if (dc->type & MiniDumpWithDataSegs) + flags_out |= ModuleWriteDataSeg; + if (dc->type & MiniDumpWithProcessThreadData) + flags_out |= ModuleWriteTlsData; + if (dc->type & MiniDumpWithCodeSegs) + flags_out |= ModuleWriteCodeSegs; + ms->Length = (lstrlenW(dc->module[i].name) + 1) * sizeof(WCHAR); + if (sizeof(ULONG) + ms->Length > sizeof(tmp)) + FIXME("Buffer overflow!!!\n"); + lstrcpyW(ms->Buffer, dc->module[i].name); + + if (dc->cb) + { + MINIDUMP_CALLBACK_INPUT cbin; + MINIDUMP_CALLBACK_OUTPUT cbout; + + cbin.ProcessId = dc->pid; + cbin.ProcessHandle = dc->hProcess; + cbin.CallbackType = ModuleCallback; + + cbin.u.Module.FullPath = ms->Buffer; + cbin.u.Module.BaseOfImage = dc->module[i].base; + cbin.u.Module.SizeOfImage = dc->module[i].size; + cbin.u.Module.CheckSum = dc->module[i].checksum; + cbin.u.Module.TimeDateStamp = dc->module[i].timestamp; + memset(&cbin.u.Module.VersionInfo, 0, sizeof(cbin.u.Module.VersionInfo)); + cbin.u.Module.CvRecord = NULL; + cbin.u.Module.SizeOfCvRecord = 0; + cbin.u.Module.MiscRecord = NULL; + cbin.u.Module.SizeOfMiscRecord = 0; + + cbout.u.ModuleWriteFlags = flags_out; + if (!dc->cb->CallbackRoutine(dc->cb->CallbackParam, &cbin, &cbout)) + continue; + flags_out &= cbout.u.ModuleWriteFlags; + } + if (flags_out & ModuleWriteModule) + { + mdModule.BaseOfImage = dc->module[i].base; + mdModule.SizeOfImage = dc->module[i].size; + mdModule.CheckSum = dc->module[i].checksum; + mdModule.TimeDateStamp = dc->module[i].timestamp; + mdModule.ModuleNameRva = dc->rva; + ms->Length -= sizeof(WCHAR); + append(dc, ms, sizeof(ULONG) + ms->Length + sizeof(WCHAR)); + memset(&mdModule.VersionInfo, 0, sizeof(mdModule.VersionInfo)); /* FIXME */ + mdModule.CvRecord.DataSize = 0; /* FIXME */ + mdModule.CvRecord.Rva = 0; /* FIXME */ + mdModule.MiscRecord.DataSize = 0; /* FIXME */ + mdModule.MiscRecord.Rva = 0; /* FIXME */ + mdModule.Reserved0 = 0; /* FIXME */ + mdModule.Reserved1 = 0; /* FIXME */ + writeat(dc, + rva_base + sizeof(mdModuleList.NumberOfModules) + + mdModuleList.NumberOfModules++ * sizeof(mdModule), + &mdModule, sizeof(mdModule)); + } } + writeat(dc, rva_base, &mdModuleList.NumberOfModules, + sizeof(mdModuleList.NumberOfModules)); } /****************************************************************** @@ -99,34 +497,39 @@ static void dump_modules(struct process* pcs, HANDLE hFile, RVA* rva) * * Dumps into File the information about the system */ -static void dump_system_info(struct process* pcs, HANDLE hFile, RVA* rva) +static void dump_system_info(struct dump_context* dc) { MINIDUMP_SYSTEM_INFO mdSysInfo; SYSTEM_INFO sysInfo; - OSVERSIONINFOA osInfo; + OSVERSIONINFOW osInfo; DWORD written; + ULONG slen; GetSystemInfo(&sysInfo); - GetVersionExA(&osInfo); + osInfo.dwOSVersionInfoSize = sizeof(osInfo); + GetVersionExW(&osInfo); mdSysInfo.ProcessorArchitecture = sysInfo.u.s.wProcessorArchitecture; mdSysInfo.ProcessorLevel = sysInfo.wProcessorLevel; mdSysInfo.ProcessorRevision = sysInfo.wProcessorRevision; - mdSysInfo.Reserved0 = 0; - + mdSysInfo.u.s.NumberOfProcessors = sysInfo.dwNumberOfProcessors; + mdSysInfo.u.s.ProductType = VER_NT_WORKSTATION; /* FIXME */ mdSysInfo.MajorVersion = osInfo.dwMajorVersion; mdSysInfo.MinorVersion = osInfo.dwMinorVersion; mdSysInfo.BuildNumber = osInfo.dwBuildNumber; mdSysInfo.PlatformId = osInfo.dwPlatformId; - mdSysInfo.CSDVersionRva = *rva + sizeof(mdSysInfo); - mdSysInfo.Reserved1 = 0; + mdSysInfo.CSDVersionRva = dc->rva + sizeof(mdSysInfo); + mdSysInfo.u1.Reserved1 = 0; - WriteFile(hFile, &mdSysInfo, sizeof(mdSysInfo), &written, NULL); - *rva += sizeof(mdSysInfo); - WriteFile(hFile, osInfo.szCSDVersion, strlen(osInfo.szCSDVersion) + 1, - &written, NULL); - *rva += strlen(osInfo.szCSDVersion) + 1; + memset(&mdSysInfo.Cpu, 0, sizeof(mdSysInfo.Cpu)); + + append(dc, &mdSysInfo, sizeof(mdSysInfo)); + + slen = lstrlenW(osInfo.szCSDVersion) * sizeof(WCHAR); + WriteFile(dc->hFile, &slen, sizeof(slen), &written, NULL); + WriteFile(dc->hFile, osInfo.szCSDVersion, slen, &written, NULL); + dc->rva += sizeof(ULONG) + slen; } /****************************************************************** @@ -134,65 +537,175 @@ static void dump_system_info(struct process* pcs, HANDLE hFile, RVA* rva) * * Dumps into File the information about running threads */ -static void dump_threads(struct process* pcs, HANDLE hFile, RVA* rva) +static void dump_threads(struct dump_context* dc, + const MINIDUMP_EXCEPTION_INFORMATION* except) { -#if 0 MINIDUMP_THREAD mdThd; MINIDUMP_THREAD_LIST mdThdList; - DWORD written; - DBG_THREAD* thd; + unsigned i; + RVA rva_base; + DWORD flags_out; + CONTEXT ctx; - mdThdList.NumberOfThreads = pcs->num_threads; - WriteFile(hFile, &mdThdList.NumberOfThreads, sizeof(mdThdList.NumberOfThreads), - &written, NULL); - *rva += sizeof(mdThdList.NumberOfThreads) + - mdThdList.NumberOfThreads * sizeof(mdThd); - for (thd = pcs->threads; thd; thd = thd->next) + mdThdList.NumberOfThreads = 0; + + rva_base = dc->rva; + dc->rva += sizeof(mdThdList.NumberOfThreads) + + dc->spi->dwThreadCount * sizeof(mdThd); + + for (i = 0; i < dc->spi->dwThreadCount; i++) { - mdThd.ThreadId = thd->tid; - mdThd.SuspendCount = 0; /* FIXME */ - mdThd.PriorityClass = 0; /* FIXME */ - mdThd.Priority = 0; /* FIXME */ - mdThd.Teb = 0; /* FIXME */ - mdThd.Stack.StartOfMemoryRange = 0; /* FIXME */ - mdThd.Stack.Memory.DataSize = 0; /* FIXME */ - mdThd.Stack.Memory.Rva = 0; /* FIXME */ - mdThd.ThreadContext.DataSize = 0;/* FIXME */ - mdThd.ThreadContext.Rva = 0; /* FIXME */ + fetch_thread_info(dc, i, except, &mdThd, &ctx); - WriteFile(hFile, &mdThd, sizeof(mdThd), &written, NULL); - FIXME("Stack & thread context not written\n"); + flags_out = ThreadWriteThread | ThreadWriteStack | ThreadWriteContext | + ThreadWriteInstructionWindow; + if (dc->type & MiniDumpWithProcessThreadData) + flags_out |= ThreadWriteThreadData; + if (dc->type & MiniDumpWithThreadInfo) + flags_out |= ThreadWriteThreadInfo; + + if (dc->cb) + { + MINIDUMP_CALLBACK_INPUT cbin; + MINIDUMP_CALLBACK_OUTPUT cbout; + + cbin.ProcessId = dc->pid; + cbin.ProcessHandle = dc->hProcess; + cbin.CallbackType = ThreadCallback; + cbin.u.Thread.ThreadId = dc->spi->ti[i].dwThreadID; + cbin.u.Thread.ThreadHandle = 0; /* FIXME */ + memcpy(&cbin.u.Thread.Context, &ctx, sizeof(CONTEXT)); + cbin.u.Thread.SizeOfContext = sizeof(CONTEXT); + cbin.u.Thread.StackBase = mdThd.Stack.StartOfMemoryRange; + cbin.u.Thread.StackEnd = mdThd.Stack.StartOfMemoryRange + + mdThd.Stack.Memory.DataSize; + + cbout.u.ThreadWriteFlags = flags_out; + if (!dc->cb->CallbackRoutine(dc->cb->CallbackParam, &cbin, &cbout)) + continue; + flags_out &= cbout.u.ThreadWriteFlags; + } + if (flags_out & ThreadWriteThread) + { + if (ctx.ContextFlags && (flags_out & ThreadWriteContext)) + { + mdThd.ThreadContext.Rva = dc->rva; + mdThd.ThreadContext.DataSize = sizeof(CONTEXT); + append(dc, &ctx, sizeof(CONTEXT)); + } + if (mdThd.Stack.Memory.DataSize && (flags_out & ThreadWriteStack)) + { + add_memory_block(dc, mdThd.Stack.StartOfMemoryRange, + mdThd.Stack.Memory.DataSize, + rva_base + sizeof(mdThdList.NumberOfThreads) + + mdThdList.NumberOfThreads * sizeof(mdThd) + + FIELD_OFFSET(MINIDUMP_THREAD, Stack.Memory.Rva)); + } + writeat(dc, + rva_base + sizeof(mdThdList.NumberOfThreads) + + mdThdList.NumberOfThreads * sizeof(mdThd), + &mdThd, sizeof(mdThd)); + mdThdList.NumberOfThreads++; + } + if (ctx.ContextFlags && (flags_out & ThreadWriteInstructionWindow)) + { + /* FIXME: - Native dbghelp also dumps 0x80 bytes around EIP + * - also crop values across module boundaries, + * - and don't make it i386 dependent + */ + /* add_memory_block(dc, ctx.Eip - 0x80, ctx.Eip + 0x80, 0); */ + } } -#endif + writeat(dc, rva_base, + &mdThdList.NumberOfThreads, sizeof(mdThdList.NumberOfThreads)); +} + +/****************************************************************** + * dump_memory_info + * + * dumps information about the memory of the process (stack of the threads) + */ +static void dump_memory_info(struct dump_context* dc) +{ + MINIDUMP_MEMORY_LIST mdMemList; + MINIDUMP_MEMORY_DESCRIPTOR mdMem; + DWORD written; + unsigned i, pos, len; + RVA rva_base; + char tmp[1024]; + + mdMemList.NumberOfMemoryRanges = dc->num_mem; + append(dc, &mdMemList.NumberOfMemoryRanges, + sizeof(mdMemList.NumberOfMemoryRanges)); + rva_base = dc->rva; + dc->rva += mdMemList.NumberOfMemoryRanges * sizeof(mdMem); + + for (i = 0; i < dc->num_mem; i++) + { + mdMem.StartOfMemoryRange = dc->mem[i].base; + mdMem.Memory.Rva = dc->rva; + mdMem.Memory.DataSize = dc->mem[i].size; + SetFilePointer(dc->hFile, dc->rva, NULL, FILE_BEGIN); + for (pos = 0; pos < dc->mem[i].size; pos += sizeof(tmp)) + { + len = min(dc->mem[i].size - pos, sizeof(tmp)); + if (ReadProcessMemory(dc->hProcess, + (void*)(ULONG)(dc->mem[i].base + pos), + tmp, len, NULL)) + WriteFile(dc->hFile, tmp, len, &written, NULL); + } + dc->rva += mdMem.Memory.DataSize; + writeat(dc, rva_base + i * sizeof(mdMem), &mdMem, sizeof(mdMem)); + if (dc->mem[i].rva) + { + writeat(dc, dc->mem[i].rva, &mdMem.Memory.Rva, sizeof(mdMem.Memory.Rva)); + } + } +} + +static void dump_misc_info(struct dump_context* dc) +{ + MINIDUMP_MISC_INFO mmi; + + mmi.SizeOfInfo = sizeof(mmi); + mmi.Flags1 = MINIDUMP_MISC1_PROCESS_ID; + mmi.ProcessId = dc->pid; + /* FIXME: create/user/kernel time */ + append(dc, &mmi, sizeof(mmi)); } /****************************************************************** * MiniDumpWriteDump (DEBUGHLP.@) * - * */ -BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile, +BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess, DWORD pid, HANDLE hFile, MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam, PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam) { - struct process* pcs; MINIDUMP_HEADER mdHead; MINIDUMP_DIRECTORY mdDir; - DWORD currRva, written; - DWORD i, nStream, addStream; - RVA rva; + DWORD i, nStreams, idx_stream; + struct dump_context dc; - pcs = process_find_by_handle(hProcess); - if (!pcs) return FALSE; /* FIXME: should try to load it ??? */ + dc.hProcess = hProcess; + dc.hFile = hFile; + dc.pid = pid; + dc.module = NULL; + dc.num_module = 0; + dc.cb = CallbackParam; + dc.type = DumpType; + dc.mem = NULL; + dc.num_mem = 0; + dc.rva = 0; + + if (!fetch_process_info(&dc)) return FALSE; + fetch_module_info(&dc); /* 1) init */ - - nStream = UserStreamParam ? UserStreamParam->UserStreamCount : 0; - addStream = 0; - if (DumpType & MiniDumpNormal) - addStream += 3; /* sure ? thread stack back trace */ + nStreams = 6 + (ExceptionParam ? 1 : 0) + + (UserStreamParam ? UserStreamParam->UserStreamCount : 0); if (DumpType & MiniDumpWithDataSegs) FIXME("NIY MiniDumpWithDataSegs\n"); @@ -206,61 +719,123 @@ BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile, FIXME("NIY MiniDumpScanMemory\n"); /* 2) write header */ - rva = sizeof(mdHead); mdHead.Signature = MINIDUMP_SIGNATURE; mdHead.Version = MINIDUMP_VERSION; - mdHead.NumberOfStreams = nStream + addStream; - mdHead.StreamDirectoryRva = rva; + mdHead.NumberOfStreams = nStreams; + mdHead.StreamDirectoryRva = sizeof(mdHead); mdHead.u.TimeDateStamp = time(NULL); mdHead.Flags = DumpType; - WriteFile(hFile, &mdHead, sizeof(mdHead), &written, NULL); + append(&dc, &mdHead, sizeof(mdHead)); /* 3) write stream directories */ - rva += (nStream + addStream) * sizeof(mdDir); + dc.rva += nStreams * sizeof(mdDir); + idx_stream = 0; + /* 3.1) write data stream directories */ - currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); - SetFilePointer(hFile, rva, NULL, FILE_BEGIN); - mdDir.StreamType = ModuleListStream; - mdDir.Location.Rva = rva; - dump_modules(pcs, hFile, &rva); - mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva; - SetFilePointer(hFile, currRva, NULL, FILE_BEGIN); - WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL); - currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); - SetFilePointer(hFile, rva, NULL, FILE_BEGIN); mdDir.StreamType = ThreadListStream; - mdDir.Location.Rva = rva; - dump_threads(pcs, hFile, &rva); - mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva; - SetFilePointer(hFile, currRva, NULL, FILE_BEGIN); - WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL); + mdDir.Location.Rva = dc.rva; + dump_threads(&dc, ExceptionParam); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); + + mdDir.StreamType = ModuleListStream; + mdDir.Location.Rva = dc.rva; + dump_modules(&dc, FALSE); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); + + mdDir.StreamType = 0xfff0; /* FIXME: this is part of MS reserved streams */ + mdDir.Location.Rva = dc.rva; + dump_modules(&dc, TRUE); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); + + mdDir.StreamType = MemoryListStream; + mdDir.Location.Rva = dc.rva; + dump_memory_info(&dc); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); - currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); - SetFilePointer(hFile, rva, NULL, FILE_BEGIN); mdDir.StreamType = SystemInfoStream; - mdDir.Location.Rva = rva; - dump_system_info(pcs, hFile, &rva); - mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva; - SetFilePointer(hFile, currRva, NULL, FILE_BEGIN); - WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL); + mdDir.Location.Rva = dc.rva; + dump_system_info(&dc); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); - /* 3.2) write user define stream */ - for (i = 0; i < nStream; i++) + mdDir.StreamType = MiscInfoStream; + mdDir.Location.Rva = dc.rva; + dump_misc_info(&dc); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); + + /* 3.2) write exception information (if any) */ + if (ExceptionParam) { - mdDir.StreamType = UserStreamParam->UserStreamArray[i].Type; - mdDir.Location.DataSize = UserStreamParam->UserStreamArray[i].BufferSize; - mdDir.Location.Rva = rva; - WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL); - currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); - SetFilePointer(hFile, rva, NULL, FILE_BEGIN); - WriteFile(hFile, - UserStreamParam->UserStreamArray[i].Buffer, - UserStreamParam->UserStreamArray[i].BufferSize, - &written, NULL); - rva += UserStreamParam->UserStreamArray[i].BufferSize; - SetFilePointer(hFile, currRva, NULL, FILE_BEGIN); + mdDir.StreamType = ExceptionStream; + mdDir.Location.Rva = dc.rva; + dump_exception_info(&dc, ExceptionParam); + mdDir.Location.DataSize = dc.rva - mdDir.Location.Rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); } + /* 3.3) write user defined streams (if any) */ + if (UserStreamParam) + { + for (i = 0; i < UserStreamParam->UserStreamCount; i++) + { + mdDir.StreamType = UserStreamParam->UserStreamArray[i].Type; + mdDir.Location.DataSize = UserStreamParam->UserStreamArray[i].BufferSize; + mdDir.Location.Rva = dc.rva; + writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir), + &mdDir, sizeof(mdDir)); + append(&dc, UserStreamParam->UserStreamArray[i].Buffer, + UserStreamParam->UserStreamArray[i].BufferSize); + } + } + + HeapFree(GetProcessHeap(), 0, dc.pcs_buffer); + HeapFree(GetProcessHeap(), 0, dc.mem); + HeapFree(GetProcessHeap(), 0, dc.module); + return TRUE; } + +/****************************************************************** + * MiniDumpReadDumpStream (DEBUGHLP.@) + * + * + */ +BOOL WINAPI MiniDumpReadDumpStream(PVOID base, ULONG str_idx, + PMINIDUMP_DIRECTORY* pdir, + PVOID* stream, ULONG* size) +{ + MINIDUMP_HEADER* mdHead = (MINIDUMP_HEADER*)base; + + if (mdHead->Signature == MINIDUMP_SIGNATURE) + { + MINIDUMP_DIRECTORY* dir; + int i; + + dir = (MINIDUMP_DIRECTORY*)((char*)base + mdHead->StreamDirectoryRva); + for (i = 0; i < mdHead->NumberOfStreams; i++, dir++) + { + if (dir->StreamType == str_idx) + { + *pdir = dir; + *stream = (char*)base + dir->Location.Rva; + *size = dir->Location.DataSize; + return TRUE; + } + } + } + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; +} diff --git a/reactos/dll/win32/dbghelp/module.c b/reactos/dll/win32/dbghelp/module.c index ea5a955d93f..8b2ece0be2f 100644 --- a/reactos/dll/win32/dbghelp/module.c +++ b/reactos/dll/win32/dbghelp/module.c @@ -2,7 +2,7 @@ * File module.c - module handling for the wine debugger * * Copyright (C) 1993, Eric Youngdale. - * 2000-2004, Eric Pouech + * 2000-2007, Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -16,7 +16,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -27,80 +27,146 @@ #include "dbghelp_private.h" #include "psapi.h" -#include "winreg.h" #include "winternl.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); -static void module_fill_module(const char* in, char* out, unsigned size) -{ - const char* ptr; - unsigned len; +const WCHAR S_ElfW[] = {'<','e','l','f','>','\0'}; +const WCHAR S_WineLoaderW[] = {'<','w','i','n','e','-','l','o','a','d','e','r','>','\0'}; +static const WCHAR S_DotSoW[] = {'.','s','o','\0'}; +static const WCHAR S_DotPdbW[] = {'.','p','d','b','\0'}; +const WCHAR S_WinePThreadW[] = {'w','i','n','e','-','p','t','h','r','e','a','d','\0'}; +const WCHAR S_WineKThreadW[] = {'w','i','n','e','-','k','t','h','r','e','a','d','\0'}; +const WCHAR S_SlashW[] = {'/','\0'}; - for (ptr = in + strlen(in) - 1; - *ptr != '/' && *ptr != '\\' && ptr >= in; - ptr--); - if (ptr < in || *ptr == '/' || *ptr == '\\') ptr++; - strncpy(out, ptr, size); - out[size - 1] = '\0'; - len = strlen(out); - if (len > 4 && - (!strcasecmp(&out[len - 4], ".dll") || !strcasecmp(&out[len - 4], ".exe"))) - out[len - 4] = '\0'; +static const WCHAR S_AcmW[] = {'.','a','c','m','\0'}; +static const WCHAR S_DllW[] = {'.','d','l','l','\0'}; +static const WCHAR S_DrvW[] = {'.','d','r','v','\0'}; +static const WCHAR S_ExeW[] = {'.','e','x','e','\0'}; +static const WCHAR S_OcxW[] = {'.','o','c','x','\0'}; +static const WCHAR S_VxdW[] = {'.','v','x','d','\0'}; +static const WCHAR * const ext[] = {S_AcmW, S_DllW, S_DrvW, S_ExeW, S_OcxW, S_VxdW, NULL}; + +static int match_ext(const WCHAR* ptr, size_t len) +{ + const WCHAR* const *e; + size_t l; + + for (e = ext; *e; e++) + { + l = strlenW(*e); + if (l >= len) return FALSE; + if (strncmpiW(&ptr[len - l], *e, l)) continue; + return l; + } + return 0; +} + +static const WCHAR* get_filename(const WCHAR* name, const WCHAR* endptr) +{ + const WCHAR* ptr; + + if (!endptr) endptr = name + strlenW(name); + for (ptr = endptr - 1; ptr >= name; ptr--) + { + if (*ptr == '/' || *ptr == '\\') break; + } + return ++ptr; +} + +static void module_fill_module(const WCHAR* in, WCHAR* out, size_t size) +{ + const WCHAR *ptr, *endptr; + size_t len, l; + + ptr = get_filename(in, endptr = in + strlenW(in)); + len = min(endptr - ptr, size - 1); + memcpy(out, ptr, len * sizeof(WCHAR)); + out[len] = '\0'; + if (len > 4 && (l = match_ext(out, len))) + out[len - l] = '\0'; + else if (len > 12 && + (!strcmpiW(out + len - 12, S_WinePThreadW) || + !strcmpiW(out + len - 12, S_WineKThreadW))) + lstrcpynW(out, S_WineLoaderW, size); else { - if (len > 7 && - (!strcasecmp(&out[len - 7], ".dll.so") || !strcasecmp(&out[len - 7], ".exe.so"))) - strcpy(&out[len - 7], ""); - else if (len > 7 && - out[len - 7] == '.' && !strcasecmp(&out[len - 3], ".so")) - { - if (len + 3 < size) strcpy(&out[len - 3], ""); - else WARN("Buffer too short: %s\n", out); - } + if (len > 3 && !strcmpiW(&out[len - 3], S_DotSoW) && + (l = match_ext(out, len - 3))) + strcpyW(&out[len - l - 3], S_ElfW); + } + while ((*out = tolowerW(*out))) out++; +} + +void module_set_module(struct module* module, const WCHAR* name) +{ + module_fill_module(name, module->module.ModuleName, sizeof(module->module.ModuleName)); + WideCharToMultiByte(CP_ACP, 0, module->module.ModuleName, -1, + module->module_name, sizeof(module->module_name), + NULL, NULL); +} + +static const char* get_module_type(enum module_type type, BOOL virtual) +{ + switch (type) + { + case DMT_ELF: return virtual ? "Virtual ELF" : "ELF"; + case DMT_PE: return virtual ? "Virtual PE" : "PE"; + default: return "---"; } - while ((*out = tolower(*out))) out++; } /*********************************************************************** - * Creates and links a new module to a process + * Creates and links a new module to a process */ -struct module* module_new(struct process* pcs, const char* name, - enum module_type type, +struct module* module_new(struct process* pcs, const WCHAR* name, + enum module_type type, BOOL virtual, unsigned long mod_addr, unsigned long size, - unsigned long stamp, unsigned long checksum) + unsigned long stamp, unsigned long checksum) { struct module* module; - if (!(module = HeapAlloc(GetProcessHeap(), 0, sizeof(*module)))) + assert(type == DMT_ELF || type == DMT_PE); + if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module)))) return NULL; - memset(module, 0, sizeof(*module)); - module->next = pcs->lmodules; pcs->lmodules = module; - TRACE("=> %s %08lx-%08lx %s\n", - type == DMT_ELF ? "ELF" : (type == DMT_PE ? "PE" : "---"), - mod_addr, mod_addr + size, name); + TRACE("=> %s %08lx-%08lx %s\n", + get_module_type(type, virtual), mod_addr, mod_addr + size, + debugstr_w(name)); pool_init(&module->pool, 65536); - + module->module.SizeOfStruct = sizeof(module->module); module->module.BaseOfImage = mod_addr; module->module.ImageSize = size; - module_fill_module(name, module->module.ModuleName, sizeof(module->module.ModuleName)); + module_set_module(module, name); module->module.ImageName[0] = '\0'; - strncpy(module->module.LoadedImageName, name, - sizeof(module->module.LoadedImageName)); - module->module.LoadedImageName[sizeof(module->module.LoadedImageName) - 1] = '\0'; + lstrcpynW(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName) / sizeof(WCHAR)); module->module.SymType = SymNone; module->module.NumSyms = 0; module->module.TimeDateStamp = stamp; module->module.CheckSum = checksum; + memset(module->module.LoadedPdbName, 0, sizeof(module->module.CVData)); + module->module.CVSig = 0; + memset(module->module.CVData, 0, sizeof(module->module.CVData)); + module->module.PdbSig = 0; + memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70)); + module->module.PdbAge = 0; + module->module.PdbUnmatched = FALSE; + module->module.DbgUnmatched = FALSE; + module->module.LineNumbers = FALSE; + module->module.GlobalSymbols = FALSE; + module->module.TypeInfo = FALSE; + module->module.SourceIndexed = FALSE; + module->module.Publics = FALSE; + module->type = type; + module->is_virtual = virtual ? TRUE : FALSE; module->sortlist_valid = FALSE; module->addr_sorttab = NULL; /* FIXME: this seems a bit too high (on a per module basis) @@ -121,29 +187,47 @@ struct module* module_new(struct process* pcs, const char* name, * module_find_by_name * */ -struct module* module_find_by_name(const struct process* pcs, - const char* name, enum module_type type) +struct module* module_find_by_name(const struct process* pcs, const WCHAR* name) { struct module* module; - if (type == DMT_UNKNOWN) + for (module = pcs->lmodules; module; module = module->next) { - if ((module = module_find_by_name(pcs, name, DMT_PE)) || - (module = module_find_by_name(pcs, name, DMT_ELF))) + if (!strcmpiW(name, module->module.ModuleName)) return module; + } + SetLastError(ERROR_INVALID_NAME); + return NULL; +} + +struct module* module_find_by_nameA(const struct process* pcs, const char* name) +{ + WCHAR wname[MAX_PATH]; + + MultiByteToWideChar(CP_ACP, 0, name, -1, wname, sizeof(wname) / sizeof(WCHAR)); + return module_find_by_name(pcs, wname); +} + +/*********************************************************************** + * module_is_already_loaded + * + */ +struct module* module_is_already_loaded(const struct process* pcs, const WCHAR* name) +{ + struct module* module; + const WCHAR* filename; + + /* first compare the loaded image name... */ + for (module = pcs->lmodules; module; module = module->next) + { + if (!strcmpiW(name, module->module.LoadedImageName)) return module; } - else + /* then compare the standard filenames (without the path) ... */ + filename = get_filename(name, NULL); + for (module = pcs->lmodules; module; module = module->next) { - for (module = pcs->lmodules; module; module = module->next) - { - if (type == module->type && !strcasecmp(name, module->module.LoadedImageName)) - return module; - } - for (module = pcs->lmodules; module; module = module->next) - { - if (type == module->type && !strcasecmp(name, module->module.ModuleName)) - return module; - } + if (!strcmpiW(filename, get_filename(module->module.LoadedImageName, NULL))) + return module; } SetLastError(ERROR_INVALID_NAME); return NULL; @@ -199,29 +283,50 @@ struct module* module_get_containee(const struct process* pcs, * container (and also force the ELF container's debug info loading if deferred) * - otherwise return the module itself if it has some debug info */ -struct module* module_get_debug(const struct process* pcs, struct module* module) +BOOL module_get_debug(struct module_pair* pair) { - struct module* parent; + IMAGEHLP_DEFERRED_SYMBOL_LOADW64 idslW64; - if (!module) return NULL; - /* for a PE builtin, always get info from parent */ - if ((parent = module_get_container(pcs, module))) - module = parent; + if (!pair->requested) return FALSE; + /* for a PE builtin, always get info from container */ + if (!(pair->effective = module_get_container(pair->pcs, pair->requested))) + pair->effective = pair->requested; /* if deferred, force loading */ - if (module->module.SymType == SymDeferred) + if (pair->effective->module.SymType == SymDeferred) { BOOL ret; - - switch (module->type) + + if (pair->effective->is_virtual) ret = FALSE; + else switch (pair->effective->type) { - case DMT_ELF: ret = elf_load_debug_info(module); break; - case DMT_PE: ret = pe_load_debug_info(pcs, module); break; - default: ret = FALSE; break; + case DMT_ELF: + ret = elf_load_debug_info(pair->effective, NULL); + break; + case DMT_PE: + idslW64.SizeOfStruct = sizeof(idslW64); + idslW64.BaseOfImage = pair->effective->module.BaseOfImage; + idslW64.CheckSum = pair->effective->module.CheckSum; + idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp; + memcpy(idslW64.FileName, pair->effective->module.ImageName, + sizeof(idslW64.FileName)); + idslW64.Reparse = FALSE; + idslW64.hFile = INVALID_HANDLE_VALUE; + + pcs_callback(pair->pcs, CBA_DEFERRED_SYMBOL_LOAD_START, &idslW64); + ret = pe_load_debug_info(pair->pcs, pair->effective); + pcs_callback(pair->pcs, + ret ? CBA_DEFERRED_SYMBOL_LOAD_COMPLETE : CBA_DEFERRED_SYMBOL_LOAD_FAILURE, + &idslW64); + break; + default: + ret = FALSE; + break; } - if (!ret) module->module.SymType = SymNone; - assert(module->module.SymType != SymDeferred); + if (!ret) pair->effective->module.SymType = SymNone; + assert(pair->effective->module.SymType != SymDeferred); + pair->effective->module.NumSyms = pair->effective->ht_symbols.num_elts; } - return (module && module->module.SymType != SymNone) ? module : NULL; + return pair->effective->module.SymType != SymNone; } /*********************************************************************** @@ -254,89 +359,217 @@ struct module* module_find_by_addr(const struct process* pcs, unsigned long addr return module; } -static BOOL module_is_elf_container_loaded(struct process* pcs, const char* ImageName, - const char* ModuleName) +/****************************************************************** + * module_is_elf_container_loaded + * + * checks whether the ELF container, for a (supposed) PE builtin is + * already loaded + */ +static BOOL module_is_elf_container_loaded(const struct process* pcs, + const WCHAR* ImageName, DWORD base) { - char buffer[MAX_PATH]; size_t len; struct module* module; + PCWSTR filename, modname; + + if (!base) return FALSE; + filename = get_filename(ImageName, NULL); + len = strlenW(filename); - if (!ModuleName) - { - module_fill_module(ImageName, buffer, sizeof(buffer)); - ModuleName = buffer; - } - len = strlen(ModuleName); for (module = pcs->lmodules; module; module = module->next) { - if (!strncasecmp(module->module.ModuleName, ModuleName, len) && - module->type == DMT_ELF && - !strcmp(module->module.ModuleName + len, "")) - return TRUE; + if (module->type == DMT_ELF && + base >= module->module.BaseOfImage && + base < module->module.BaseOfImage + module->module.ImageSize) + { + modname = get_filename(module->module.LoadedImageName, NULL); + if (!strncmpiW(modname, filename, len) && + !memcmp(modname + len, S_DotSoW, 3 * sizeof(WCHAR))) + { + return TRUE; + } + } } + /* likely a native PE module */ + WARN("Couldn't find container for %s\n", debugstr_w(ImageName)); return FALSE; } +/****************************************************************** + * module_get_type_by_name + * + * Guesses a filename type from its extension + */ +enum module_type module_get_type_by_name(const WCHAR* name) +{ + int len = strlenW(name); + + /* Skip all version extensions (.[digits]) regex: "(\.\d+)*$" */ + do + { + int i = len; + + while (i && isdigit(name[i - 1])) i--; + + if (i && name[i - 1] == '.') + len = i - 1; + else + break; + } while (len); + + /* check for terminating .so or .so.[digit] */ + if (len > 3 && !memcmp(name + len - 3, S_DotSoW, 3)) + return DMT_ELF; + + if (len > 4 && !strncmpiW(name + len - 4, S_DotPdbW, 4)) + return DMT_PDB; + + /* wine-[kp]thread is also an ELF module */ + if (((len > 12 && name[len - 13] == '/') || len == 12) && + (!strncmpiW(name + len - 12, S_WinePThreadW, 12) || + !strncmpiW(name + len - 12, S_WineKThreadW, 12))) + { + return DMT_ELF; + } + return DMT_PE; +} + /*********************************************************************** * SymLoadModule (DBGHELP.@) */ -DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, char* ImageName, - char* ModuleName, DWORD BaseOfDll, DWORD SizeOfDll) +DWORD WINAPI SymLoadModule(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, + PCSTR ModuleName, DWORD BaseOfDll, DWORD SizeOfDll) +{ + return SymLoadModuleEx(hProcess, hFile, ImageName, ModuleName, BaseOfDll, + SizeOfDll, NULL, 0); +} + +/*********************************************************************** + * SymLoadModuleEx (DBGHELP.@) + */ +DWORD64 WINAPI SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, + PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize, + PMODLOAD_DATA Data, DWORD Flags) +{ + PWSTR wImageName, wModuleName; + unsigned len; + DWORD64 ret; + + TRACE("(%p %p %s %s %s %08x %p %08x)\n", + hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName), + wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags); + + if (ImageName) + { + len = MultiByteToWideChar(CP_ACP, 0, ImageName, -1, NULL, 0); + wImageName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, ImageName, -1, wImageName, len); + } + else wImageName = NULL; + if (ModuleName) + { + len = MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, NULL, 0); + wModuleName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); + MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, wModuleName, len); + } + else wModuleName = NULL; + + ret = SymLoadModuleExW(hProcess, hFile, wImageName, wModuleName, + BaseOfDll, DllSize, Data, Flags); + HeapFree(GetProcessHeap(), 0, wImageName); + HeapFree(GetProcessHeap(), 0, wModuleName); + return ret; +} + +/*********************************************************************** + * SymLoadModuleExW (DBGHELP.@) + */ +DWORD64 WINAPI SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageName, + PCWSTR wModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll, + PMODLOAD_DATA Data, DWORD Flags) { struct process* pcs; struct module* module = NULL; - TRACE("(%p %p %s %s %08lx %08lx)\n", - hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName), - BaseOfDll, SizeOfDll); + TRACE("(%p %p %s %s %s %08x %p %08x)\n", + hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName), + wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags); - pcs = process_find_by_handle(hProcess); - if (!pcs) return FALSE; + if (Data) + FIXME("Unsupported load data parameter %p for %s\n", + Data, debugstr_w(wImageName)); + if (!validate_addr64(BaseOfDll)) return FALSE; + + if (!(pcs = process_find_by_handle(hProcess))) return FALSE; + + if (Flags & SLMFLAG_VIRTUAL) + { + module = module_new(pcs, wImageName, module_get_type_by_name(wImageName), + TRUE, (DWORD)BaseOfDll, SizeOfDll, 0, 0); + if (!module) return FALSE; + if (wModuleName) module_set_module(module, wModuleName); + module->module.SymType = SymVirtual; + + return TRUE; + } + if (Flags & ~(SLMFLAG_VIRTUAL)) + FIXME("Unsupported Flags %08x for %s\n", Flags, debugstr_w(wImageName)); /* force transparent ELF loading / unloading */ elf_synchronize_module_list(pcs); /* this is a Wine extension to the API just to redo the synchronisation */ - if (!ImageName && !hFile) return 0; + if (!wImageName && !hFile) return 0; - if (module_is_elf_container_loaded(pcs, ImageName, ModuleName)) - { - /* force the loading of DLL as builtin */ - if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName, BaseOfDll, SizeOfDll))) - goto done; - WARN("Couldn't locate %s\n", ImageName); - return 0; - } - TRACE("Assuming %s as native DLL\n", ImageName); - if (!(module = pe_load_module(pcs, ImageName, hFile, BaseOfDll, SizeOfDll))) - { - unsigned len = strlen(ImageName); - - if (!strcmp(ImageName + len - 3, ".so") && - (module = elf_load_module(pcs, ImageName))) goto done; - FIXME("should have successfully loaded some debug information for image %s\n", ImageName); - if ((module = pe_load_module_from_pcs(pcs, ImageName, ModuleName, BaseOfDll, SizeOfDll))) - goto done; - WARN("Couldn't locate %s\n", ImageName); - return 0; - } - -done: - /* by default pe_load_module fills module.ModuleName from a derivation - * of ImageName. Overwrite it, if we have better information + /* check if the module is already loaded, or if it's a builtin PE module with + * an containing ELF module */ - if (ModuleName) + if (wImageName) { - strncpy(module->module.ModuleName, ModuleName, - sizeof(module->module.ModuleName)); - module->module.ModuleName[sizeof(module->module.ModuleName) - 1] = '\0'; + module = module_is_already_loaded(pcs, wImageName); + if (!module && module_is_elf_container_loaded(pcs, wImageName, BaseOfDll)) + { + /* force the loading of DLL as builtin */ + module = pe_load_builtin_module(pcs, wImageName, BaseOfDll, SizeOfDll); + } } - strncpy(module->module.ImageName, ImageName, sizeof(module->module.ImageName)); - module->module.ImageName[sizeof(module->module.ImageName) - 1] = '\0'; + if (!module) + { + /* otherwise, try a regular PE module */ + if (!(module = pe_load_native_module(pcs, wImageName, hFile, BaseOfDll, SizeOfDll))) + { + /* and finally and ELF module */ + if (module_get_type_by_name(wImageName) == DMT_ELF) + module = elf_load_module(pcs, wImageName, BaseOfDll); + } + } + if (!module) + { + WARN("Couldn't locate %s\n", debugstr_w(wImageName)); + return 0; + } + module->module.NumSyms = module->ht_symbols.num_elts; + /* by default module_new fills module.ModuleName from a derivation + * of LoadedImageName. Overwrite it, if we have better information + */ + if (wModuleName) + module_set_module(module, wModuleName); + lstrcpynW(module->module.ImageName, wImageName, + sizeof(module->module.ImageName) / sizeof(CHAR)); return module->module.BaseOfImage; } +/*********************************************************************** + * SymLoadModule64 (DBGHELP.@) + */ +DWORD64 WINAPI SymLoadModule64(HANDLE hProcess, HANDLE hFile, PCSTR ImageName, + PCSTR ModuleName, DWORD64 BaseOfDll, DWORD SizeOfDll) +{ + if (!validate_addr64(BaseOfDll)) return FALSE; + return SymLoadModule(hProcess, hFile, ImageName, ModuleName, (DWORD)BaseOfDll, SizeOfDll); +} + /****************************************************************** * module_remove * @@ -345,13 +578,16 @@ BOOL module_remove(struct process* pcs, struct module* module) { struct module** p; - TRACE("%s (%p)\n", module->module.ModuleName, module); + TRACE("%s (%p)\n", debugstr_w(module->module.ModuleName), module); hash_table_destroy(&module->ht_symbols); hash_table_destroy(&module->ht_types); - HeapFree(GetProcessHeap(), 0, (char*)module->sources); + HeapFree(GetProcessHeap(), 0, module->sources); HeapFree(GetProcessHeap(), 0, module->addr_sorttab); + HeapFree(GetProcessHeap(), 0, module->dwarf2_info); pool_destroy(&module->pool); - + /* native dbghelp doesn't invoke registered callback(,CBA_SYMBOLS_UNLOADED,) here + * so do we + */ for (p = &pcs->lmodules; *p; p = &(*p)->next) { if (*p == module) @@ -381,13 +617,92 @@ BOOL WINAPI SymUnloadModule(HANDLE hProcess, DWORD BaseOfDll) return module_remove(pcs, module); } +/****************************************************************** + * SymUnloadModule64 (DBGHELP.@) + * + */ +BOOL WINAPI SymUnloadModule64(HANDLE hProcess, DWORD64 BaseOfDll) +{ + struct process* pcs; + struct module* module; + + pcs = process_find_by_handle(hProcess); + if (!pcs) return FALSE; + if (!validate_addr64(BaseOfDll)) return FALSE; + module = module_find_by_addr(pcs, (DWORD)BaseOfDll, DMT_UNKNOWN); + if (!module) return FALSE; + return module_remove(pcs, module); +} + /****************************************************************** * SymEnumerateModules (DBGHELP.@) * */ +struct enum_modW64_32 +{ + PSYM_ENUMMODULES_CALLBACK cb; + PVOID user; + char module[MAX_PATH]; +}; + +static BOOL CALLBACK enum_modW64_32(PCWSTR name, DWORD64 base, PVOID user) +{ + struct enum_modW64_32* x = user; + + WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL); + return x->cb(x->module, (DWORD)base, x->user); +} + BOOL WINAPI SymEnumerateModules(HANDLE hProcess, PSYM_ENUMMODULES_CALLBACK EnumModulesCallback, PVOID UserContext) +{ + struct enum_modW64_32 x; + + x.cb = EnumModulesCallback; + x.user = UserContext; + + return SymEnumerateModulesW64(hProcess, enum_modW64_32, &x); +} + +/****************************************************************** + * SymEnumerateModules64 (DBGHELP.@) + * + */ +struct enum_modW64_64 +{ + PSYM_ENUMMODULES_CALLBACK64 cb; + PVOID user; + char module[MAX_PATH]; +}; + +static BOOL CALLBACK enum_modW64_64(PCWSTR name, DWORD64 base, PVOID user) +{ + struct enum_modW64_64* x = user; + + WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL); + return x->cb(x->module, base, x->user); +} + +BOOL WINAPI SymEnumerateModules64(HANDLE hProcess, + PSYM_ENUMMODULES_CALLBACK64 EnumModulesCallback, + PVOID UserContext) +{ + struct enum_modW64_64 x; + + x.cb = EnumModulesCallback; + x.user = UserContext; + + return SymEnumerateModulesW64(hProcess, enum_modW64_64, &x); +} + +/****************************************************************** + * SymEnumerateModulesW64 (DBGHELP.@) + * + */ +BOOL WINAPI SymEnumerateModulesW64(HANDLE hProcess, + PSYM_ENUMMODULES_CALLBACKW64 EnumModulesCallback, + PVOID UserContext) { struct process* pcs = process_find_by_handle(hProcess); struct module* module; @@ -396,29 +711,92 @@ BOOL WINAPI SymEnumerateModules(HANDLE hProcess, for (module = pcs->lmodules; module; module = module->next) { - if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type != DMT_PE) + if (!(dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) && module->type == DMT_ELF) continue; - if (!EnumModulesCallback(module->module.ModuleName, + if (!EnumModulesCallback(module->module.ModuleName, module->module.BaseOfImage, UserContext)) break; } return TRUE; } +/****************************************************************** + * EnumerateLoadedModules64 (DBGHELP.@) + * + */ +struct enum_load_modW64_64 +{ + PENUMLOADED_MODULES_CALLBACK64 cb; + PVOID user; + char module[MAX_PATH]; +}; + +static BOOL CALLBACK enum_load_modW64_64(PCWSTR name, DWORD64 base, ULONG size, + PVOID user) +{ + struct enum_load_modW64_64* x = user; + + WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL); + return x->cb(x->module, base, size, x->user); +} + +BOOL WINAPI EnumerateLoadedModules64(HANDLE hProcess, + PENUMLOADED_MODULES_CALLBACK64 EnumLoadedModulesCallback, + PVOID UserContext) +{ + struct enum_load_modW64_64 x; + + x.cb = EnumLoadedModulesCallback; + x.user = UserContext; + + return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_64, &x); +} + /****************************************************************** * EnumerateLoadedModules (DBGHELP.@) * */ +struct enum_load_modW64_32 +{ + PENUMLOADED_MODULES_CALLBACK cb; + PVOID user; + char module[MAX_PATH]; +}; + +static BOOL CALLBACK enum_load_modW64_32(PCWSTR name, DWORD64 base, ULONG size, + PVOID user) +{ + struct enum_load_modW64_32* x = user; + WideCharToMultiByte(CP_ACP, 0, name, -1, x->module, sizeof(x->module), NULL, NULL); + return x->cb(x->module, (DWORD)base, size, x->user); +} + BOOL WINAPI EnumerateLoadedModules(HANDLE hProcess, PENUMLOADED_MODULES_CALLBACK EnumLoadedModulesCallback, PVOID UserContext) +{ + struct enum_load_modW64_32 x; + + x.cb = EnumLoadedModulesCallback; + x.user = UserContext; + + return EnumerateLoadedModulesW64(hProcess, enum_load_modW64_32, &x); +} + +/****************************************************************** + * EnumerateLoadedModulesW64 (DBGHELP.@) + * + */ +BOOL WINAPI EnumerateLoadedModulesW64(HANDLE hProcess, + PENUMLOADED_MODULES_CALLBACKW64 EnumLoadedModulesCallback, + PVOID UserContext) { HMODULE* hMods; - char base[256], mod[256]; + WCHAR baseW[256], modW[256]; DWORD i, sz; MODULEINFO mi; - hMods = HeapAlloc(GetProcessHeap(), 0, sz); + hMods = HeapAlloc(GetProcessHeap(), 0, 256 * sizeof(hMods[0])); if (!hMods) return FALSE; if (!EnumProcessModules(hProcess, hMods, 256 * sizeof(hMods[0]), &sz)) @@ -432,11 +810,10 @@ BOOL WINAPI EnumerateLoadedModules(HANDLE hProcess, for (i = 0; i < sz; i++) { if (!GetModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)) || - !GetModuleBaseNameA(hProcess, hMods[i], base, sizeof(base))) + !GetModuleBaseNameW(hProcess, hMods[i], baseW, sizeof(baseW) / sizeof(WCHAR))) continue; - module_fill_module(base, mod, sizeof(mod)); - - EnumLoadedModulesCallback(mod, (DWORD)mi.lpBaseOfDll, mi.SizeOfImage, + module_fill_module(baseW, modW, sizeof(modW) / sizeof(CHAR)); + EnumLoadedModulesCallback(modW, (DWORD_PTR)mi.lpBaseOfDll, mi.SizeOfImage, UserContext); } HeapFree(GetProcessHeap(), 0, hMods); @@ -448,30 +825,152 @@ BOOL WINAPI EnumerateLoadedModules(HANDLE hProcess, * SymGetModuleInfo (DBGHELP.@) * */ -BOOL WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr, +BOOL WINAPI SymGetModuleInfo(HANDLE hProcess, DWORD dwAddr, PIMAGEHLP_MODULE ModuleInfo) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; + IMAGEHLP_MODULE mi; + IMAGEHLP_MODULEW64 miw64; - if (!pcs) return FALSE; - if (ModuleInfo->SizeOfStruct < sizeof(*ModuleInfo)) return FALSE; - module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN); - if (!module) return FALSE; + if (sizeof(mi) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n"); - *ModuleInfo = module->module; - if (module->module.SymType == SymNone) - { - module = module_get_container(pcs, module); - if (module && module->module.SymType != SymNone) - ModuleInfo->SymType = module->module.SymType; - } + miw64.SizeOfStruct = sizeof(miw64); + if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE; + + mi.SizeOfStruct = miw64.SizeOfStruct; + mi.BaseOfImage = miw64.BaseOfImage; + mi.ImageSize = miw64.ImageSize; + mi.TimeDateStamp = miw64.TimeDateStamp; + mi.CheckSum = miw64.CheckSum; + mi.NumSyms = miw64.NumSyms; + mi.SymType = miw64.SymType; + WideCharToMultiByte(CP_ACP, 0, miw64.ModuleName, -1, + mi.ModuleName, sizeof(mi.ModuleName), NULL, NULL); + WideCharToMultiByte(CP_ACP, 0, miw64.ImageName, -1, + mi.ImageName, sizeof(mi.ImageName), NULL, NULL); + WideCharToMultiByte(CP_ACP, 0, miw64.LoadedImageName, -1, + mi.LoadedImageName, sizeof(mi.LoadedImageName), NULL, NULL); + + memcpy(ModuleInfo, &mi, ModuleInfo->SizeOfStruct); return TRUE; } +/****************************************************************** + * SymGetModuleInfoW (DBGHELP.@) + * + */ +BOOL WINAPI SymGetModuleInfoW(HANDLE hProcess, DWORD dwAddr, + PIMAGEHLP_MODULEW ModuleInfo) +{ + IMAGEHLP_MODULEW64 miw64; + IMAGEHLP_MODULEW miw; + + if (sizeof(miw) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n"); + + miw64.SizeOfStruct = sizeof(miw64); + if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE; + + miw.SizeOfStruct = miw64.SizeOfStruct; + miw.BaseOfImage = miw64.BaseOfImage; + miw.ImageSize = miw64.ImageSize; + miw.TimeDateStamp = miw64.TimeDateStamp; + miw.CheckSum = miw64.CheckSum; + miw.NumSyms = miw64.NumSyms; + miw.SymType = miw64.SymType; + strcpyW(miw.ModuleName, miw64.ModuleName); + strcpyW(miw.ImageName, miw64.ImageName); + strcpyW(miw.LoadedImageName, miw64.LoadedImageName); + memcpy(ModuleInfo, &miw, ModuleInfo->SizeOfStruct); + + return TRUE; +} + +/****************************************************************** + * SymGetModuleInfo64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetModuleInfo64(HANDLE hProcess, DWORD64 dwAddr, + PIMAGEHLP_MODULE64 ModuleInfo) +{ + IMAGEHLP_MODULE64 mi64; + IMAGEHLP_MODULEW64 miw64; + + if (sizeof(mi64) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n"); + + miw64.SizeOfStruct = sizeof(miw64); + if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE; + + mi64.SizeOfStruct = miw64.SizeOfStruct; + mi64.BaseOfImage = miw64.BaseOfImage; + mi64.ImageSize = miw64.ImageSize; + mi64.TimeDateStamp = miw64.TimeDateStamp; + mi64.CheckSum = miw64.CheckSum; + mi64.NumSyms = miw64.NumSyms; + mi64.SymType = miw64.SymType; + WideCharToMultiByte(CP_ACP, 0, miw64.ModuleName, -1, + mi64.ModuleName, sizeof(mi64.ModuleName), NULL, NULL); + WideCharToMultiByte(CP_ACP, 0, miw64.ImageName, -1, + mi64.ImageName, sizeof(mi64.ImageName), NULL, NULL); + WideCharToMultiByte(CP_ACP, 0, miw64.LoadedImageName, -1, + mi64.LoadedImageName, sizeof(mi64.LoadedImageName), NULL, NULL); + WideCharToMultiByte(CP_ACP, 0, miw64.LoadedPdbName, -1, + mi64.LoadedPdbName, sizeof(mi64.LoadedPdbName), NULL, NULL); + + mi64.CVSig = miw64.CVSig; + WideCharToMultiByte(CP_ACP, 0, miw64.CVData, -1, + mi64.CVData, sizeof(mi64.CVData), NULL, NULL); + mi64.PdbSig = miw64.PdbSig; + mi64.PdbSig70 = miw64.PdbSig70; + mi64.PdbAge = miw64.PdbAge; + mi64.PdbUnmatched = miw64.PdbUnmatched; + mi64.DbgUnmatched = miw64.DbgUnmatched; + mi64.LineNumbers = miw64.LineNumbers; + mi64.GlobalSymbols = miw64.GlobalSymbols; + mi64.TypeInfo = miw64.TypeInfo; + mi64.SourceIndexed = miw64.SourceIndexed; + mi64.Publics = miw64.Publics; + + memcpy(ModuleInfo, &mi64, ModuleInfo->SizeOfStruct); + + return TRUE; +} + +/****************************************************************** + * SymGetModuleInfoW64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr, + PIMAGEHLP_MODULEW64 ModuleInfo) +{ + struct process* pcs = process_find_by_handle(hProcess); + struct module* module; + IMAGEHLP_MODULEW64 miw64; + + TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo); + + if (!pcs) return FALSE; + if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE; + module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN); + if (!module) return FALSE; + + miw64 = module->module; + + /* update debug information from container if any */ + if (module->module.SymType == SymNone) + { + module = module_get_container(pcs, module); + if (module && module->module.SymType != SymNone) + { + miw64.SymType = module->module.SymType; + miw64.NumSyms = module->module.NumSyms; + } + } + memcpy(ModuleInfo, &miw64, ModuleInfo->SizeOfStruct); + return TRUE; +} + /*********************************************************************** - * SymGetModuleBase (IMAGEHLP.@) + * SymGetModuleBase (DBGHELP.@) */ DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr) { @@ -484,6 +983,15 @@ DWORD WINAPI SymGetModuleBase(HANDLE hProcess, DWORD dwAddr) return module->module.BaseOfImage; } +/*********************************************************************** + * SymGetModuleBase64 (DBGHELP.@) + */ +DWORD64 WINAPI SymGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr) +{ + if (!validate_addr64(dwAddr)) return 0; + return SymGetModuleBase(hProcess, (DWORD)dwAddr); +} + /****************************************************************** * module_reset_debug_info * Removes any debug information linked to a given module. diff --git a/reactos/dll/win32/dbghelp/msc.c b/reactos/dll/win32/dbghelp/msc.c index ea8bdc2d5a9..5e6f8a84bcf 100644 --- a/reactos/dll/win32/dbghelp/msc.c +++ b/reactos/dll/win32/dbghelp/msc.c @@ -4,7 +4,7 @@ * * Copyright (C) 1996, Eric Youngdale. * Copyright (C) 1999-2000, Ulrich Weigand. - * Copyright (C) 2004, Eric Pouech. + * Copyright (C) 2004-2006, Eric Pouech. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,9 +18,9 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ - + /* * Note - this handles reading debug information for 32 bit applications * that run under Windows-NT for example. I doubt that this would work well @@ -31,14 +31,14 @@ * Get 16 bit CV stuff working. * Add symbol size to internal symbol table. */ - + #include "config.h" #include "wine/port.h" - + #include #include #include - + #include #ifdef HAVE_UNISTD_H # include @@ -49,37 +49,28 @@ #include #include "windef.h" #include "winbase.h" -#include "winreg.h" #include "winternl.h" - -#include - + +#include "wine/exception.h" #include "wine/debug.h" #include "dbghelp_private.h" -#include "mscvpdb.h" - +#include "wine/mscvpdb.h" + WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_msc); - + #define MAX_PATHNAME_LEN 1024 - + /*======================================================================== * Debug file access helper routines */ - -static _SEH_FILTER(page_fault) -{ - if (_SEH_GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) - return _SEH_EXECUTE_HANDLER; - return _SEH_CONTINUE_SEARCH; -} - + static void dump(const void* ptr, unsigned len) { int i, j; - BYTE msg[128]; + char msg[128]; const char* hexof = "0123456789abcdef"; const BYTE* x = (const BYTE*)ptr; - + for (i = 0; i < len; i += 16) { sprintf(msg, "%08x: ", i); @@ -97,40 +88,27 @@ static void dump(const void* ptr, unsigned len) FIXME("%s\n", msg); } } - + /*======================================================================== * Process CodeView type information. */ - + #define MAX_BUILTIN_TYPES 0x0480 #define FIRST_DEFINABLE_TYPE 0x1000 - + static struct symt* cv_basic_types[MAX_BUILTIN_TYPES]; - -#define SymTagCVBitField (SymTagMax + 0x100) -struct codeview_bitfield -{ - struct symt symt; - unsigned subtype; - unsigned bitposition; - unsigned bitlength; -}; - + struct cv_defined_module { BOOL allowed; unsigned int num_defined_types; struct symt** defined_types; - - struct codeview_bitfield* bitfields; - unsigned num_bitfields; - unsigned used_bitfields; }; /* FIXME: don't make it static */ #define CV_MAX_MODULES 32 static struct cv_defined_module cv_zmodules[CV_MAX_MODULES]; static struct cv_defined_module*cv_current_module; - + static void codeview_init_basic_types(struct module* module) { /* @@ -153,7 +131,7 @@ static void codeview_init_basic_types(struct module* module) cv_basic_types[T_WCHAR] = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt; cv_basic_types[T_INT4] = &symt_new_basic(module, btInt, "INT4", 4)->symt; cv_basic_types[T_UINT4] = &symt_new_basic(module, btUInt, "UINT4", 4)->symt; - + cv_basic_types[T_32PVOID] = &symt_new_pointer(module, cv_basic_types[T_VOID])->symt; cv_basic_types[T_32PCHAR] = &symt_new_pointer(module, cv_basic_types[T_CHAR])->symt; cv_basic_types[T_32PSHORT] = &symt_new_pointer(module, cv_basic_types[T_SHORT])->symt; @@ -170,12 +148,12 @@ static void codeview_init_basic_types(struct module* module) cv_basic_types[T_32PINT4] = &symt_new_pointer(module, cv_basic_types[T_INT4])->symt; cv_basic_types[T_32PUINT4] = &symt_new_pointer(module, cv_basic_types[T_UINT4])->symt; } - + static int numeric_leaf(int* value, const unsigned short int* leaf) { unsigned short int type = *leaf++; int length = 2; - + if (type < LF_NUMERIC) { *value = type; @@ -188,121 +166,121 @@ static int numeric_leaf(int* value, const unsigned short int* leaf) length += 1; *value = *(const char*)leaf; break; - + case LF_SHORT: length += 2; *value = *(const short*)leaf; break; - + case LF_USHORT: length += 2; - *value = *(const unsigned short*)leaf; + *value = *leaf; break; - + case LF_LONG: length += 4; *value = *(const int*)leaf; break; - + case LF_ULONG: length += 4; *value = *(const unsigned int*)leaf; break; - + case LF_QUADWORD: case LF_UQUADWORD: FIXME("Unsupported numeric leaf type %04x\n", type); length += 8; *value = 0; /* FIXME */ break; - + case LF_REAL32: FIXME("Unsupported numeric leaf type %04x\n", type); length += 4; *value = 0; /* FIXME */ break; - + case LF_REAL48: FIXME("Unsupported numeric leaf type %04x\n", type); length += 6; *value = 0; /* FIXME */ break; - + case LF_REAL64: FIXME("Unsupported numeric leaf type %04x\n", type); length += 8; *value = 0; /* FIXME */ break; - + case LF_REAL80: FIXME("Unsupported numeric leaf type %04x\n", type); length += 10; *value = 0; /* FIXME */ break; - + case LF_REAL128: FIXME("Unsupported numeric leaf type %04x\n", type); length += 16; *value = 0; /* FIXME */ break; - + case LF_COMPLEX32: FIXME("Unsupported numeric leaf type %04x\n", type); length += 4; *value = 0; /* FIXME */ break; - + case LF_COMPLEX64: FIXME("Unsupported numeric leaf type %04x\n", type); length += 8; *value = 0; /* FIXME */ break; - + case LF_COMPLEX80: FIXME("Unsupported numeric leaf type %04x\n", type); length += 10; *value = 0; /* FIXME */ break; - + case LF_COMPLEX128: FIXME("Unsupported numeric leaf type %04x\n", type); length += 16; *value = 0; /* FIXME */ break; - + case LF_VARSTRING: FIXME("Unsupported numeric leaf type %04x\n", type); length += 2 + *leaf; *value = 0; /* FIXME */ break; - + default: FIXME("Unknown numeric leaf type %04x\n", type); *value = 0; break; } } - + return length; } - + /* convert a pascal string (as stored in debug information) into * a C string (null terminated). */ static const char* terminate_string(const struct p_string* p_name) { static char symname[256]; - + memcpy(symname, p_name->name, p_name->namelen); symname[p_name->namelen] = '\0'; - + return (!*symname || strcmp(symname, "__unnamed") == 0) ? NULL : symname; } - -static struct symt* codeview_get_type(unsigned int typeno, BOOL allow_special) + +static struct symt* codeview_get_type(unsigned int typeno, BOOL quiet) { struct symt* symt = NULL; - + /* * Convert Codeview type numbers into something we can grok internally. * Numbers < FIRST_DEFINABLE_TYPE are all fixed builtin types. @@ -318,9 +296,9 @@ static struct symt* codeview_get_type(unsigned int typeno, BOOL allow_special) unsigned mod_index = typeno >> 24; unsigned mod_typeno = typeno & 0x00FFFFFF; struct cv_defined_module* mod; - + mod = (mod_index == 0) ? cv_current_module : &cv_zmodules[mod_index]; - + if (mod_index >= CV_MAX_MODULES || !mod->allowed) FIXME("Module of index %d isn't loaded yet (%x)\n", mod_index, typeno); else @@ -329,12 +307,25 @@ static struct symt* codeview_get_type(unsigned int typeno, BOOL allow_special) symt = mod->defined_types[mod_typeno - FIRST_DEFINABLE_TYPE]; } } - if (!allow_special && symt && symt->tag == SymTagCVBitField) - FIXME("bitfields are only handled for UDTs\n"); - if (!symt && typeno) FIXME("Returning NULL symt for type-id %x\n", typeno); + if (!quiet && !symt && typeno) FIXME("Returning NULL symt for type-id %x\n", typeno); return symt; } - + +struct codeview_type_parse +{ + struct module* module; + const BYTE* table; + const DWORD* offset; + DWORD num; +}; + +static inline const void* codeview_jump_to_type(const struct codeview_type_parse* ctp, DWORD idx) +{ + if (idx < FIRST_DEFINABLE_TYPE) return NULL; + idx -= FIRST_DEFINABLE_TYPE; + return (idx >= ctp->num) ? NULL : (ctp->table + ctp->offset[idx]); +} + static int codeview_add_type(unsigned int typeno, struct symt* dt) { if (typeno < FIRST_DEFINABLE_TYPE) @@ -351,123 +342,133 @@ static int codeview_add_type(unsigned int typeno, struct symt* dt) { cv_current_module->num_defined_types += 0x100; if (cv_current_module->defined_types) - cv_current_module->defined_types = (struct symt**) - HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, - cv_current_module->defined_types, + cv_current_module->defined_types = HeapReAlloc(GetProcessHeap(), + HEAP_ZERO_MEMORY, cv_current_module->defined_types, cv_current_module->num_defined_types * sizeof(struct symt*)); else - cv_current_module->defined_types = (struct symt**) - HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, - cv_current_module->num_defined_types * sizeof(struct symt*)); - + cv_current_module->defined_types = HeapAlloc(GetProcessHeap(), + HEAP_ZERO_MEMORY, + cv_current_module->num_defined_types * sizeof(struct symt*)); + if (cv_current_module->defined_types == NULL) return FALSE; } - + if (cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE]) + { + if (cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE] != dt) + FIXME("Overwriting at %x\n", typeno); + } cv_current_module->defined_types[typeno - FIRST_DEFINABLE_TYPE] = dt; return TRUE; } - + static void codeview_clear_type_table(void) { int i; - + for (i = 0; i < CV_MAX_MODULES; i++) { - if (cv_zmodules[i].allowed && cv_zmodules[i].defined_types) + if (cv_zmodules[i].allowed) HeapFree(GetProcessHeap(), 0, cv_zmodules[i].defined_types); cv_zmodules[i].allowed = FALSE; cv_zmodules[i].defined_types = NULL; cv_zmodules[i].num_defined_types = 0; - if (cv_zmodules[i].bitfields) - HeapFree(GetProcessHeap(), 0, cv_zmodules[i].bitfields); - cv_zmodules[i].bitfields = NULL; - cv_zmodules[i].num_bitfields = cv_zmodules[i].used_bitfields = 0; } cv_current_module = NULL; } - -static int codeview_add_type_pointer(struct module* module, unsigned int typeno, - unsigned int datatype) + +static struct symt* codeview_parse_one_type(struct codeview_type_parse* ctp, + unsigned curr_type, + const union codeview_type* type, BOOL details); + +static void* codeview_cast_symt(struct symt* symt, enum SymTagEnum tag) { - struct symt* symt = &symt_new_pointer(module, - codeview_get_type(datatype, FALSE))->symt; - return codeview_add_type(typeno, symt); + if (symt->tag != tag) + { + FIXME("Bad tag. Expected %d, but got %d\n", tag, symt->tag); + return NULL; + } + return symt; } - -static int codeview_add_type_array(struct module* module, - unsigned int typeno, const char* name, - unsigned int elemtype, unsigned int arr_len) + +static struct symt* codeview_fetch_type(struct codeview_type_parse* ctp, + unsigned typeno) { - struct symt* symt; - struct symt* elem = codeview_get_type(elemtype, FALSE); + struct symt* symt; + const union codeview_type* p; + + if (!typeno) return NULL; + if ((symt = codeview_get_type(typeno, TRUE))) return symt; + + /* forward declaration */ + if (!(p = codeview_jump_to_type(ctp, typeno))) + { + FIXME("Cannot locate type %x\n", typeno); + return NULL; + } + symt = codeview_parse_one_type(ctp, typeno, p, FALSE); + if (!symt) FIXME("Couldn't load forward type %x\n", typeno); + return symt; +} + +static struct symt* codeview_add_type_pointer(struct codeview_type_parse* ctp, + struct symt* existing, + unsigned int pointee_type) +{ + struct symt* pointee; + + if (existing) + { + existing = codeview_cast_symt(existing, SymTagPointerType); + return existing; + } + pointee = codeview_fetch_type(ctp, pointee_type); + return &symt_new_pointer(ctp->module, pointee)->symt; +} + +static struct symt* codeview_add_type_array(struct codeview_type_parse* ctp, + const char* name, + unsigned int elemtype, + unsigned int indextype, + unsigned int arr_len) +{ + struct symt* elem = codeview_fetch_type(ctp, elemtype); + struct symt* index = codeview_fetch_type(ctp, indextype); DWORD arr_max = 0; - + if (elem) { - DWORD elem_size; + DWORD64 elem_size; symt_get_info(elem, TI_GET_LENGTH, &elem_size); - if (elem_size) arr_max = arr_len / elem_size; + if (elem_size) arr_max = arr_len / (DWORD)elem_size; } - symt = &symt_new_array(module, 0, arr_max, elem)->symt; - return codeview_add_type(typeno, symt); + return &symt_new_array(ctp->module, 0, arr_max, elem, index)->symt; } - -static int codeview_add_type_bitfield(unsigned int typeno, unsigned int bitoff, - unsigned int nbits, unsigned int basetype) + +static int codeview_add_type_enum_field_list(struct module* module, + struct symt_enum* symt, + const union codeview_reftype* ref_type) { - if (cv_current_module->used_bitfields >= cv_current_module->num_bitfields) + const unsigned char* ptr = ref_type->fieldlist.list; + const unsigned char* last = (const BYTE*)ref_type + ref_type->generic.len + 2; + const union codeview_fieldtype* type; + + while (ptr < last) { - if (cv_current_module->bitfields) - { - cv_current_module->num_bitfields *= 2; - cv_current_module->bitfields = - HeapReAlloc(GetProcessHeap(), 0, - cv_current_module->bitfields, - cv_current_module->num_bitfields * sizeof(struct codeview_bitfield)); - } - else - { - cv_current_module->num_bitfields = 64; - cv_current_module->bitfields = - HeapAlloc(GetProcessHeap(), 0, - cv_current_module->num_bitfields * sizeof(struct codeview_bitfield)); - } - if (!cv_current_module->bitfields) return 0; - } - - cv_current_module->bitfields[cv_current_module->used_bitfields].symt.tag = SymTagCVBitField; - cv_current_module->bitfields[cv_current_module->used_bitfields].subtype = basetype; - cv_current_module->bitfields[cv_current_module->used_bitfields].bitposition = bitoff; - cv_current_module->bitfields[cv_current_module->used_bitfields].bitlength = nbits; - - return codeview_add_type(typeno, &cv_current_module->bitfields[cv_current_module->used_bitfields++].symt); -} - -static int codeview_add_type_enum_field_list(struct module* module, - unsigned int typeno, - const unsigned char* list, int len) -{ - struct symt_enum* symt; - const unsigned char* ptr = list; - - symt = symt_new_enum(module, NULL); - while (ptr - list < len) - { - const union codeview_fieldtype* type = (const union codeview_fieldtype*)ptr; - if (*ptr >= 0xf0) /* LF_PAD... */ { ptr += *ptr & 0x0f; continue; } - + + type = (const union codeview_fieldtype*)ptr; + switch (type->generic.id) { case LF_ENUMERATE_V1: { int value, vlen = numeric_leaf(&value, &type->enumerate_v1.value); const struct p_string* p_name = (const struct p_string*)((const unsigned char*)&type->enumerate_v1.value + vlen); - + symt_add_enum_element(module, symt, terminate_string(p_name), value); ptr += 2 + 2 + vlen + (1 + p_name->namelen); break; @@ -476,198 +477,200 @@ static int codeview_add_type_enum_field_list(struct module* module, { int value, vlen = numeric_leaf(&value, &type->enumerate_v3.value); const char* name = (const char*)&type->enumerate_v3.value + vlen; - + symt_add_enum_element(module, symt, name, value); ptr += 2 + 2 + vlen + (1 + strlen(name)); break; } - + default: FIXME("Unsupported type %04x in ENUM field list\n", type->generic.id); return FALSE; } } - - return codeview_add_type(typeno, &symt->symt); + return TRUE; } - -static int codeview_add_type_struct_field_list(struct module* module, - unsigned int typeno, - const unsigned char* list, int len) + +static void codeview_add_udt_element(struct codeview_type_parse* ctp, + struct symt_udt* symt, const char* name, + int value, unsigned type) { - struct symt_udt* symt; - const unsigned char* ptr = list; - int value, leaf_len, vpoff, vplen; + struct symt* subtype; + const union codeview_reftype*cv_type; + + if ((cv_type = codeview_jump_to_type(ctp, type))) + { + switch (cv_type->generic.id) + { + case LF_BITFIELD_V1: + symt_add_udt_element(ctp->module, symt, name, + codeview_fetch_type(ctp, cv_type->bitfield_v1.type), + cv_type->bitfield_v1.bitoff, + cv_type->bitfield_v1.nbits); + return; + case LF_BITFIELD_V2: + symt_add_udt_element(ctp->module, symt, name, + codeview_fetch_type(ctp, cv_type->bitfield_v2.type), + cv_type->bitfield_v2.bitoff, + cv_type->bitfield_v2.nbits); + return; + } + } + subtype = codeview_fetch_type(ctp, type); + + if (subtype) + { + DWORD64 elem_size = 0; + symt_get_info(subtype, TI_GET_LENGTH, &elem_size); + symt_add_udt_element(ctp->module, symt, name, subtype, + value << 3, (DWORD)elem_size << 3); + } +} + +static int codeview_add_type_struct_field_list(struct codeview_type_parse* ctp, + struct symt_udt* symt, + unsigned fieldlistno) +{ + const unsigned char* ptr; + const unsigned char* last; + int value, leaf_len; const struct p_string* p_name; const char* c_name; - struct symt* subtype; - const unsigned short int* p_vboff; - - symt = symt_new_udt(module, NULL, 0, UdtStruct /* don't care */); - while (ptr - list < len) + const union codeview_reftype*type_ref; + const union codeview_fieldtype* type; + + if (!fieldlistno) return TRUE; + type_ref = codeview_jump_to_type(ctp, fieldlistno); + ptr = type_ref->fieldlist.list; + last = (const BYTE*)type_ref + type_ref->generic.len + 2; + + while (ptr < last) { - const union codeview_fieldtype* type = (const union codeview_fieldtype*)ptr; - if (*ptr >= 0xf0) /* LF_PAD... */ { - ptr +=* ptr & 0x0f; + ptr += *ptr & 0x0f; continue; } - + + type = (const union codeview_fieldtype*)ptr; + switch (type->generic.id) { case LF_BCLASS_V1: leaf_len = numeric_leaf(&value, &type->bclass_v1.offset); - + /* FIXME: ignored for now */ - + ptr += 2 + 2 + 2 + leaf_len; break; - + case LF_BCLASS_V2: leaf_len = numeric_leaf(&value, &type->bclass_v2.offset); - + /* FIXME: ignored for now */ - + ptr += 2 + 2 + 4 + leaf_len; break; - + case LF_VBCLASS_V1: case LF_IVBCLASS_V1: { + const unsigned short int* p_vboff; + int vpoff, vplen; leaf_len = numeric_leaf(&value, &type->vbclass_v1.vbpoff); p_vboff = (const unsigned short int*)((const char*)&type->vbclass_v1.vbpoff + leaf_len); vplen = numeric_leaf(&vpoff, p_vboff); - + /* FIXME: ignored for now */ - + ptr += 2 + 2 + 2 + 2 + leaf_len + vplen; } break; - + case LF_VBCLASS_V2: case LF_IVBCLASS_V2: { + const unsigned short int* p_vboff; + int vpoff, vplen; leaf_len = numeric_leaf(&value, &type->vbclass_v2.vbpoff); p_vboff = (const unsigned short int*)((const char*)&type->vbclass_v2.vbpoff + leaf_len); vplen = numeric_leaf(&vpoff, p_vboff); - + /* FIXME: ignored for now */ - + ptr += 2 + 2 + 4 + 4 + leaf_len + vplen; } break; - + case LF_MEMBER_V1: leaf_len = numeric_leaf(&value, &type->member_v1.offset); p_name = (const struct p_string*)((const char*)&type->member_v1.offset + leaf_len); - subtype = codeview_get_type(type->member_v1.type, TRUE); - - if (!subtype || subtype->tag != SymTagCVBitField) - { - DWORD elem_size = 0; - if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); - symt_add_udt_element(module, symt, terminate_string(p_name), - codeview_get_type(type->member_v1.type, TRUE), - value << 3, elem_size << 3); - } - else - { - struct codeview_bitfield* cvbf = (struct codeview_bitfield*)subtype; - symt_add_udt_element(module, symt, terminate_string(p_name), - codeview_get_type(cvbf->subtype, FALSE), - cvbf->bitposition, cvbf->bitlength); - } - + + codeview_add_udt_element(ctp, symt, terminate_string(p_name), value, + type->member_v1.type); + ptr += 2 + 2 + 2 + leaf_len + (1 + p_name->namelen); break; - + case LF_MEMBER_V2: leaf_len = numeric_leaf(&value, &type->member_v2.offset); p_name = (const struct p_string*)((const unsigned char*)&type->member_v2.offset + leaf_len); - subtype = codeview_get_type(type->member_v2.type, TRUE); - - if (!subtype || subtype->tag != SymTagCVBitField) - { - DWORD elem_size = 0; - if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); - symt_add_udt_element(module, symt, terminate_string(p_name), - subtype, value << 3, elem_size << 3); - } - else - { - struct codeview_bitfield* cvbf = (struct codeview_bitfield*)subtype; - symt_add_udt_element(module, symt, terminate_string(p_name), - codeview_get_type(cvbf->subtype, FALSE), - cvbf->bitposition, cvbf->bitlength); - } - + + codeview_add_udt_element(ctp, symt, terminate_string(p_name), value, + type->member_v2.type); + ptr += 2 + 2 + 4 + leaf_len + (1 + p_name->namelen); break; - + case LF_MEMBER_V3: leaf_len = numeric_leaf(&value, &type->member_v3.offset); c_name = (const char*)&type->member_v3.offset + leaf_len; - subtype = codeview_get_type(type->member_v3.type, TRUE); - - if (!subtype || subtype->tag != SymTagCVBitField) - { - DWORD elem_size = 0; - if (subtype) symt_get_info(subtype, TI_GET_LENGTH, &elem_size); - symt_add_udt_element(module, symt, c_name, - subtype, value << 3, elem_size << 3); - } - else - { - struct codeview_bitfield* cvbf = (struct codeview_bitfield*)subtype; - symt_add_udt_element(module, symt, c_name, - codeview_get_type(cvbf->subtype, FALSE), - cvbf->bitposition, cvbf->bitlength); - } - + + codeview_add_udt_element(ctp, symt, c_name, value, type->member_v3.type); + ptr += 2 + 2 + 4 + leaf_len + (strlen(c_name) + 1); break; - + case LF_STMEMBER_V1: /* FIXME: ignored for now */ ptr += 2 + 2 + 2 + (1 + type->stmember_v1.p_name.namelen); break; - + case LF_STMEMBER_V2: /* FIXME: ignored for now */ ptr += 2 + 4 + 2 + (1 + type->stmember_v2.p_name.namelen); break; - + case LF_METHOD_V1: /* FIXME: ignored for now */ ptr += 2 + 2 + 2 + (1 + type->method_v1.p_name.namelen); break; - + case LF_METHOD_V2: /* FIXME: ignored for now */ ptr += 2 + 2 + 4 + (1 + type->method_v2.p_name.namelen); break; - + case LF_NESTTYPE_V1: /* FIXME: ignored for now */ ptr += 2 + 2 + (1 + type->nesttype_v1.p_name.namelen); break; - + case LF_NESTTYPE_V2: /* FIXME: ignored for now */ ptr += 2 + 2 + 4 + (1 + type->nesttype_v2.p_name.namelen); break; - + case LF_VFUNCTAB_V1: /* FIXME: ignored for now */ ptr += 2 + 2; break; - + case LF_VFUNCTAB_V2: /* FIXME: ignored for now */ ptr += 2 + 2 + 4; break; - + case LF_ONEMETHOD_V1: /* FIXME: ignored for now */ switch ((type->onemethod_v1.attribute >> 2) & 7) @@ -675,13 +678,13 @@ static int codeview_add_type_struct_field_list(struct module* module, case 4: case 6: /* (pure) introducing virtual method */ ptr += 2 + 2 + 2 + 4 + (1 + type->onemethod_virt_v1.p_name.namelen); break; - + default: ptr += 2 + 2 + 2 + (1 + type->onemethod_v1.p_name.namelen); break; } break; - + case LF_ONEMETHOD_V2: /* FIXME: ignored for now */ switch ((type->onemethod_v2.attribute >> 2) & 7) @@ -689,286 +692,395 @@ static int codeview_add_type_struct_field_list(struct module* module, case 4: case 6: /* (pure) introducing virtual method */ ptr += 2 + 2 + 4 + 4 + (1 + type->onemethod_virt_v2.p_name.namelen); break; - + default: ptr += 2 + 2 + 4 + (1 + type->onemethod_v2.p_name.namelen); break; } break; - + default: FIXME("Unsupported type %04x in STRUCT field list\n", type->generic.id); return FALSE; } } - - return codeview_add_type(typeno, &symt->symt); + + return TRUE; } - -static int codeview_add_type_enum(struct module* module, unsigned int typeno, - const char* name, unsigned int fieldlist) + +static struct symt* codeview_add_type_enum(struct codeview_type_parse* ctp, + struct symt* existing, + const char* name, + unsigned fieldlistno) { - struct symt_enum* symt = symt_new_enum(module, name); - struct symt* list = codeview_get_type(fieldlist, FALSE); - - /* FIXME: this is rather ugly !!! */ - if (list) symt->vchildren = ((struct symt_enum*)list)->vchildren; - - return codeview_add_type(typeno, &symt->symt); + struct symt_enum* symt; + + if (existing) + { + if (!(symt = codeview_cast_symt(existing, SymTagEnum))) return NULL; + /* should also check that all fields are the same */ + } + else + { + symt = symt_new_enum(ctp->module, name); + if (fieldlistno) + { + const union codeview_reftype* fieldlist; + fieldlist = codeview_jump_to_type(ctp, fieldlistno); + codeview_add_type_enum_field_list(ctp->module, symt, fieldlist); + } + } + return &symt->symt; } - -static int codeview_add_type_struct(struct module* module, unsigned int typeno, - const char* name, int structlen, - unsigned int fieldlist, enum UdtKind kind) + +static struct symt* codeview_add_type_struct(struct codeview_type_parse* ctp, + struct symt* existing, + const char* name, int structlen, + enum UdtKind kind) { - struct symt_udt* symt = symt_new_udt(module, name, structlen, kind); - struct symt* list = codeview_get_type(fieldlist, FALSE); - - /* FIXME: this is rather ugly !!! */ - if (list) symt->vchildren = ((struct symt_udt*)list)->vchildren; - - return codeview_add_type(typeno, &symt->symt); + struct symt_udt* symt; + + if (existing) + { + if (!(symt = codeview_cast_symt(existing, SymTagUDT))) return NULL; + /* should also check that all fields are the same */ + } + else symt = symt_new_udt(ctp->module, name, structlen, kind); + + return &symt->symt; } - -static int codeview_new_func_signature(struct module* module, unsigned typeno, - unsigned ret_type) + +static struct symt* codeview_new_func_signature(struct codeview_type_parse* ctp, + struct symt* existing, + enum CV_call_e call_conv) { - struct symt* symt; - symt = &symt_new_function_signature(module, - codeview_get_type(ret_type, FALSE))->symt; - return codeview_add_type(typeno, symt); + struct symt_function_signature* sym; + + if (existing) + { + sym = codeview_cast_symt(existing, SymTagFunctionType); + if (!sym) return NULL; + } + else + { + sym = symt_new_function_signature(ctp->module, NULL, call_conv); + } + return &sym->symt; } - -static int codeview_parse_type_table(struct module* module, const char* table, - int len) + +static void codeview_add_func_signature_args(struct codeview_type_parse* ctp, + struct symt_function_signature* sym, + unsigned ret_type, + unsigned args_list) { - unsigned int curr_type = 0x1000; - const char* ptr = table; - int retv; - const union codeview_type* type; + const union codeview_reftype* reftype; + + sym->rettype = codeview_fetch_type(ctp, ret_type); + if (args_list && (reftype = codeview_jump_to_type(ctp, args_list))) + { + int i; + switch (reftype->generic.id) + { + case LF_ARGLIST_V1: + for (i = 0; i < reftype->arglist_v1.num; i++) + symt_add_function_signature_parameter(ctp->module, sym, + codeview_fetch_type(ctp, reftype->arglist_v1.args[i])); + break; + case LF_ARGLIST_V2: + for (i = 0; i < reftype->arglist_v2.num; i++) + symt_add_function_signature_parameter(ctp->module, sym, + codeview_fetch_type(ctp, reftype->arglist_v2.args[i])); + break; + default: + FIXME("Unexpected leaf %x for signature's pmt\n", reftype->generic.id); + } + } +} + +static struct symt* codeview_parse_one_type(struct codeview_type_parse* ctp, + unsigned curr_type, + const union codeview_type* type, BOOL details) +{ + struct symt* symt; int value, leaf_len; const struct p_string* p_name; const char* c_name; - - while (ptr - table < len) + struct symt* existing; + + existing = codeview_get_type(curr_type, TRUE); + + switch (type->generic.id) { - retv = TRUE; - type = (const union codeview_type*)ptr; - - switch (type->generic.id) + case LF_MODIFIER_V1: + /* FIXME: we don't handle modifiers, + * but readd previous type on the curr_type + */ + WARN("Modifier on %x: %s%s%s%s\n", + type->modifier_v1.type, + type->modifier_v1.attribute & 0x01 ? "const " : "", + type->modifier_v1.attribute & 0x02 ? "volatile " : "", + type->modifier_v1.attribute & 0x04 ? "unaligned " : "", + type->modifier_v1.attribute & ~0x07 ? "unknown " : ""); + if (!(symt = codeview_get_type(type->modifier_v1.type, TRUE))) + symt = codeview_parse_one_type(ctp, type->modifier_v1.type, + codeview_jump_to_type(ctp, type->modifier_v1.type), details); + break; + case LF_MODIFIER_V2: + /* FIXME: we don't handle modifiers, but readd previous type on the curr_type */ + WARN("Modifier on %x: %s%s%s%s\n", + type->modifier_v2.type, + type->modifier_v2.attribute & 0x01 ? "const " : "", + type->modifier_v2.attribute & 0x02 ? "volatile " : "", + type->modifier_v2.attribute & 0x04 ? "unaligned " : "", + type->modifier_v2.attribute & ~0x07 ? "unknown " : ""); + if (!(symt = codeview_get_type(type->modifier_v2.type, TRUE))) + symt = codeview_parse_one_type(ctp, type->modifier_v2.type, + codeview_jump_to_type(ctp, type->modifier_v2.type), details); + break; + + case LF_POINTER_V1: + symt = codeview_add_type_pointer(ctp, existing, type->pointer_v1.datatype); + break; + case LF_POINTER_V2: + symt = codeview_add_type_pointer(ctp, existing, type->pointer_v2.datatype); + break; + + case LF_ARRAY_V1: + if (existing) symt = codeview_cast_symt(existing, SymTagArrayType); + else { - case LF_MODIFIER_V1: - /* FIXME: we don't handle modifiers, - * but readd previous type on the curr_type - */ - WARN("Modifier on %x: %s%s%s%s\n", - type->modifier_v1.type, - type->modifier_v1.attribute & 0x01 ? "const " : "", - type->modifier_v1.attribute & 0x02 ? "volatile " : "", - type->modifier_v1.attribute & 0x04 ? "unaligned " : "", - type->modifier_v1.attribute & ~0x07 ? "unknown " : ""); - codeview_add_type(curr_type, - codeview_get_type(type->modifier_v1.type, FALSE)); - break; - case LF_MODIFIER_V2: - /* FIXME: we don't handle modifiers, but readd previous type on the curr_type */ - WARN("Modifier on %x: %s%s%s%s\n", - type->modifier_v2.type, - type->modifier_v2.attribute & 0x01 ? "const " : "", - type->modifier_v2.attribute & 0x02 ? "volatile " : "", - type->modifier_v2.attribute & 0x04 ? "unaligned " : "", - type->modifier_v2.attribute & ~0x07 ? "unknown " : ""); - codeview_add_type(curr_type, - codeview_get_type(type->modifier_v2.type, FALSE)); - break; - - case LF_POINTER_V1: - retv = codeview_add_type_pointer(module, curr_type, - type->pointer_v1.datatype); - break; - case LF_POINTER_V2: - retv = codeview_add_type_pointer(module, curr_type, - type->pointer_v2.datatype); - break; - - case LF_ARRAY_V1: leaf_len = numeric_leaf(&value, &type->array_v1.arrlen); p_name = (const struct p_string*)((const unsigned char*)&type->array_v1.arrlen + leaf_len); - - retv = codeview_add_type_array(module, curr_type, terminate_string(p_name), - type->array_v1.elemtype, value); - break; - case LF_ARRAY_V2: + symt = codeview_add_type_array(ctp, terminate_string(p_name), + type->array_v1.elemtype, + type->array_v1.idxtype, value); + } + break; + case LF_ARRAY_V2: + if (existing) symt = codeview_cast_symt(existing, SymTagArrayType); + else + { leaf_len = numeric_leaf(&value, &type->array_v2.arrlen); p_name = (const struct p_string*)((const unsigned char*)&type->array_v2.arrlen + leaf_len); - - retv = codeview_add_type_array(module, curr_type, terminate_string(p_name), - type->array_v2.elemtype, value); - break; - case LF_ARRAY_V3: + + symt = codeview_add_type_array(ctp, terminate_string(p_name), + type->array_v2.elemtype, + type->array_v2.idxtype, value); + } + break; + case LF_ARRAY_V3: + if (existing) symt = codeview_cast_symt(existing, SymTagArrayType); + else + { leaf_len = numeric_leaf(&value, &type->array_v3.arrlen); c_name = (const char*)&type->array_v3.arrlen + leaf_len; - - retv = codeview_add_type_array(module, curr_type, c_name, - type->array_v3.elemtype, value); - break; - - case LF_BITFIELD_V1: - /* a bitfield is a CodeView specific data type which represent a bitfield - * in a structure or a class. For now, we store it in a SymTag-like type - * (so that the rest of the process is seamless), but check at udt - * inclusion type for its presence - */ - retv = codeview_add_type_bitfield(curr_type, type->bitfield_v1.bitoff, - type->bitfield_v1.nbits, - type->bitfield_v1.type); - break; - case LF_BITFIELD_V2: - retv = codeview_add_type_bitfield(curr_type, type->bitfield_v2.bitoff, - type->bitfield_v2.nbits, - type->bitfield_v2.type); - break; - case LF_FIELDLIST_V1: - case LF_FIELDLIST_V2: - { - /* - * A 'field list' is a CodeView-specific data type which doesn't - * directly correspond to any high-level data type. It is used - * to hold the collection of members of a struct, class, union - * or enum type. The actual definition of that type will follow - * later, and refer to the field list definition record. - * - * As we don't have a field list type ourselves, we look ahead - * in the field list to try to find out whether this field list - * will be used for an enum or struct type, and create a dummy - * type of the corresponding sort. Later on, the definition of - * the 'real' type will copy the member / enumeration data. - */ - const char* list = type->fieldlist.list; - int len = (ptr + type->generic.len + 2) - list; - - if (((const union codeview_fieldtype*)list)->generic.id == LF_ENUMERATE_V1 || - ((const union codeview_fieldtype*)list)->generic.id == LF_ENUMERATE_V3) - retv = codeview_add_type_enum_field_list(module, curr_type, list, len); - else - retv = codeview_add_type_struct_field_list(module, curr_type, list, len); - } - break; - - case LF_STRUCTURE_V1: - case LF_CLASS_V1: - leaf_len = numeric_leaf(&value, &type->struct_v1.structlen); - p_name = (const struct p_string*)((const unsigned char*)&type->struct_v1.structlen + leaf_len); - - retv = codeview_add_type_struct(module, curr_type, terminate_string(p_name), - value, type->struct_v1.fieldlist, - type->generic.id == LF_CLASS_V1 ? UdtClass : UdtStruct); - break; - - case LF_STRUCTURE_V2: - case LF_CLASS_V2: - leaf_len = numeric_leaf(&value, &type->struct_v2.structlen); - p_name = (const struct p_string*)((const unsigned char*)&type->struct_v2.structlen + leaf_len); - - retv = codeview_add_type_struct(module, curr_type, terminate_string(p_name), - value, type->struct_v2.fieldlist, - type->generic.id == LF_CLASS_V2 ? UdtClass : UdtStruct); - break; - - case LF_STRUCTURE_V3: - case LF_CLASS_V3: - leaf_len = numeric_leaf(&value, &type->struct_v3.structlen); - c_name = (const char*)&type->struct_v3.structlen + leaf_len; - - retv = codeview_add_type_struct(module, curr_type, c_name, - value, type->struct_v3.fieldlist, - type->generic.id == LF_CLASS_V3 ? UdtClass : UdtStruct); - break; - - case LF_UNION_V1: - leaf_len = numeric_leaf(&value, &type->union_v1.un_len); - p_name = (const struct p_string*)((const unsigned char*)&type->union_v1.un_len + leaf_len); - - retv = codeview_add_type_struct(module, curr_type, terminate_string(p_name), - value, type->union_v1.fieldlist, UdtUnion); - break; - case LF_UNION_V2: - leaf_len = numeric_leaf(&value, &type->union_v2.un_len); - p_name = (const struct p_string*)((const unsigned char*)&type->union_v2.un_len + leaf_len); - - retv = codeview_add_type_struct(module, curr_type, terminate_string(p_name), - value, type->union_v2.fieldlist, UdtUnion); - break; - case LF_UNION_V3: - leaf_len = numeric_leaf(&value, &type->union_v3.un_len); - c_name = (const char*)&type->union_v3.un_len + leaf_len; - - retv = codeview_add_type_struct(module, curr_type, c_name, - value, type->union_v3.fieldlist, UdtUnion); - - case LF_ENUM_V1: - retv = codeview_add_type_enum(module, curr_type, terminate_string(&type->enumeration_v1.p_name), - type->enumeration_v1.field); - break; - - case LF_ENUM_V2: - retv = codeview_add_type_enum(module, curr_type, terminate_string(&type->enumeration_v2.p_name), - type->enumeration_v2.field); - break; - case LF_ENUM_V3: - retv = codeview_add_type_enum(module, curr_type, type->enumeration_v3.name, - type->enumeration_v3.field); - break; - case LF_PROCEDURE_V1: - retv = codeview_new_func_signature(module, curr_type, - type->procedure_v1.rvtype); - break; - case LF_PROCEDURE_V2: - retv = codeview_new_func_signature(module, curr_type, - type->procedure_v2.rvtype); - break; - case LF_MFUNCTION_V1: - /* FIXME: for C++, this is plain wrong, but as we don't use arg types - * nor class information, this would just do for now - */ - retv = codeview_new_func_signature(module, curr_type, - type->mfunction_v1.rvtype); - break; - case LF_MFUNCTION_V2: - /* FIXME: for C++, this is plain wrong, but as we don't use arg types - * nor class information, this would just do for now - */ - retv = codeview_new_func_signature(module, curr_type, - type->mfunction_v2.rvtype); - break; - case LF_ARGLIST_V1: - case LF_ARGLIST_V2: - { - static int once; - if (!once++) - FIXME("Not adding parameters' types to function signature\n"); - } - break; - - default: - FIXME("Unsupported type-id leaf %x\n", type->generic.id); - dump(type, 2 + type->generic.len); - break; + + symt = codeview_add_type_array(ctp, c_name, + type->array_v3.elemtype, + type->array_v3.idxtype, value); } - if (!retv) return FALSE; - curr_type++; - ptr += type->generic.len + 2; + break; + + case LF_STRUCTURE_V1: + case LF_CLASS_V1: + leaf_len = numeric_leaf(&value, &type->struct_v1.structlen); + p_name = (const struct p_string*)((const unsigned char*)&type->struct_v1.structlen + leaf_len); + symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), value, + type->generic.id == LF_CLASS_V1 ? UdtClass : UdtStruct); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->struct_v1.fieldlist); + } + break; + + case LF_STRUCTURE_V2: + case LF_CLASS_V2: + leaf_len = numeric_leaf(&value, &type->struct_v2.structlen); + p_name = (const struct p_string*)((const unsigned char*)&type->struct_v2.structlen + leaf_len); + symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), value, + type->generic.id == LF_CLASS_V2 ? UdtClass : UdtStruct); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->struct_v2.fieldlist); + } + break; + + case LF_STRUCTURE_V3: + case LF_CLASS_V3: + leaf_len = numeric_leaf(&value, &type->struct_v3.structlen); + c_name = (const char*)&type->struct_v3.structlen + leaf_len; + symt = codeview_add_type_struct(ctp, existing, c_name, value, + type->generic.id == LF_CLASS_V3 ? UdtClass : UdtStruct); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->struct_v3.fieldlist); + } + break; + + case LF_UNION_V1: + leaf_len = numeric_leaf(&value, &type->union_v1.un_len); + p_name = (const struct p_string*)((const unsigned char*)&type->union_v1.un_len + leaf_len); + symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), + value, UdtUnion); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->union_v1.fieldlist); + } + break; + + case LF_UNION_V2: + leaf_len = numeric_leaf(&value, &type->union_v2.un_len); + p_name = (const struct p_string*)((const unsigned char*)&type->union_v2.un_len + leaf_len); + symt = codeview_add_type_struct(ctp, existing, terminate_string(p_name), + value, UdtUnion); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->union_v2.fieldlist); + } + break; + + case LF_UNION_V3: + leaf_len = numeric_leaf(&value, &type->union_v3.un_len); + c_name = (const char*)&type->union_v3.un_len + leaf_len; + symt = codeview_add_type_struct(ctp, existing, c_name, + value, UdtUnion); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_type_struct_field_list(ctp, (struct symt_udt*)symt, + type->union_v3.fieldlist); + } + break; + + case LF_ENUM_V1: + symt = codeview_add_type_enum(ctp, existing, + terminate_string(&type->enumeration_v1.p_name), + type->enumeration_v1.fieldlist); + break; + + case LF_ENUM_V2: + symt = codeview_add_type_enum(ctp, existing, + terminate_string(&type->enumeration_v2.p_name), + type->enumeration_v2.fieldlist); + break; + + case LF_ENUM_V3: + symt = codeview_add_type_enum(ctp, existing, type->enumeration_v3.name, + type->enumeration_v3.fieldlist); + break; + + case LF_PROCEDURE_V1: + symt = codeview_new_func_signature(ctp, existing, type->procedure_v1.call); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_func_signature_args(ctp, + (struct symt_function_signature*)symt, + type->procedure_v1.rvtype, + type->procedure_v1.arglist); + } + break; + case LF_PROCEDURE_V2: + symt = codeview_new_func_signature(ctp, existing,type->procedure_v2.call); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_func_signature_args(ctp, + (struct symt_function_signature*)symt, + type->procedure_v2.rvtype, + type->procedure_v2.arglist); + } + break; + + case LF_MFUNCTION_V1: + /* FIXME: for C++, this is plain wrong, but as we don't use arg types + * nor class information, this would just do for now + */ + symt = codeview_new_func_signature(ctp, existing, type->mfunction_v1.call); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_func_signature_args(ctp, + (struct symt_function_signature*)symt, + type->mfunction_v1.rvtype, + type->mfunction_v1.arglist); + } + break; + case LF_MFUNCTION_V2: + /* FIXME: for C++, this is plain wrong, but as we don't use arg types + * nor class information, this would just do for now + */ + symt = codeview_new_func_signature(ctp, existing, type->mfunction_v2.call); + if (details) + { + codeview_add_type(curr_type, symt); + codeview_add_func_signature_args(ctp, + (struct symt_function_signature*)symt, + type->mfunction_v2.rvtype, + type->mfunction_v2.arglist); + } + break; + + case LF_VTSHAPE_V1: + /* this is an ugly hack... FIXME when we have C++ support */ + if (!(symt = existing)) + { + char buf[128]; + snprintf(buf, sizeof(buf), "__internal_vt_shape_%x\n", curr_type); + symt = &symt_new_udt(ctp->module, buf, 0, UdtStruct)->symt; + } + break; + default: + FIXME("Unsupported type-id leaf %x\n", type->generic.id); + dump(type, 2 + type->generic.len); + return FALSE; } - + return codeview_add_type(curr_type, symt) ? symt : NULL; +} + +static int codeview_parse_type_table(struct codeview_type_parse* ctp) +{ + unsigned int curr_type = FIRST_DEFINABLE_TYPE; + const union codeview_type* type; + + for (curr_type = FIRST_DEFINABLE_TYPE; curr_type < FIRST_DEFINABLE_TYPE + ctp->num; curr_type++) + { + type = codeview_jump_to_type(ctp, curr_type); + + /* type records we're interested in are the ones referenced by symbols + * The known ranges are (X mark the ones we want): + * X 0000-0016 for V1 types + * 0200-020c for V1 types referenced by other types + * 0400-040f for V1 types (complex lists & sets) + * X 1000-100f for V2 types + * 1200-120c for V2 types referenced by other types + * 1400-140f for V1 types (complex lists & sets) + * X 1500-150d for V3 types + * 8000-8010 for numeric leafes + */ + if (type->generic.id & 0x8600) continue; + codeview_parse_one_type(ctp, curr_type, type, TRUE); + } + return TRUE; } - + /*======================================================================== * Process CodeView line number information. */ - + static struct codeview_linetab* codeview_snarf_linetab(struct module* module, - const char* linetab, int size, + const BYTE* linetab, int size, BOOL pascal_str) { int file_segcount; @@ -985,59 +1097,59 @@ static struct codeview_linetab* codeview_snarf_linetab(struct module* module, union any_size pnt2; const struct startend* start; int this_seg; - struct symt_compiland* compiland; - + unsigned source; + /* * Now get the important bits. */ - pnt.c = linetab; + pnt.uc = linetab; nfile = *pnt.s++; nseg = *pnt.s++; - + filetab = (const unsigned int*) pnt.c; - + /* * Now count up the number of segments in the file. */ nseg = 0; for (i = 0; i < nfile; i++) { - pnt2.c = linetab + filetab[i]; + pnt2.uc = linetab + filetab[i]; nseg += *pnt2.s; } - + /* * Next allocate the header we will be returning. * There is one header for each segment, so that we can reach in * and pull bits as required. */ - lt_hdr = (struct codeview_linetab*) - HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (nseg + 1) * sizeof(*lt_hdr)); + lt_hdr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + (nseg + 1) * sizeof(*lt_hdr)); if (lt_hdr == NULL) { goto leave; } - + /* * Now fill the header we will be returning, one for each segment. * Note that this will basically just contain pointers into the existing * line table, and we do not actually copy any additional information * or allocate any additional memory. */ - + this_seg = 0; for (i = 0; i < nfile; i++) { /* * Get the pointer into the segment information. */ - pnt2.c = linetab + filetab[i]; + pnt2.uc = linetab + filetab[i]; file_segcount = *pnt2.s; - + pnt2.ui++; lt_ptr = (const unsigned int*) pnt2.c; start = (const struct startend*)(lt_ptr + file_segcount); - + /* * Now snarf the filename for all of the segments for this file. */ @@ -1046,51 +1158,51 @@ static struct codeview_linetab* codeview_snarf_linetab(struct module* module, p_fn = (const struct p_string*)(start + file_segcount); memset(filename, 0, sizeof(filename)); memcpy(filename, p_fn->name, p_fn->namelen); - compiland = symt_new_compiland(module, filename); + source = source_new(module, NULL, filename); } else - compiland = symt_new_compiland(module, (const char*)(start + file_segcount)); - + source = source_new(module, NULL, (const char*)(start + file_segcount)); + for (k = 0; k < file_segcount; k++, this_seg++) { - pnt2.c = linetab + lt_ptr[k]; + pnt2.uc = linetab + lt_ptr[k]; lt_hdr[this_seg].start = start[k].start; lt_hdr[this_seg].end = start[k].end; - lt_hdr[this_seg].compiland = compiland; + lt_hdr[this_seg].source = source; lt_hdr[this_seg].segno = *pnt2.s++; lt_hdr[this_seg].nline = *pnt2.s++; lt_hdr[this_seg].offtab = pnt2.ui; lt_hdr[this_seg].linetab = (const unsigned short*)(pnt2.ui + lt_hdr[this_seg].nline); } } - + leave: - + return lt_hdr; - + } - + /*======================================================================== * Process CodeView symbol information. */ - + static unsigned int codeview_map_offset(const struct msc_debug_info* msc_dbg, unsigned int offset) { int nomap = msc_dbg->nomap; const OMAP_DATA* omapp = msc_dbg->omapp; int i; - + if (!nomap || !omapp) return offset; - + /* FIXME: use binary search */ for (i = 0; i < nomap - 1; i++) if (omapp[i].from <= offset && omapp[i+1].from > offset) return !omapp[i].to ? 0 : omapp[i].to + (offset - omapp[i].from); - + return 0; } - + static const struct codeview_linetab* codeview_get_linetab(const struct codeview_linetab* linetab, unsigned seg, unsigned offset) @@ -1108,36 +1220,36 @@ codeview_get_linetab(const struct codeview_linetab* linetab, } return linetab; } - + static unsigned codeview_get_address(const struct msc_debug_info* msc_dbg, unsigned seg, unsigned offset) { int nsect = msc_dbg->nsect; const IMAGE_SECTION_HEADER* sectp = msc_dbg->sectp; - + if (!seg || seg > nsect) return 0; return msc_dbg->module->module.BaseOfImage + codeview_map_offset(msc_dbg, sectp[seg-1].VirtualAddress + offset); } - + static void codeview_add_func_linenum(struct module* module, struct symt_function* func, const struct codeview_linetab* linetab, unsigned offset, unsigned size) { unsigned int i; - + if (!linetab) return; for (i = 0; i < linetab->nline; i++) { if (linetab->offtab[i] >= offset && linetab->offtab[i] < offset + size) { - symt_add_func_line(module, func, linetab->compiland->source, + symt_add_func_line(module, func, linetab->source, linetab->linetab[i], linetab->offtab[i] - offset); } } } - + static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root, int offset, int size, struct codeview_linetab* linetab) @@ -1148,7 +1260,9 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root struct symt_block* block = NULL; struct symt* symt; const char* name; - + struct symt_compiland* compiland = NULL; + struct location loc; + /* * Loop over the different types of records and whenever we * find something we are interested in, record it and move on. @@ -1157,8 +1271,9 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root { const union codeview_symbol* sym = (const union codeview_symbol*)(root + i); length = sym->generic.len + 2; - if (length & 3) FIXME("unpadded len %u\n", length + 2); - + if (i + length > size) break; + if (length & 3) FIXME("unpadded len %u\n", length); + switch (sym->generic.id) { /* @@ -1167,9 +1282,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root */ case S_GDATA_V1: case S_LDATA_V1: - flt = codeview_get_linetab(linetab, sym->data_v1.segment, sym->data_v1.offset); - symt_new_global_variable(msc_dbg->module, - flt ? flt->compiland : NULL, + symt_new_global_variable(msc_dbg->module, compiland, terminate_string(&sym->data_v1.p_name), sym->generic.id == S_LDATA_V1, codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset), 0, @@ -1177,10 +1290,9 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root break; case S_GDATA_V2: case S_LDATA_V2: - flt = codeview_get_linetab(linetab, sym->data_v2.segment, sym->data_v2.offset); name = terminate_string(&sym->data_v2.p_name); if (name) - symt_new_global_variable(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_global_variable(msc_dbg->module, compiland, name, sym->generic.id == S_LDATA_V2, codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset), 0, @@ -1188,57 +1300,52 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root break; case S_GDATA_V3: case S_LDATA_V3: - flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset); if (*sym->data_v3.name) - symt_new_global_variable(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_global_variable(msc_dbg->module, compiland, sym->data_v3.name, sym->generic.id == S_LDATA_V3, codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), 0, codeview_get_type(sym->data_v3.symtype, FALSE)); break; - + case S_PUB_V1: /* FIXME is this really a 'data_v1' structure ?? */ if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) { - flt = codeview_get_linetab(linetab, sym->data_v1.segment, sym->data_v1.offset); - symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_public(msc_dbg->module, compiland, terminate_string(&sym->data_v1.p_name), codeview_get_address(msc_dbg, sym->data_v1.segment, sym->data_v1.offset), - 0, TRUE /* FIXME */, TRUE /* FIXME */); + 1, TRUE /* FIXME */, TRUE /* FIXME */); } break; case S_PUB_V2: /* FIXME is this really a 'data_v2' structure ?? */ if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) { - flt = codeview_get_linetab(linetab, sym->data_v2.segment, sym->data_v2.offset); - symt_new_public(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_public(msc_dbg->module, compiland, terminate_string(&sym->data_v2.p_name), codeview_get_address(msc_dbg, sym->data_v2.segment, sym->data_v2.offset), - 0, TRUE /* FIXME */, TRUE /* FIXME */); + 1, TRUE /* FIXME */, TRUE /* FIXME */); } break; - + /* * Sort of like a global function, but it just points * to a thunk, which is a stupid name for what amounts to * a PLT slot in the normal jargon that everyone else uses. */ case S_THUNK_V1: - flt = codeview_get_linetab(linetab, sym->thunk_v1.segment, sym->thunk_v1.offset); - symt_new_thunk(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_thunk(msc_dbg->module, compiland, terminate_string(&sym->thunk_v1.p_name), sym->thunk_v1.thtype, codeview_get_address(msc_dbg, sym->thunk_v1.segment, sym->thunk_v1.offset), sym->thunk_v1.thunk_len); break; case S_THUNK_V3: - flt = codeview_get_linetab(linetab, sym->thunk_v3.segment, sym->thunk_v3.offset); - symt_new_thunk(msc_dbg->module, flt ? flt->compiland : NULL, + symt_new_thunk(msc_dbg->module, compiland, sym->thunk_v3.name, sym->thunk_v3.thtype, codeview_get_address(msc_dbg, sym->thunk_v3.segment, sym->thunk_v3.offset), sym->thunk_v3.thunk_len); break; - + /* * Global and static functions. */ @@ -1246,77 +1353,106 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root case S_LPROC_V1: flt = codeview_get_linetab(linetab, sym->proc_v1.segment, sym->proc_v1.offset); if (curr_func) FIXME("nested function\n"); - curr_func = symt_new_function(msc_dbg->module, - flt ? flt->compiland : NULL, + curr_func = symt_new_function(msc_dbg->module, compiland, terminate_string(&sym->proc_v1.p_name), codeview_get_address(msc_dbg, sym->proc_v1.segment, sym->proc_v1.offset), sym->proc_v1.proc_len, codeview_get_type(sym->proc_v1.proctype, FALSE)); codeview_add_func_linenum(msc_dbg->module, curr_func, flt, sym->proc_v1.offset, sym->proc_v1.proc_len); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v1.debug_start, NULL); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v1.debug_end, NULL); + loc.kind = loc_absolute; + loc.offset = sym->proc_v1.debug_start; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, &loc, NULL); + loc.offset = sym->proc_v1.debug_end; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, &loc, NULL); break; case S_GPROC_V2: case S_LPROC_V2: flt = codeview_get_linetab(linetab, sym->proc_v2.segment, sym->proc_v2.offset); if (curr_func) FIXME("nested function\n"); - curr_func = symt_new_function(msc_dbg->module, - flt ? flt->compiland : NULL, + curr_func = symt_new_function(msc_dbg->module, compiland, terminate_string(&sym->proc_v2.p_name), codeview_get_address(msc_dbg, sym->proc_v2.segment, sym->proc_v2.offset), sym->proc_v2.proc_len, codeview_get_type(sym->proc_v2.proctype, FALSE)); codeview_add_func_linenum(msc_dbg->module, curr_func, flt, sym->proc_v2.offset, sym->proc_v2.proc_len); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v2.debug_start, NULL); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v2.debug_end, NULL); + loc.kind = loc_absolute; + loc.offset = sym->proc_v2.debug_start; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, &loc, NULL); + loc.offset = sym->proc_v2.debug_end; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, &loc, NULL); break; case S_GPROC_V3: case S_LPROC_V3: flt = codeview_get_linetab(linetab, sym->proc_v3.segment, sym->proc_v3.offset); if (curr_func) FIXME("nested function\n"); - curr_func = symt_new_function(msc_dbg->module, - flt ? flt->compiland : NULL, + curr_func = symt_new_function(msc_dbg->module, compiland, sym->proc_v3.name, codeview_get_address(msc_dbg, sym->proc_v3.segment, sym->proc_v3.offset), sym->proc_v3.proc_len, codeview_get_type(sym->proc_v3.proctype, FALSE)); codeview_add_func_linenum(msc_dbg->module, curr_func, flt, sym->proc_v3.offset, sym->proc_v3.proc_len); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, sym->proc_v3.debug_start, NULL); - symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, sym->proc_v3.debug_end, NULL); + loc.kind = loc_absolute; + loc.offset = sym->proc_v3.debug_start; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugStart, &loc, NULL); + loc.offset = sym->proc_v3.debug_end; + symt_add_function_point(msc_dbg->module, curr_func, SymTagFuncDebugEnd, &loc, NULL); break; /* * Function parameters and stack variables. */ case S_BPREL_V1: - symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v1.offset, - block, codeview_get_type(sym->stack_v1.symtype, FALSE), + loc.kind = loc_regrel; + loc.reg = 0; /* FIXME */ + loc.offset = sym->stack_v1.offset; + symt_add_func_local(msc_dbg->module, curr_func, + sym->stack_v1.offset > 0 ? DataIsParam : DataIsLocal, + &loc, block, + codeview_get_type(sym->stack_v1.symtype, FALSE), terminate_string(&sym->stack_v1.p_name)); break; case S_BPREL_V2: - symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v2.offset, - block, codeview_get_type(sym->stack_v2.symtype, FALSE), + loc.kind = loc_regrel; + loc.reg = 0; /* FIXME */ + loc.offset = sym->stack_v2.offset; + symt_add_func_local(msc_dbg->module, curr_func, + sym->stack_v2.offset > 0 ? DataIsParam : DataIsLocal, + &loc, block, + codeview_get_type(sym->stack_v2.symtype, FALSE), terminate_string(&sym->stack_v2.p_name)); break; case S_BPREL_V3: - symt_add_func_local(msc_dbg->module, curr_func, 0, sym->stack_v3.offset, - block, codeview_get_type(sym->stack_v3.symtype, FALSE), + loc.kind = loc_regrel; + loc.reg = 0; /* FIXME */ + loc.offset = sym->stack_v3.offset; + symt_add_func_local(msc_dbg->module, curr_func, + sym->stack_v3.offset > 0 ? DataIsParam : DataIsLocal, + &loc, block, + codeview_get_type(sym->stack_v3.symtype, FALSE), sym->stack_v3.name); break; - + case S_REGISTER_V1: - symt_add_func_local(msc_dbg->module, curr_func, 0, sym->register_v1.reg, + loc.kind = loc_register; + loc.reg = sym->register_v1.reg; + loc.offset = 0; + symt_add_func_local(msc_dbg->module, curr_func, + DataIsLocal, &loc, block, codeview_get_type(sym->register_v1.type, FALSE), terminate_string(&sym->register_v1.p_name)); break; case S_REGISTER_V2: - symt_add_func_local(msc_dbg->module, curr_func, 0, sym->register_v2.reg, + loc.kind = loc_register; + loc.reg = sym->register_v2.reg; + loc.offset = 0; + symt_add_func_local(msc_dbg->module, curr_func, + DataIsLocal, &loc, block, codeview_get_type(sym->register_v2.type, FALSE), terminate_string(&sym->register_v2.p_name)); break; - + case S_BLOCK_V1: block = symt_open_func_block(msc_dbg->module, curr_func, block, codeview_get_address(msc_dbg, sym->block_v1.segment, sym->block_v1.offset), @@ -1327,7 +1463,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root codeview_get_address(msc_dbg, sym->block_v3.segment, sym->block_v3.offset), sym->block_v3.length); break; - + case S_END_V1: if (block) { @@ -1339,17 +1475,14 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root curr_func = NULL; } break; - - /* FIXME: we should use this as a compiland, instead of guessing it on the fly */ + case S_COMPILAND_V1: - TRACE("S-Compiland-V1e %x %s\n", - sym->compiland_v1.unknown, - terminate_string(&sym->compiland_v1.p_name)); + TRACE("S-Compiland-V1 %x %s\n", + sym->compiland_v1.unknown, terminate_string(&sym->compiland_v1.p_name)); break; - + case S_COMPILAND_V2: - TRACE("S-Compiland-V2 %s\n", - terminate_string(&sym->compiland_v2.p_name)); + TRACE("S-Compiland-V2 %s\n", terminate_string(&sym->compiland_v2.p_name)); if (TRACE_ON(dbghelp_msc)) { const char* ptr1 = sym->compiland_v2.p_name.name + sym->compiland_v2.p_name.namelen; @@ -1376,16 +1509,20 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root } } break; - + case S_OBJNAME_V1: - TRACE("S-ObjName %.*s\n", ((const BYTE*)sym)[8], (const BYTE*)sym + 9); + TRACE("S-ObjName %s\n", terminate_string(&sym->objname_v1.p_name)); + compiland = symt_new_compiland(msc_dbg->module, 0 /* FIXME */, + source_new(msc_dbg->module, NULL, + terminate_string(&sym->objname_v1.p_name))); break; - + case S_LABEL_V1: if (curr_func) { - symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, - codeview_get_address(msc_dbg, sym->label_v1.segment, sym->label_v1.offset) - curr_func->address, + loc.kind = loc_absolute; + loc.offset = codeview_get_address(msc_dbg, sym->label_v1.segment, sym->label_v1.offset) - curr_func->address; + symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, &loc, terminate_string(&sym->label_v1.p_name)); } else @@ -1395,72 +1532,69 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root case S_LABEL_V3: if (curr_func) { + loc.kind = loc_absolute; + loc.offset = codeview_get_address(msc_dbg, sym->label_v3.segment, sym->label_v3.offset) - curr_func->address; symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, - codeview_get_address(msc_dbg, sym->label_v3.segment, sym->label_v3.offset) - curr_func->address, - sym->label_v3.name); + &loc, sym->label_v3.name); } else FIXME("No current function for label %s\n", sym->label_v3.name); break; - + case S_CONSTANT_V1: { - int val, vlen; + int vlen; const struct p_string* name; - const char* x; struct symt* se; - - vlen = numeric_leaf(&val, &sym->constant_v1.cvalue); + VARIANT v; + + v.n1.n2.vt = VT_I4; + vlen = numeric_leaf(&v.n1.n2.n3.intVal, &sym->constant_v1.cvalue); name = (const struct p_string*)((const char*)&sym->constant_v1.cvalue + vlen); se = codeview_get_type(sym->constant_v1.type, FALSE); - if (!se) x = "---"; - else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name; - else x = "###"; - - TRACE("S-Constant-V1 %u %s %x (%s)\n", - val, terminate_string(name), sym->constant_v1.type, x); - /* FIXME: we should add this as a constant value */ + + TRACE("S-Constant-V1 %u %s %x\n", + v.n1.n2.n3.intVal, terminate_string(name), sym->constant_v1.type); + symt_new_constant(msc_dbg->module, compiland, terminate_string(name), + se, &v); } break; case S_CONSTANT_V2: { - int val, vlen; + int vlen; const struct p_string* name; - const char* x; struct symt* se; - - vlen = numeric_leaf(&val, &sym->constant_v2.cvalue); + VARIANT v; + + v.n1.n2.vt = VT_I4; + vlen = numeric_leaf(&v.n1.n2.n3.intVal, &sym->constant_v2.cvalue); name = (const struct p_string*)((const char*)&sym->constant_v2.cvalue + vlen); se = codeview_get_type(sym->constant_v2.type, FALSE); - if (!se) x = "---"; - else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name; - else x = "###"; - - TRACE("S-Constant-V2 %u %s %x (%s)\n", - val, terminate_string(name), sym->constant_v2.type, x); - /* FIXME: we should add this as a constant value */ + + TRACE("S-Constant-V2 %u %s %x\n", + v.n1.n2.n3.intVal, terminate_string(name), sym->constant_v2.type); + symt_new_constant(msc_dbg->module, compiland, terminate_string(name), + se, &v); } break; case S_CONSTANT_V3: { - int val, vlen; + int vlen; const char* name; - const char* x; struct symt* se; - - vlen = numeric_leaf(&val, &sym->constant_v3.cvalue); + VARIANT v; + + v.n1.n2.vt = VT_I4; + vlen = numeric_leaf(&v.n1.n2.n3.intVal, &sym->constant_v3.cvalue); name = (const char*)&sym->constant_v3.cvalue + vlen; se = codeview_get_type(sym->constant_v3.type, FALSE); - if (!se) x = "---"; - else if (se->tag == SymTagEnum) x = ((struct symt_enum*)se)->name; - else x = "###"; - - TRACE("S-Constant-V3 %u %s %x (%s)\n", - val, name, sym->constant_v3.type, x); + + TRACE("S-Constant-V3 %u %s %x\n", + v.n1.n2.n3.intVal, name, sym->constant_v3.type); /* FIXME: we should add this as a constant value */ } break; - + case S_UDT_V1: if (sym->udt_v1.type) { @@ -1493,7 +1627,7 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root sym->udt_v3.name, sym->udt_v3.type); } break; - + /* * These are special, in that they are always followed by an * additional length-prefixed string which is *not* included @@ -1505,142 +1639,128 @@ static int codeview_snarf(const struct msc_debug_info* msc_dbg, const BYTE* root name = (const char*)sym + length; length += (*name + 1 + 3) & ~3; break; - - case S_PUB_DATA_V3: + + case S_PUB_V3: if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) { - flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset); - symt_new_public(msc_dbg->module, - flt ? flt->compiland : NULL, + symt_new_public(msc_dbg->module, compiland, sym->data_v3.name, codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), - 0, FALSE /* FIXME */, FALSE); + 1, FALSE /* FIXME */, FALSE); } break; case S_PUB_FUNC1_V3: case S_PUB_FUNC2_V3: /* using a data_v3 isn't what we'd expect */ if (!(dbghelp_options & SYMOPT_NO_PUBLICS)) { - flt = codeview_get_linetab(linetab, sym->data_v3.segment, sym->data_v3.offset); - symt_new_public(msc_dbg->module, - flt ? flt->compiland : NULL, + symt_new_public(msc_dbg->module, compiland, sym->data_v3.name, codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset), - 0, TRUE /* FIXME */, TRUE); + 1, TRUE /* FIXME */, TRUE); } break; - + case S_MSTOOL_V3: /* just to silence a few warnings */ break; - + + case S_SSEARCH_V1: + TRACE("Start search: seg=0x%x at offset 0x%08x\n", + sym->ssearch_v1.segment, sym->ssearch_v1.offset); + break; + + case S_ALIGN_V1: + TRACE("S-Align V1\n"); + break; + default: FIXME("Unsupported symbol id %x\n", sym->generic.id); dump(sym, 2 + sym->generic.len); break; } } - + if (curr_func) symt_normalize_function(msc_dbg->module, curr_func); - - if (linetab) HeapFree(GetProcessHeap(), 0, linetab); + + HeapFree(GetProcessHeap(), 0, linetab); return TRUE; } - + /*======================================================================== * Process PDB file. */ - -struct pdb_lookup -{ - const char* filename; - enum {PDB_JG, PDB_DS} kind; - union - { - struct - { - DWORD timestamp; - struct PDB_JG_TOC* toc; - } jg; - struct - { - GUID guid; - struct PDB_DS_TOC* toc; - } ds; - } u; -}; - + static void* pdb_jg_read(const struct PDB_JG_HEADER* pdb, const WORD* block_list, int size) { int i, num_blocks; BYTE* buffer; - + if (!size) return NULL; - + num_blocks = (size + pdb->block_size - 1) / pdb->block_size; buffer = HeapAlloc(GetProcessHeap(), 0, num_blocks * pdb->block_size); - + for (i = 0; i < num_blocks; i++) memcpy(buffer + i * pdb->block_size, (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size); - + return buffer; } - + static void* pdb_ds_read(const struct PDB_DS_HEADER* pdb, const DWORD* block_list, int size) { int i, num_blocks; BYTE* buffer; - + if (!size) return NULL; - + num_blocks = (size + pdb->block_size - 1) / pdb->block_size; buffer = HeapAlloc(GetProcessHeap(), 0, num_blocks * pdb->block_size); - + for (i = 0; i < num_blocks; i++) memcpy(buffer + i * pdb->block_size, (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size); - + return buffer; } - + static void* pdb_read_jg_file(const struct PDB_JG_HEADER* pdb, const struct PDB_JG_TOC* toc, DWORD file_nr) { const WORD* block_list; DWORD i; - + if (!toc || file_nr >= toc->num_files) return NULL; - + block_list = (const WORD*) &toc->file[toc->num_files]; for (i = 0; i < file_nr; i++) block_list += (toc->file[i].size + pdb->block_size - 1) / pdb->block_size; - + return pdb_jg_read(pdb, block_list, toc->file[file_nr].size); } - + static void* pdb_read_ds_file(const struct PDB_DS_HEADER* pdb, const struct PDB_DS_TOC* toc, DWORD file_nr) { const DWORD* block_list; DWORD i; - + if (!toc || file_nr >= toc->num_files) return NULL; - + if (toc->file_size[file_nr] == 0 || toc->file_size[file_nr] == 0xFFFFFFFF) { - FIXME(">>> requesting NULL stream (%lu)\n", file_nr); + FIXME(">>> requesting NULL stream (%u)\n", file_nr); return NULL; } block_list = &toc->file_size[toc->num_files]; for (i = 0; i < file_nr; i++) block_list += (toc->file_size[i] + pdb->block_size - 1) / pdb->block_size; - + return pdb_ds_read(pdb, block_list, toc->file_size[file_nr]); } - -static void* pdb_read_file(const BYTE* image, const struct pdb_lookup* pdb_lookup, + +static void* pdb_read_file(const char* image, const struct pdb_lookup* pdb_lookup, DWORD file_nr) { switch (pdb_lookup->kind) @@ -1654,7 +1774,7 @@ static void* pdb_read_file(const BYTE* image, const struct pdb_lookup* pdb_looku } return NULL; } - + static unsigned pdb_get_file_size(const struct pdb_lookup* pdb_lookup, DWORD file_nr) { switch (pdb_lookup->kind) @@ -1664,30 +1784,30 @@ static unsigned pdb_get_file_size(const struct pdb_lookup* pdb_lookup, DWORD fil } return 0; } - + static void pdb_free(void* buffer) { HeapFree(GetProcessHeap(), 0, buffer); } - + static void pdb_free_lookup(const struct pdb_lookup* pdb_lookup) { switch (pdb_lookup->kind) { case PDB_JG: - if (pdb_lookup->u.jg.toc) pdb_free(pdb_lookup->u.jg.toc); + pdb_free(pdb_lookup->u.jg.toc); break; case PDB_DS: - if (pdb_lookup->u.ds.toc) pdb_free(pdb_lookup->u.ds.toc); + pdb_free(pdb_lookup->u.ds.toc); break; } } - + static void pdb_convert_types_header(PDB_TYPES* types, const BYTE* image) { memset(types, 0, sizeof(PDB_TYPES)); if (!image) return; - + if (*(const DWORD*)image < 19960000) /* FIXME: correct version? */ { /* Old version of the types record header */ @@ -1705,13 +1825,13 @@ static void pdb_convert_types_header(PDB_TYPES* types, const BYTE* image) *types = *(const PDB_TYPES*)image; } } - + static void pdb_convert_symbols_header(PDB_SYMBOLS* symbols, int* header_size, const BYTE* image) { memset(symbols, 0, sizeof(PDB_SYMBOLS)); if (!image) return; - + if (*(const DWORD*)image != 0xffffffff) { /* Old version of the symbols record header */ @@ -1725,7 +1845,7 @@ static void pdb_convert_symbols_header(PDB_SYMBOLS* symbols, symbols->hash1_file = old->hash1_file; symbols->hash2_file = old->hash2_file; symbols->gsym_file = old->gsym_file; - + *header_size = sizeof(PDB_SYMBOLS_OLD); } else @@ -1735,11 +1855,11 @@ static void pdb_convert_symbols_header(PDB_SYMBOLS* symbols, *header_size = sizeof(PDB_SYMBOLS); } } - + static void pdb_convert_symbol_file(const PDB_SYMBOLS* symbols, PDB_SYMBOL_FILE_EX* sfile, unsigned* size, const void* image) - + { if (symbols->version < 19970000) { @@ -1757,42 +1877,67 @@ static void pdb_convert_symbol_file(const PDB_SYMBOLS* symbols, *size = sizeof(PDB_SYMBOL_FILE_EX) - 1; } } - -static BOOL CALLBACK pdb_match(char* file, void* user) + +static BOOL CALLBACK pdb_match(const char* file, void* user) { - /* accept first file */ - return FALSE; + /* accept first file that exists */ + HANDLE h = CreateFileA(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + TRACE("match with %s returns %p\n", file, h); + if (INVALID_HANDLE_VALUE != h) { + CloseHandle(h); + return FALSE; + } + return TRUE; } - -static HANDLE open_pdb_file(const struct process* pcs, const char* filename) + +static HANDLE open_pdb_file(const struct process* pcs, + const struct pdb_lookup* lookup) { HANDLE h; char dbg_file_path[MAX_PATH]; - - h = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - /* FIXME: should give more bits on the file to look at */ - if (h == INVALID_HANDLE_VALUE && - SymFindFileInPath(pcs->handle, NULL, (char*)filename, NULL, 0, 0, 0, - dbg_file_path, pdb_match, NULL)) + BOOL ret = FALSE; + + switch (lookup->kind) { - h = CreateFileA(dbg_file_path, GENERIC_READ, FILE_SHARE_READ, NULL, - OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + case PDB_JG: + ret = SymFindFileInPath(pcs->handle, NULL, lookup->filename, + (PVOID)(DWORD_PTR)lookup->u.jg.timestamp, + lookup->age, 0, SSRVOPT_DWORD, + dbg_file_path, pdb_match, NULL); + break; + case PDB_DS: + ret = SymFindFileInPath(pcs->handle, NULL, lookup->filename, + (PVOID)&lookup->u.ds.guid, lookup->age, 0, + SSRVOPT_GUIDPTR, dbg_file_path, pdb_match, NULL); + break; } + if (!ret) + { + WARN("\tCouldn't find %s\n", lookup->filename); + return NULL; + } + h = CreateFileA(dbg_file_path, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + TRACE("%s: %s returns %p\n", lookup->filename, dbg_file_path, h); return (h == INVALID_HANDLE_VALUE) ? NULL : h; } - + static void pdb_process_types(const struct msc_debug_info* msc_dbg, - const char* image, struct pdb_lookup* pdb_lookup) + const char* image, const struct pdb_lookup* pdb_lookup) { - char* types_image = NULL; - + BYTE* types_image = NULL; + types_image = pdb_read_file(image, pdb_lookup, 2); if (types_image) { - PDB_TYPES types; + PDB_TYPES types; + struct codeview_type_parse ctp; + DWORD total; + const BYTE* ptr; + DWORD* offset; + pdb_convert_types_header(&types, types_image); - + /* Check for unknown versions */ switch (types.version) { @@ -1802,116 +1947,135 @@ static void pdb_process_types(const struct msc_debug_info* msc_dbg, case 19990903: break; default: - ERR("-Unknown type info version %ld\n", types.version); + ERR("-Unknown type info version %d\n", types.version); } - + + ctp.module = msc_dbg->module; + /* reconstruct the types offset... + * FIXME: maybe it's present in the newest PDB_TYPES structures + */ + total = types.last_index - types.first_index + 1; + offset = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) * total); + ctp.table = ptr = types_image + types.type_offset; + ctp.num = 0; + while (ptr < ctp.table + types.type_size && ctp.num < total) + { + offset[ctp.num++] = ptr - ctp.table; + ptr += ((const union codeview_type*)ptr)->generic.len + 2; + } + ctp.offset = offset; + /* Read type table */ - codeview_parse_type_table(msc_dbg->module, types_image + types.type_offset, - types.type_size); + codeview_parse_type_table(&ctp); + HeapFree(GetProcessHeap(), 0, offset); pdb_free(types_image); } } - + static const char PDB_JG_IDENT[] = "Microsoft C/C++ program database 2.00\r\n\032JG\0"; static const char PDB_DS_IDENT[] = "Microsoft C/C++ MSF 7.00\r\n\032DS\0"; - -static BOOL pdb_init(struct pdb_lookup* pdb_lookup, const char* image) + +/****************************************************************** + * pdb_init + * + * Tries to load a pdb file + * if do_fill is TRUE, then it just fills pdb_lookup with the information of the + * file + * if do_fill is FALSE, then it just checks that the kind of PDB (stored in + * pdb_lookup) matches what's really in the file + */ +static BOOL pdb_init(struct pdb_lookup* pdb_lookup, const char* image, BOOL do_fill) { + BOOL ret = TRUE; + /* check the file header, and if ok, load the TOC */ TRACE("PDB(%s): %.40s\n", pdb_lookup->filename, debugstr_an(image, 40)); - switch (pdb_lookup->kind) + + if (!memcmp(image, PDB_JG_IDENT, sizeof(PDB_JG_IDENT))) { - case PDB_JG: - pdb_lookup->u.jg.toc = NULL; - if (memcmp(image, PDB_JG_IDENT, sizeof(PDB_JG_IDENT))) + const struct PDB_JG_HEADER* pdb = (const struct PDB_JG_HEADER*)image; + struct PDB_JG_ROOT* root; + + pdb_lookup->u.jg.toc = pdb_jg_read(pdb, pdb->toc_block, pdb->toc.size); + root = pdb_read_jg_file(pdb, pdb_lookup->u.jg.toc, 1); + if (!root) { - FIXME("Couldn't match JG header\n"); + ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename); return FALSE; } - else + switch (root->Version) { - const struct PDB_JG_HEADER* pdb = (const struct PDB_JG_HEADER*)image; - struct PDB_JG_ROOT* root; - - pdb_lookup->u.jg.toc = pdb_jg_read(pdb, pdb->toc_block, pdb->toc.size); - root = pdb_read_jg_file(pdb, pdb_lookup->u.jg.toc, 1); - if (!root) - { - ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename); - return FALSE; - } - switch (root->Version) - { - case 19950623: /* VC 4.0 */ - case 19950814: - case 19960307: /* VC 5.0 */ - case 19970604: /* VC 6.0 */ - break; - default: - ERR("-Unknown root block version %ld\n", root->Version); - } - /* Check .PDB time stamp */ - if (root->TimeDateStamp != pdb_lookup->u.jg.timestamp) - { - ERR("-Wrong time stamp of .PDB file %s (0x%08lx, 0x%08lx)\n", - pdb_lookup->filename, root->TimeDateStamp, - pdb_lookup->u.jg.timestamp); - } - pdb_free(root); + case 19950623: /* VC 4.0 */ + case 19950814: + case 19960307: /* VC 5.0 */ + case 19970604: /* VC 6.0 */ + break; + default: + ERR("-Unknown root block version %d\n", root->Version); } - break; - case PDB_DS: - pdb_lookup->u.ds.toc = NULL; - if (memcmp(image, PDB_DS_IDENT, sizeof(PDB_DS_IDENT))) + if (do_fill) { - FIXME("Couldn't match DS header\n"); - return FALSE; + pdb_lookup->kind = PDB_JG; + pdb_lookup->u.jg.timestamp = root->TimeDateStamp; + pdb_lookup->age = root->Age; } - else - { - const struct PDB_DS_HEADER* pdb = (const struct PDB_DS_HEADER*)image; - struct PDB_DS_ROOT* root; - - pdb_lookup->u.ds.toc = - pdb_ds_read(pdb, - (const DWORD*)((const char*)pdb + pdb->toc_page * pdb->block_size), - pdb->toc_size); - root = pdb_read_ds_file(pdb, pdb_lookup->u.ds.toc, 1); - if (!root) - { - ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename); - return FALSE; - } - switch (root->Version) - { - case 20000404: - break; - default: - ERR("-Unknown root block version %ld\n", root->Version); - } - /* Check .PDB time stamp */ - if (memcmp(&root->guid, &pdb_lookup->u.ds.guid, sizeof(GUID))) - { - ERR("-Wrong GUID of .PDB file %s (%s, %s)\n", - pdb_lookup->filename, - wine_dbgstr_guid(&root->guid), - wine_dbgstr_guid(&pdb_lookup->u.ds.guid)); - } - pdb_free(root); - } - break; + else if (pdb_lookup->kind != PDB_JG || + pdb_lookup->u.jg.timestamp != root->TimeDateStamp || + pdb_lookup->age != root->Age) + ret = FALSE; + TRACE("found JG/%c for %s: age=%x timestamp=%x\n", + do_fill ? 'f' : '-', pdb_lookup->filename, root->Age, + root->TimeDateStamp); + pdb_free(root); } - + else if (!memcmp(image, PDB_DS_IDENT, sizeof(PDB_DS_IDENT))) + { + const struct PDB_DS_HEADER* pdb = (const struct PDB_DS_HEADER*)image; + struct PDB_DS_ROOT* root; + + pdb_lookup->u.ds.toc = + pdb_ds_read(pdb, + (const DWORD*)((const char*)pdb + pdb->toc_page * pdb->block_size), + pdb->toc_size); + root = pdb_read_ds_file(pdb, pdb_lookup->u.ds.toc, 1); + if (!root) + { + ERR("-Unable to get root from .PDB in %s\n", pdb_lookup->filename); + return FALSE; + } + switch (root->Version) + { + case 20000404: + break; + default: + ERR("-Unknown root block version %d\n", root->Version); + } + if (do_fill) + { + pdb_lookup->kind = PDB_DS; + pdb_lookup->u.ds.guid = root->guid; + pdb_lookup->age = root->Age; + } + else if (pdb_lookup->kind != PDB_DS || + memcmp(&pdb_lookup->u.ds.guid, &root->guid, sizeof(GUID)) || + pdb_lookup->age != root->Age) + ret = FALSE; + TRACE("found DS/%c for %s: age=%x guid=%s\n", + do_fill ? 'f' : '-', pdb_lookup->filename, root->Age, + debugstr_guid(&root->guid)); + pdb_free(root); + } + if (0) /* some tool to dump the internal files from a PDB file */ { int i, num_files; - + switch (pdb_lookup->kind) { case PDB_JG: num_files = pdb_lookup->u.jg.toc->num_files; break; case PDB_DS: num_files = pdb_lookup->u.ds.toc->num_files; break; } - + for (i = 1; i < num_files; i++) { unsigned char* x = pdb_read_file(image, pdb_lookup, i); @@ -1921,19 +2085,20 @@ static BOOL pdb_init(struct pdb_lookup* pdb_lookup, const char* image) pdb_free(x); } } - return TRUE; + return ret; } - + static BOOL pdb_process_internal(const struct process* pcs, const struct msc_debug_info* msc_dbg, struct pdb_lookup* pdb_lookup, unsigned module_index); - + static void pdb_process_symbol_imports(const struct process* pcs, const struct msc_debug_info* msc_dbg, - PDB_SYMBOLS* symbols, + const PDB_SYMBOLS* symbols, const void* symbols_image, - char* image, struct pdb_lookup* pdb_lookup, + const char* image, + const struct pdb_lookup* pdb_lookup, unsigned module_index) { if (module_index == -1 && symbols && symbols->pdbimport_size) @@ -1943,7 +2108,7 @@ static void pdb_process_symbol_imports(const struct process* pcs, const void* last; const char* ptr; int i = 0; - + imp = (const PDB_SYMBOL_IMPORT*)((const char*)symbols_image + sizeof(PDB_SYMBOLS) + symbols->module_size + symbols->offset_size + symbols->hash_size + symbols->srcmodule_size); @@ -1961,10 +2126,16 @@ static void pdb_process_symbol_imports(const struct process* pcs, else { struct pdb_lookup imp_pdb_lookup; - + + /* FIXME: this is an import of a JG PDB file + * how's a DS PDB handled ? + */ imp_pdb_lookup.filename = imp->filename; imp_pdb_lookup.kind = PDB_JG; imp_pdb_lookup.u.jg.timestamp = imp->TimeDateStamp; + imp_pdb_lookup.age = imp->Age; + TRACE("got for %s: age=%u ts=%x\n", + imp->filename, imp->Age, imp->TimeDateStamp); pdb_process_internal(pcs, msc_dbg, &imp_pdb_lookup, i); } i++; @@ -1976,7 +2147,7 @@ static void pdb_process_symbol_imports(const struct process* pcs, cv_current_module->allowed = TRUE; pdb_process_types(msc_dbg, image, pdb_lookup); } - + static BOOL pdb_process_internal(const struct process* pcs, const struct msc_debug_info* msc_dbg, struct pdb_lookup* pdb_lookup, @@ -1985,28 +2156,28 @@ static BOOL pdb_process_internal(const struct process* pcs, BOOL ret = FALSE; HANDLE hFile, hMap = NULL; char* image = NULL; - char* symbols_image = NULL; - + BYTE* symbols_image = NULL; + TRACE("Processing PDB file %s\n", pdb_lookup->filename); - + /* Open and map() .PDB file */ - if ((hFile = open_pdb_file(pcs, pdb_lookup->filename)) == NULL || - ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) || + if ((hFile = open_pdb_file(pcs, pdb_lookup)) == NULL || + ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) || ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL)) { - ERR("-Unable to peruse .PDB file %s\n", pdb_lookup->filename); + WARN("Unable to open .PDB file: %s\n", pdb_lookup->filename); goto leave; } - pdb_init(pdb_lookup, image); - + pdb_init(pdb_lookup, image, FALSE); + symbols_image = pdb_read_file(image, pdb_lookup, 3); if (symbols_image) { PDB_SYMBOLS symbols; - char* modimage; - char* file; + BYTE* modimage; + BYTE* file; int header_size = 0; - + pdb_convert_symbols_header(&symbols, &header_size, symbols_image); switch (symbols.version) { @@ -2016,22 +2187,22 @@ static BOOL pdb_process_internal(const struct process* pcs, case 19990903: break; default: - ERR("-Unknown symbol info version %ld %08lx\n", + ERR("-Unknown symbol info version %d %08x\n", symbols.version, symbols.version); } - + pdb_process_symbol_imports(pcs, msc_dbg, &symbols, symbols_image, image, pdb_lookup, module_index); - + /* Read global symbol table */ modimage = pdb_read_file(image, pdb_lookup, symbols.gsym_file); if (modimage) { codeview_snarf(msc_dbg, modimage, 0, pdb_get_file_size(pdb_lookup, symbols.gsym_file), NULL); - + pdb_free(modimage); } - + /* Read per-module symbol / linenumber tables */ file = symbols_image + header_size; while (file - symbols_image < header_size + symbols.module_size) @@ -2039,144 +2210,172 @@ static BOOL pdb_process_internal(const struct process* pcs, PDB_SYMBOL_FILE_EX sfile; const char* file_name; unsigned size; - + HeapValidate(GetProcessHeap(), 0, NULL); pdb_convert_symbol_file(&symbols, &sfile, &size, file); - + modimage = pdb_read_file(image, pdb_lookup, sfile.file); if (modimage) { struct codeview_linetab* linetab = NULL; - + if (sfile.lineno_size) linetab = codeview_snarf_linetab(msc_dbg->module, modimage + sfile.symbol_size, sfile.lineno_size, pdb_lookup->kind == PDB_JG); - + if (sfile.symbol_size) codeview_snarf(msc_dbg, modimage, sizeof(DWORD), sfile.symbol_size, linetab); - + pdb_free(modimage); } file_name = (const char*)file + size; file_name += strlen(file_name) + 1; - file = (char*)((DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3); + file = (BYTE*)((DWORD)(file_name + strlen(file_name) + 1 + 3) & ~3); } } else pdb_process_symbol_imports(pcs, msc_dbg, NULL, NULL, image, pdb_lookup, module_index); - msc_dbg->module->module.SymType = SymCv; ret = TRUE; - + leave: /* Cleanup */ - if (symbols_image) pdb_free(symbols_image); + pdb_free(symbols_image); pdb_free_lookup(pdb_lookup); - + if (image) UnmapViewOfFile(image); if (hMap) CloseHandle(hMap); if (hFile) CloseHandle(hFile); - + return ret; } - + static BOOL pdb_process_file(const struct process* pcs, const struct msc_debug_info* msc_dbg, struct pdb_lookup* pdb_lookup) { BOOL ret; - + memset(cv_zmodules, 0, sizeof(cv_zmodules)); codeview_init_basic_types(msc_dbg->module); ret = pdb_process_internal(pcs, msc_dbg, pdb_lookup, -1); codeview_clear_type_table(); + if (ret) + { + msc_dbg->module->module.SymType = SymCv; + if (pdb_lookup->kind == PDB_JG) + msc_dbg->module->module.PdbSig = pdb_lookup->u.jg.timestamp; + else + msc_dbg->module->module.PdbSig70 = pdb_lookup->u.ds.guid; + msc_dbg->module->module.PdbAge = pdb_lookup->age; + MultiByteToWideChar(CP_ACP, 0, pdb_lookup->filename, -1, + msc_dbg->module->module.LoadedPdbName, + sizeof(msc_dbg->module->module.LoadedPdbName) / sizeof(WCHAR)); + /* FIXME: we could have a finer grain here */ + msc_dbg->module->module.LineNumbers = TRUE; + msc_dbg->module->module.GlobalSymbols = TRUE; + msc_dbg->module->module.TypeInfo = TRUE; + msc_dbg->module->module.SourceIndexed = TRUE; + msc_dbg->module->module.Publics = TRUE; + } return ret; } - + +BOOL pdb_fetch_file_info(struct pdb_lookup* pdb_lookup) +{ + HANDLE hFile, hMap = NULL; + char* image = NULL; + BOOL ret = TRUE; + + if ((hFile = CreateFileA(pdb_lookup->filename, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE || + ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) == NULL) || + ((image = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) == NULL)) + { + WARN("Unable to open .PDB file: %s\n", pdb_lookup->filename); + ret = FALSE; + } + else + { + pdb_init(pdb_lookup, image, TRUE); + pdb_free_lookup(pdb_lookup); + } + + if (image) UnmapViewOfFile(image); + if (hMap) CloseHandle(hMap); + if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile); + + return ret; +} + /*======================================================================== * Process CodeView debug information. */ - + #define MAKESIG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) #define CODEVIEW_NB09_SIG MAKESIG('N','B','0','9') #define CODEVIEW_NB10_SIG MAKESIG('N','B','1','0') #define CODEVIEW_NB11_SIG MAKESIG('N','B','1','1') #define CODEVIEW_RSDS_SIG MAKESIG('R','S','D','S') - -typedef struct _CODEVIEW_HEADER_NBxx -{ - DWORD dwSignature; - DWORD lfoDirectory; -} CODEVIEW_HEADER_NBxx,* PCODEVIEW_HEADER_NBxx; - -typedef struct _CODEVIEW_HEADER_RSDS -{ - DWORD dwSignature; - GUID guid; - DWORD unknown; - CHAR name[1]; -} CODEVIEW_HEADER_RSDS,* PCODEVIEW_HEADER_RSDS; - -typedef struct _CODEVIEW_PDB_DATA -{ - DWORD timestamp; - DWORD unknown; - CHAR name[1]; -} CODEVIEW_PDB_DATA, *PCODEVIEW_PDB_DATA; - -typedef struct _CV_DIRECTORY_HEADER -{ - WORD cbDirHeader; - WORD cbDirEntry; - DWORD cDir; - DWORD lfoNextDir; - DWORD flags; -} CV_DIRECTORY_HEADER, *PCV_DIRECTORY_HEADER; - -typedef struct _CV_DIRECTORY_ENTRY -{ - WORD subsection; - WORD iMod; - DWORD lfo; - DWORD cb; -} CV_DIRECTORY_ENTRY, *PCV_DIRECTORY_ENTRY; - -#define sstAlignSym 0x125 -#define sstSrcModule 0x127 - + static BOOL codeview_process_info(const struct process* pcs, const struct msc_debug_info* msc_dbg) { - const CODEVIEW_HEADER_NBxx* cv = (const CODEVIEW_HEADER_NBxx*)msc_dbg->root; + const DWORD* signature = (const DWORD*)msc_dbg->root; BOOL ret = FALSE; struct pdb_lookup pdb_lookup; - - TRACE("Processing signature %.4s\n", (const char*)&cv->dwSignature); - - switch (cv->dwSignature) + + TRACE("Processing signature %.4s\n", (const char*)signature); + + switch (*signature) { case CODEVIEW_NB09_SIG: case CODEVIEW_NB11_SIG: { - const CV_DIRECTORY_HEADER* hdr = (const CV_DIRECTORY_HEADER*)(msc_dbg->root + cv->lfoDirectory); - const CV_DIRECTORY_ENTRY* ent; - const CV_DIRECTORY_ENTRY* prev; - const CV_DIRECTORY_ENTRY* next; + const OMFSignature* cv = (const OMFSignature*)msc_dbg->root; + const OMFDirHeader* hdr = (const OMFDirHeader*)(msc_dbg->root + cv->filepos); + const OMFDirEntry* ent; + const OMFDirEntry* prev; + const OMFDirEntry* next; unsigned int i; - + codeview_init_basic_types(msc_dbg->module); - ent = (const CV_DIRECTORY_ENTRY*)((const BYTE*)hdr + hdr->cbDirHeader); + + for (i = 0; i < hdr->cDir; i++) + { + ent = (const OMFDirEntry*)((const BYTE*)hdr + hdr->cbDirHeader + i * hdr->cbDirEntry); + if (ent->SubSection == sstGlobalTypes) + { + const OMFGlobalTypes* types; + struct codeview_type_parse ctp; + + types = (const OMFGlobalTypes*)(msc_dbg->root + ent->lfo); + ctp.module = msc_dbg->module; + ctp.offset = (const DWORD*)(types + 1); + ctp.num = types->cTypes; + ctp.table = (const BYTE*)(ctp.offset + types->cTypes); + + cv_current_module = &cv_zmodules[0]; + if (cv_current_module->allowed) FIXME("Already allowed ??\n"); + cv_current_module->allowed = TRUE; + + codeview_parse_type_table(&ctp); + break; + } + } + + ent = (const OMFDirEntry*)((const BYTE*)hdr + hdr->cbDirHeader); for (i = 0; i < hdr->cDir; i++, ent = next) { - next = (i == hdr->cDir-1)? NULL : - (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent + hdr->cbDirEntry); - prev = (i == 0)? NULL : - (const CV_DIRECTORY_ENTRY*)((const BYTE*)ent - hdr->cbDirEntry); - - if (ent->subsection == sstAlignSym) + next = (i == hdr->cDir-1) ? NULL : + (const OMFDirEntry*)((const BYTE*)ent + hdr->cbDirEntry); + prev = (i == 0) ? NULL : + (const OMFDirEntry*)((const BYTE*)ent - hdr->cbDirEntry); + + if (ent->SubSection == sstAlignSym) { /* * Check the next and previous entry. If either is a @@ -2186,61 +2385,75 @@ static BOOL codeview_process_info(const struct process* pcs, * FIXME: This is not a general solution! */ struct codeview_linetab* linetab = NULL; - + if (next && next->iMod == ent->iMod && - next->subsection == sstSrcModule) + next->SubSection == sstSrcModule) linetab = codeview_snarf_linetab(msc_dbg->module, msc_dbg->root + next->lfo, next->cb, TRUE); - + if (prev && prev->iMod == ent->iMod && - prev->subsection == sstSrcModule) + prev->SubSection == sstSrcModule) linetab = codeview_snarf_linetab(msc_dbg->module, msc_dbg->root + prev->lfo, prev->cb, TRUE); - + codeview_snarf(msc_dbg, msc_dbg->root + ent->lfo, sizeof(DWORD), ent->cb, linetab); } } - + msc_dbg->module->module.SymType = SymCv; + /* FIXME: we could have a finer grain here */ + msc_dbg->module->module.LineNumbers = TRUE; + msc_dbg->module->module.GlobalSymbols = TRUE; + msc_dbg->module->module.TypeInfo = TRUE; + msc_dbg->module->module.SourceIndexed = TRUE; + msc_dbg->module->module.Publics = TRUE; + codeview_clear_type_table(); ret = TRUE; break; } - + case CODEVIEW_NB10_SIG: { - const CODEVIEW_PDB_DATA* pdb = (const CODEVIEW_PDB_DATA*)(cv + 1); + const CODEVIEW_PDB_DATA* pdb = (const CODEVIEW_PDB_DATA*)msc_dbg->root; pdb_lookup.filename = pdb->name; pdb_lookup.kind = PDB_JG; pdb_lookup.u.jg.timestamp = pdb->timestamp; pdb_lookup.u.jg.toc = NULL; + pdb_lookup.age = pdb->unknown; ret = pdb_process_file(pcs, msc_dbg, &pdb_lookup); break; } case CODEVIEW_RSDS_SIG: { - const CODEVIEW_HEADER_RSDS* rsds = (const CODEVIEW_HEADER_RSDS*)msc_dbg->root; - - TRACE("Got RSDS type of PDB file: guid=%s unk=%08lx name=%s\n", + const OMFSignatureRSDS* rsds = (const OMFSignatureRSDS*)msc_dbg->root; + + TRACE("Got RSDS type of PDB file: guid=%s unk=%08x name=%s\n", wine_dbgstr_guid(&rsds->guid), rsds->unknown, rsds->name); pdb_lookup.filename = rsds->name; pdb_lookup.kind = PDB_DS; pdb_lookup.u.ds.guid = rsds->guid; pdb_lookup.u.ds.toc = NULL; + pdb_lookup.age = rsds->unknown; ret = pdb_process_file(pcs, msc_dbg, &pdb_lookup); break; } default: - ERR("Unknown CODEVIEW signature %08lX in module %s\n", - cv->dwSignature, msc_dbg->module->module.ModuleName); + ERR("Unknown CODEVIEW signature %08x in module %s\n", + *signature, debugstr_w(msc_dbg->module->module.ModuleName)); break; } - + if (ret) + { + msc_dbg->module->module.CVSig = *signature; + memcpy(msc_dbg->module->module.CVData, msc_dbg->root, + sizeof(msc_dbg->module->module.CVData)); + } return ret; } - + /*======================================================================== * Process debug directory. */ @@ -2249,18 +2462,20 @@ BOOL pe_load_debug_directory(const struct process* pcs, struct module* module, const IMAGE_SECTION_HEADER* sectp, DWORD nsect, const IMAGE_DEBUG_DIRECTORY* dbg, int nDbg) { - BOOL ret = FALSE; + BOOL ret; int i; struct msc_debug_info msc_dbg; - + msc_dbg.module = module; msc_dbg.nsect = nsect; msc_dbg.sectp = sectp; msc_dbg.nomap = 0; msc_dbg.omapp = NULL; - - _SEH_TRY + + __TRY { + ret = FALSE; + /* First, watch out for OMAP data */ for (i = 0; i < nDbg; i++) { @@ -2271,7 +2486,7 @@ BOOL pe_load_debug_directory(const struct process* pcs, struct module* module, break; } } - + /* Now, try to parse CodeView debug info */ for (i = 0; i < nDbg; i++) { @@ -2281,7 +2496,7 @@ BOOL pe_load_debug_directory(const struct process* pcs, struct module* module, if ((ret = codeview_process_info(pcs, &msc_dbg))) goto done; } } - + /* If not found, try to parse COFF debug info */ for (i = 0; i < nDbg; i++) { @@ -2300,18 +2515,18 @@ BOOL pe_load_debug_directory(const struct process* pcs, struct module* module, if (dbg[i].Type == IMAGE_DEBUG_TYPE_FPO) FIXME("This guy has FPO information\n"); #if 0 - + #define FRAME_FPO 0 #define FRAME_TRAP 1 #define FRAME_TSS 2 - + typedef struct _FPO_DATA { DWORD ulOffStart; /* offset 1st byte of function code */ DWORD cbProcSize; /* # bytes in function */ DWORD cdwLocals; /* # bytes in locals/4 */ WORD cdwParams; /* # bytes in params/4 */ - + WORD cbProlog : 8; /* # bytes in prolog */ WORD cbRegs : 3; /* # regs saved */ WORD fHasSEH : 1; /* TRUE if SEH in func */ @@ -2320,13 +2535,13 @@ typedef struct _FPO_DATA WORD cbFrame : 2; /* frame type */ } FPO_DATA; #endif - + } - _SEH_EXCEPT(page_fault) + __EXCEPT_PAGE_FAULT { ERR("Got a page fault while loading symbols\n"); ret = FALSE; } - _SEH_END; + __ENDTRY return ret; } diff --git a/reactos/dll/win32/dbghelp/mscvpdb.h b/reactos/dll/win32/dbghelp/mscvpdb.h deleted file mode 100644 index d3695a89047..00000000000 --- a/reactos/dll/win32/dbghelp/mscvpdb.h +++ /dev/null @@ -1,1424 +0,0 @@ -/* - * MS debug information definitions. - * - * Copyright (C) 1996 Eric Youngdale - * Copyright (C) 1999-2000 Ulrich Weigand - * Copyright (C) 2004 Eric Pouech - * - * 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 - */ - -/* MS has stored all its debug information in a set of structures - * which has been rather consistent across the years (ie you can grasp - * some continuity, and not so many drastic changes). - * - * A bit of history on the various formats - * MSVC 1.0 PDB v1 (new format for debug info) - * MSVC 2.0 Inclusion in link of debug info (PDB v2) - * MSVC 5.0 Types are 24 bits (instead of 16 for <= 4.x) - * MSVC x.0 PDB (change in internal streams layout) - * - * .DBG Contains COFF, FPO and Codeview info - * .PDB New format for debug info (information is - * derived from Codeview information) - * VCx0.PDB x major MSVC number, stores types, while - * .PDB stores symbols. - * - * Debug information can either be found in the debug section of a PE - * module (in something close to a .DBG file), or the debug section - * can actually refer to an external file, which can be in turn, - * either a .DBG or .PDB file. - * - * Regarding PDB files: - * ------------------- - * They are implemented as a set of internal files (as a small file - * system). The file is split into blocks, an internal file is made - * of a set of blocks. Internal files are accessed through - * numbers. For example, - * 1/ is the ROOT (basic information on the file) - * 2/ is the Symbol information (global symbols, local variables...) - * 3/ is the Type internal file (each the symbols can have type - * information associated with it). - * - * Over the years, three formats existed for the PDB: - * - ?? was rather linked to 16 bit code (our support shall be rather - * bad) - * - JG: it's the signature embedded in the file header. This format - * has been used in MSVC 2.0 => 5.0. - * - DS: it's the signature embedded in the file header. It's the - * current format supported my MS. - * - * Types internal stream - * --------------------- - * Types (from the Type internal file) have existed in three flavors - * (note that those flavors came as historical evolution, but there - * isn't a one to one link between types evolution and PDB formats' - * evolutions: - * - the first flavor (suffixed by V1 in this file), where the types - * and subtypes are 16 bit entities; and where strings are in Pascal - * format (first char is their length and are not 0 terminated) - * - the second flavor (suffixed by V2) differs from first flavor with - * types and subtypes as 32 bit entities. This forced some - * reordering of fields in some types - * - the third flavor (suffixed by V3) differs from second flavor with - * strings stored as C strings (ie are 0 terminated, instead of - * length prefixed) - * The different flavors can coexist in the same file (is this really - * true ??) - * - * For the evolution of types, the need of the second flavor was the - * number of types to be defined (limited to 0xFFFF, including the C - * basic types); the need of the third flavor is the increase of - * symbol size (to be greated than 256), which was likely needed for - * complex C++ types (nested + templates). - * - * It's somehow difficult to represent the layout of those types on - * disk because: - * - some integral values are stored as numeric leaf, which size is - * variable depending on its value - * - * Symbols internal stream - * ----------------------- - * Here also we find three flavors (that we've suffixed with _V1, _V2 - * and _V3) even if their evolution is closer to the evolution of - * types, there are not completly linked together. - */ - -#include "pshpack1.h" - -/* ======================================== * - * Type information - * ======================================== */ - -struct p_string -{ - unsigned char namelen; - char name[1]; -}; - -union codeview_type -{ - struct - { - unsigned short int len; - short int id; - } generic; - - struct - { - unsigned short int len; - short int id; - short int attribute; - short int type; - } modifier_v1; - - struct - { - unsigned short int len; - short int id; - int type; - short int attribute; - } modifier_v2; - - struct - { - unsigned short int len; - short int id; - short int attribute; - short int datatype; - struct p_string p_name; - } pointer_v1; - - struct - { - unsigned short int len; - short int id; - unsigned int datatype; - unsigned int attribute; - struct p_string p_name; - } pointer_v2; - - struct - { - unsigned short int len; - short int id; - unsigned char nbits; - unsigned char bitoff; - unsigned short type; - } bitfield_v1; - - struct - { - unsigned short int len; - short int id; - unsigned int type; - unsigned char nbits; - unsigned char bitoff; - } bitfield_v2; - - struct - { - unsigned short int len; - short int id; - short int elemtype; - short int idxtype; - unsigned short int arrlen; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } array_v1; - - struct - { - unsigned short int len; - short int id; - unsigned int elemtype; - unsigned int idxtype; - unsigned short int arrlen; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } array_v2; - - struct - { - unsigned short int len; - short int id; - unsigned int elemtype; - unsigned int idxtype; - unsigned short int arrlen; /* numeric leaf */ -#if 0 - char name[1]; -#endif - } array_v3; - - struct - { - unsigned short int len; - short int id; - short int n_element; - short int fieldlist; - short int property; - short int derived; - short int vshape; - unsigned short int structlen; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } struct_v1; - - struct - { - unsigned short int len; - short int id; - short int n_element; - short int property; - unsigned int fieldlist; - unsigned int derived; - unsigned int vshape; - unsigned short int structlen; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } struct_v2; - - struct - { - unsigned short int len; - short int id; - short int n_element; - short int property; - unsigned int fieldlist; - unsigned int derived; - unsigned int vshape; - unsigned short int structlen; /* numeric leaf */ -#if 0 - char name[1]; -#endif - } struct_v3; - - struct - { - unsigned short int len; - short int id; - short int count; - short int fieldlist; - short int property; - unsigned short int un_len; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } union_v1; - - struct - { - unsigned short int len; - short int id; - short int count; - short int property; - unsigned int fieldlist; - unsigned short int un_len; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } union_v2; - - struct - { - unsigned short int len; - short int id; - short int count; - short int property; - unsigned int fieldlist; - unsigned short int un_len; /* numeric leaf */ -#if 0 - char name[1]; -#endif - } union_v3; - - struct - { - unsigned short int len; - short int id; - short int count; - short int type; - short int field; - short int property; - struct p_string p_name; - } enumeration_v1; - - struct - { - unsigned short int len; - short int id; - short int count; - short int property; - unsigned int type; - unsigned int field; - struct p_string p_name; - } enumeration_v2; - - struct - { - unsigned short int len; - short int id; - short int count; - short int property; - unsigned int type; - unsigned int field; - char name[1]; - } enumeration_v3; - - struct - { - unsigned short int len; - short int id; - unsigned char list[1]; - } fieldlist; - - struct - { - unsigned short int len; - short int id; - unsigned short int rvtype; - unsigned char call; - unsigned char reserved; - unsigned short int params; - unsigned short int arglist; - } procedure_v1; - - struct - { - unsigned short int len; - short int id; - unsigned int rvtype; - unsigned char call; - unsigned char reserved; - unsigned short int params; - unsigned int arglist; - } procedure_v2; - - struct - { - unsigned short int len; - short int id; - unsigned short int rvtype; - unsigned short int class_type; - unsigned short int this_type; - unsigned char call; - unsigned char reserved; - unsigned short int params; - unsigned short int arglist; - unsigned int this_adjust; - } mfunction_v1; - - struct - { - unsigned short int len; - short int id; - unsigned unknown1; /* could be this_type ??? */ - unsigned int class_type; - unsigned int rvtype; - unsigned char call; - unsigned char reserved; - unsigned short params; - unsigned int arglist; - unsigned int this_adjust; - } mfunction_v2; -}; - -union codeview_fieldtype -{ - struct - { - short int id; - } generic; - - struct - { - short int id; - short int type; - short int attribute; - unsigned short int offset; /* numeric leaf */ - } bclass_v1; - - struct - { - short int id; - short int attribute; - unsigned int type; - unsigned short int offset; /* numeric leaf */ - } bclass_v2; - - struct - { - short int id; - short int btype; - short int vbtype; - short int attribute; - unsigned short int vbpoff; /* numeric leaf */ -#if 0 - unsigned short int vboff; /* numeric leaf */ -#endif - } vbclass_v1; - - struct - { - short int id; - short int attribute; - unsigned int btype; - unsigned int vbtype; - unsigned short int vbpoff; /* numeric leaf */ -#if 0 - unsigned short int vboff; /* numeric leaf */ -#endif - } vbclass_v2; - - struct - { - short int id; - short int attribute; - unsigned short int value; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } enumerate_v1; - - struct - { - short int id; - short int attribute; - unsigned short int value; /* numeric leaf */ -#if 0 - char name[1]; -#endif - } enumerate_v3; - - struct - { - short int id; - short int type; - struct p_string p_name; - } friendfcn_v1; - - struct - { - short int id; - short int _pad0; - unsigned int type; - struct p_string p_name; - } friendfcn_v2; - - struct - { - short int id; - short int type; - short int attribute; - unsigned short int offset; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } member_v1; - - struct - { - short int id; - short int attribute; - unsigned int type; - unsigned short int offset; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } member_v2; - - struct - { - short int id; - short int attribute; - unsigned int type; - unsigned short int offset; /* numeric leaf */ -#if 0 - unsigned char name[1]; -#endif - } - member_v3; - - struct - { - short int id; - short int type; - short int attribute; - struct p_string p_name; - } stmember_v1; - - struct - { - short int id; - short int attribute; - unsigned int type; - struct p_string p_name; - } stmember_v2; - - struct - { - short int id; - short int count; - short int mlist; - struct p_string p_name; - } method_v1; - - struct - { - short int id; - short int count; - unsigned int mlist; - struct p_string p_name; - } method_v2; - - struct - { - short int id; - short int index; - struct p_string p_name; - } nesttype_v1; - - struct - { - short int id; - short int _pad0; - unsigned int index; - struct p_string p_name; - } nesttype_v2; - - struct - { - short int id; - short int type; - } vfunctab_v1; - - struct - { - short int id; - short int _pad0; - unsigned int type; - } vfunctab_v2; - - struct - { - short int id; - short int type; - } friendcls_v1; - - struct - { - short int id; - short int _pad0; - unsigned int type; - } friendcls_v2; - - struct - { - short int id; - short int attribute; - short int type; - struct p_string p_name; - } onemethod_v1; - - struct - { - short int id; - short int attribute; - short int type; - unsigned int vtab_offset; - struct p_string p_name; - } onemethod_virt_v1; - - struct - { - short int id; - short int attribute; - unsigned int type; - struct p_string p_name; - } onemethod_v2; - - struct - { - short int id; - short int attribute; - unsigned int type; - unsigned int vtab_offset; - struct p_string p_name; - } onemethod_virt_v2; - - struct - { - short int id; - short int type; - unsigned int offset; - } vfuncoff_v1; - - struct - { - short int id; - short int _pad0; - unsigned int type; - unsigned int offset; - } vfuncoff_v2; - - struct - { - short int id; - short int attribute; - short int index; - struct p_string p_name; - } nesttypeex_v1; - - struct - { - short int id; - short int attribute; - unsigned int index; - struct p_string p_name; - } nesttypeex_v2; - - struct - { - short int id; - short int attribute; - unsigned int type; - struct p_string p_name; - } membermodify_v2; - -}; - - -/* - * This covers the basic datatypes that VC++ seems to be using these days. - * 32 bit mode only. There are additional numbers for the pointers in 16 - * bit mode. There are many other types listed in the documents, but these - * are apparently not used by the compiler, or represent pointer types - * that are not used. - */ -#define T_NOTYPE 0x0000 /* Notype */ -#define T_ABS 0x0001 /* Abs */ -#define T_VOID 0x0003 /* Void */ -#define T_CHAR 0x0010 /* signed char */ -#define T_SHORT 0x0011 /* short */ -#define T_LONG 0x0012 /* long */ -#define T_QUAD 0x0013 /* long long */ -#define T_UCHAR 0x0020 /* unsigned char */ -#define T_USHORT 0x0021 /* unsigned short */ -#define T_ULONG 0x0022 /* unsigned long */ -#define T_UQUAD 0x0023 /* unsigned long long */ -#define T_REAL32 0x0040 /* float */ -#define T_REAL64 0x0041 /* double */ -#define T_RCHAR 0x0070 /* real char */ -#define T_WCHAR 0x0071 /* wide char */ -#define T_INT4 0x0074 /* int */ -#define T_UINT4 0x0075 /* unsigned int */ - -#define T_32PVOID 0x0403 /* 32 bit near pointer to void */ -#define T_32PCHAR 0x0410 /* 16:32 near pointer to signed char */ -#define T_32PSHORT 0x0411 /* 16:32 near pointer to short */ -#define T_32PLONG 0x0412 /* 16:32 near pointer to int */ -#define T_32PQUAD 0x0413 /* 16:32 near pointer to long long */ -#define T_32PUCHAR 0x0420 /* 16:32 near pointer to unsigned char */ -#define T_32PUSHORT 0x0421 /* 16:32 near pointer to unsigned short */ -#define T_32PULONG 0x0422 /* 16:32 near pointer to unsigned int */ -#define T_32PUQUAD 0x0423 /* 16:32 near pointer to long long */ -#define T_32PREAL32 0x0440 /* 16:32 near pointer to float */ -#define T_32PREAL64 0x0441 /* 16:32 near pointer to float */ -#define T_32PRCHAR 0x0470 /* 16:32 near pointer to real char */ -#define T_32PWCHAR 0x0471 /* 16:32 near pointer to real char */ -#define T_32PINT4 0x0474 /* 16:32 near pointer to int */ -#define T_32PUINT4 0x0475 /* 16:32 near pointer to unsigned int */ - - -#define LF_MODIFIER_V1 0x0001 -#define LF_POINTER_V1 0x0002 -#define LF_ARRAY_V1 0x0003 -#define LF_CLASS_V1 0x0004 -#define LF_STRUCTURE_V1 0x0005 -#define LF_UNION_V1 0x0006 -#define LF_ENUM_V1 0x0007 -#define LF_PROCEDURE_V1 0x0008 -#define LF_MFUNCTION_V1 0x0009 -#define LF_VTSHAPE_V1 0x000a -#define LF_COBOL0_V1 0x000b -#define LF_COBOL1_V1 0x000c -#define LF_BARRAY_V1 0x000d -#define LF_LABEL_V1 0x000e -#define LF_NULL_V1 0x000f -#define LF_NOTTRAN_V1 0x0010 -#define LF_DIMARRAY_V1 0x0011 -#define LF_VFTPATH_V1 0x0012 -#define LF_PRECOMP_V1 0x0013 -#define LF_ENDPRECOMP_V1 0x0014 -#define LF_OEM_V1 0x0015 -#define LF_TYPESERVER_V1 0x0016 - -#define LF_MODIFIER_V2 0x1001 /* variants with new 32-bit type indices (V2) */ -#define LF_POINTER_V2 0x1002 -#define LF_ARRAY_V2 0x1003 -#define LF_CLASS_V2 0x1004 -#define LF_STRUCTURE_V2 0x1005 -#define LF_UNION_V2 0x1006 -#define LF_ENUM_V2 0x1007 -#define LF_PROCEDURE_V2 0x1008 -#define LF_MFUNCTION_V2 0x1009 -#define LF_COBOL0_V2 0x100a -#define LF_BARRAY_V2 0x100b -#define LF_DIMARRAY_V2 0x100c -#define LF_VFTPATH_V2 0x100d -#define LF_PRECOMP_V2 0x100e -#define LF_OEM_V2 0x100f - -#define LF_SKIP_V1 0x0200 -#define LF_ARGLIST_V1 0x0201 -#define LF_DEFARG_V1 0x0202 -#define LF_LIST_V1 0x0203 -#define LF_FIELDLIST_V1 0x0204 -#define LF_DERIVED_V1 0x0205 -#define LF_BITFIELD_V1 0x0206 -#define LF_METHODLIST_V1 0x0207 -#define LF_DIMCONU_V1 0x0208 -#define LF_DIMCONLU_V1 0x0209 -#define LF_DIMVARU_V1 0x020a -#define LF_DIMVARLU_V1 0x020b -#define LF_REFSYM_V1 0x020c - -#define LF_SKIP_V2 0x1200 /* variants with new 32-bit type indices (V2) */ -#define LF_ARGLIST_V2 0x1201 -#define LF_DEFARG_V2 0x1202 -#define LF_FIELDLIST_V2 0x1203 -#define LF_DERIVED_V2 0x1204 -#define LF_BITFIELD_V2 0x1205 -#define LF_METHODLIST_V2 0x1206 -#define LF_DIMCONU_V2 0x1207 -#define LF_DIMCONLU_V2 0x1208 -#define LF_DIMVARU_V2 0x1209 -#define LF_DIMVARLU_V2 0x120a - -/* Field lists */ -#define LF_BCLASS_V1 0x0400 -#define LF_VBCLASS_V1 0x0401 -#define LF_IVBCLASS_V1 0x0402 -#define LF_ENUMERATE_V1 0x0403 -#define LF_FRIENDFCN_V1 0x0404 -#define LF_INDEX_V1 0x0405 -#define LF_MEMBER_V1 0x0406 -#define LF_STMEMBER_V1 0x0407 -#define LF_METHOD_V1 0x0408 -#define LF_NESTTYPE_V1 0x0409 -#define LF_VFUNCTAB_V1 0x040a -#define LF_FRIENDCLS_V1 0x040b -#define LF_ONEMETHOD_V1 0x040c -#define LF_VFUNCOFF_V1 0x040d -#define LF_NESTTYPEEX_V1 0x040e -#define LF_MEMBERMODIFY_V1 0x040f - -#define LF_BCLASS_V2 0x1400 /* variants with new 32-bit type indices (V2) */ -#define LF_VBCLASS_V2 0x1401 -#define LF_IVBCLASS_V2 0x1402 -#define LF_FRIENDFCN_V2 0x1403 -#define LF_INDEX_V2 0x1404 -#define LF_MEMBER_V2 0x1405 -#define LF_STMEMBER_V2 0x1406 -#define LF_METHOD_V2 0x1407 -#define LF_NESTTYPE_V2 0x1408 -#define LF_VFUNCTAB_V2 0x1409 -#define LF_FRIENDCLS_V2 0x140a -#define LF_ONEMETHOD_V2 0x140b -#define LF_VFUNCOFF_V2 0x140c -#define LF_NESTTYPEEX_V2 0x140d - -#define LF_ENUMERATE_V3 0x1502 -#define LF_ARRAY_V3 0x1503 -#define LF_CLASS_V3 0x1504 -#define LF_STRUCTURE_V3 0x1505 -#define LF_UNION_V3 0x1506 -#define LF_ENUM_V3 0x1507 -#define LF_MEMBER_V3 0x150d - -#define LF_NUMERIC 0x8000 /* numeric leaf types */ -#define LF_CHAR 0x8000 -#define LF_SHORT 0x8001 -#define LF_USHORT 0x8002 -#define LF_LONG 0x8003 -#define LF_ULONG 0x8004 -#define LF_REAL32 0x8005 -#define LF_REAL64 0x8006 -#define LF_REAL80 0x8007 -#define LF_REAL128 0x8008 -#define LF_QUADWORD 0x8009 -#define LF_UQUADWORD 0x800a -#define LF_REAL48 0x800b -#define LF_COMPLEX32 0x800c -#define LF_COMPLEX64 0x800d -#define LF_COMPLEX80 0x800e -#define LF_COMPLEX128 0x800f -#define LF_VARSTRING 0x8010 - -/* ======================================== * - * Symbol information - * ======================================== */ - -union codeview_symbol -{ - struct - { - short int len; - short int id; - } generic; - - struct - { - short int len; - short int id; - unsigned int offset; - unsigned short segment; - unsigned short symtype; - struct p_string p_name; - } data_v1; - - struct - { - short int len; - short int id; - unsigned int symtype; - unsigned int offset; - unsigned short segment; - struct p_string p_name; - } data_v2; - - struct - { - short int len; - short int id; - unsigned int symtype; - unsigned int offset; - unsigned short segment; - char name[1]; - } data_v3; - - struct - { - short int len; - short int id; - unsigned int pparent; - unsigned int pend; - unsigned int next; - unsigned int offset; - unsigned short segment; - unsigned short thunk_len; - unsigned char thtype; - struct p_string p_name; - } thunk_v1; - - struct - { - short int len; - short int id; - unsigned int pparent; - unsigned int pend; - unsigned int next; - unsigned int offset; - unsigned short segment; - unsigned short thunk_len; - unsigned char thtype; - char name[1]; - } thunk_v3; - - struct - { - short int len; - short int id; - unsigned int pparent; - unsigned int pend; - unsigned int next; - unsigned int proc_len; - unsigned int debug_start; - unsigned int debug_end; - unsigned int offset; - unsigned short segment; - unsigned short proctype; - unsigned char flags; - struct p_string p_name; - } proc_v1; - - struct - { - short int len; - short int id; - unsigned int pparent; - unsigned int pend; - unsigned int next; - unsigned int proc_len; - unsigned int debug_start; - unsigned int debug_end; - unsigned int proctype; - unsigned int offset; - unsigned short segment; - unsigned char flags; - struct p_string p_name; - } proc_v2; - - struct - { - short int len; - short int id; - unsigned int pparent; - unsigned int pend; - unsigned int next; - unsigned int proc_len; - unsigned int debug_start; - unsigned int debug_end; - unsigned int proctype; - unsigned int offset; - unsigned short segment; - unsigned char flags; - char name[1]; - } proc_v3; - - struct - { - short int len; /* Total length of this entry */ - short int id; /* Always S_BPREL_V1 */ - unsigned int offset; /* Stack offset relative to BP */ - unsigned short symtype; - struct p_string p_name; - } stack_v1; - - struct - { - short int len; /* Total length of this entry */ - short int id; /* Always S_BPREL_V2 */ - unsigned int offset; /* Stack offset relative to EBP */ - unsigned int symtype; - struct p_string p_name; - } stack_v2; - - struct - { - short int len; /* Total length of this entry */ - short int id; /* Always S_BPREL_V3 */ - int offset; /* Stack offset relative to BP */ - unsigned int symtype; - char name[1]; - } stack_v3; - - struct - { - short int len; /* Total length of this entry */ - short int id; /* Always S_REGISTER */ - unsigned short type; - unsigned short reg; - struct p_string p_name; - /* don't handle register tracking */ - } register_v1; - - struct - { - short int len; /* Total length of this entry */ - short int id; /* Always S_REGISTER_V2 */ - unsigned int type; /* check whether type & reg are correct */ - unsigned int reg; - struct p_string p_name; - /* don't handle register tracking */ - } register_v2; - - struct - { - short int len; - short int id; - unsigned int parent; - unsigned int end; - unsigned int length; - unsigned int offset; - unsigned short segment; - struct p_string p_name; - } block_v1; - - struct - { - short int len; - short int id; - unsigned int parent; - unsigned int end; - unsigned int length; - unsigned int offset; - unsigned short segment; - char name[1]; - } block_v3; - - struct - { - short int len; - short int id; - unsigned int offset; - unsigned short segment; - unsigned char flags; - struct p_string p_name; - } label_v1; - - struct - { - short int len; - short int id; - unsigned int offset; - unsigned short segment; - unsigned char flags; - char name[1]; - } label_v3; - - struct - { - short int len; - short int id; - unsigned short type; - unsigned short cvalue; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } constant_v1; - - struct - { - short int len; - short int id; - unsigned type; - unsigned short cvalue; /* numeric leaf */ -#if 0 - struct p_string p_name; -#endif - } constant_v2; - - struct - { - short int len; - short int id; - unsigned type; - unsigned short cvalue; -#if 0 - char name[1]; -#endif - } constant_v3; - - struct - { - short int len; - short int id; - unsigned short type; - struct p_string p_name; - } udt_v1; - - struct - { - short int len; - short int id; - unsigned type; - struct p_string p_name; - } udt_v2; - - struct - { - short int len; - short int id; - unsigned int type; - char name[1]; - } udt_v3; - - struct - { - short int len; - short int id; - unsigned int unknown; - struct p_string p_name; - } compiland_v1; - - struct - { - short int len; - short int id; - unsigned unknown1[4]; - unsigned short unknown2; - struct p_string p_name; - } compiland_v2; - - struct - { - short int len; - short int id; - unsigned int unknown; - char name[1]; - } compiland_v3; -}; - -#define S_COMPILAND_V1 0x0001 -#define S_REGISTER_V1 0x0002 -#define S_CONSTANT_V1 0x0003 -#define S_UDT_V1 0x0004 -#define S_SSEARCH_V1 0x0005 -#define S_END_V1 0x0006 -#define S_SKIP_V1 0x0007 -#define S_CVRESERVE_V1 0x0008 -#define S_OBJNAME_V1 0x0009 -#define S_ENDARG_V1 0x000a -#define S_COBOLUDT_V1 0x000b -#define S_MANYREG_V1 0x000c -#define S_RETURN_V1 0x000d -#define S_ENTRYTHIS_V1 0x000e - -#define S_BPREL_V1 0x0200 -#define S_LDATA_V1 0x0201 -#define S_GDATA_V1 0x0202 -#define S_PUB_V1 0x0203 -#define S_LPROC_V1 0x0204 -#define S_GPROC_V1 0x0205 -#define S_THUNK_V1 0x0206 -#define S_BLOCK_V1 0x0207 -#define S_WITH_V1 0x0208 -#define S_LABEL_V1 0x0209 -#define S_CEXMODEL_V1 0x020a -#define S_VFTPATH_V1 0x020b -#define S_REGREL_V1 0x020c -#define S_LTHREAD_V1 0x020d -#define S_GTHREAD_V1 0x020e - -#define S_PROCREF_V1 0x0400 -#define S_DATAREF_V1 0x0401 -#define S_ALIGN_V1 0x0402 -#define S_LPROCREF_V1 0x0403 - -#define S_REGISTER_V2 0x1001 /* Variants with new 32-bit type indices */ -#define S_CONSTANT_V2 0x1002 -#define S_UDT_V2 0x1003 -#define S_COBOLUDT_V2 0x1004 -#define S_MANYREG_V2 0x1005 -#define S_BPREL_V2 0x1006 -#define S_LDATA_V2 0x1007 -#define S_GDATA_V2 0x1008 -#define S_PUB_V2 0x1009 -#define S_LPROC_V2 0x100a -#define S_GPROC_V2 0x100b -#define S_VFTTABLE_V2 0x100c -#define S_REGREL_V2 0x100d -#define S_LTHREAD_V2 0x100e -#define S_GTHREAD_V2 0x100f -#if 0 -#define S_XXXXXXXXX_32 0x1012 /* seems linked to a function, content unknown */ -#endif -#define S_COMPILAND_V2 0x1013 - -#define S_COMPILAND_V3 0x1101 -#define S_THUNK_V3 0x1102 -#define S_BLOCK_V3 0x1103 -#define S_LABEL_V3 0x1105 -#define S_CONSTANT_V3 0x1107 -#define S_UDT_V3 0x1108 -#define S_BPREL_V3 0x110B -#define S_LDATA_V3 0x110C -#define S_GDATA_V3 0x110D -#define S_PUB_DATA_V3 0x110E -#define S_LPROC_V3 0x110F -#define S_GPROC_V3 0x1110 -#define S_MSTOOL_V3 0x1116 /* not really understood */ -#define S_PUB_FUNC1_V3 0x1125 /* didn't get the difference between the two */ -#define S_PUB_FUNC2_V3 0x1127 - -/* ======================================== * - * Line number information - * ======================================== */ - -union any_size -{ - const char* c; - const short* s; - const int* i; - const unsigned int* ui; -}; - -struct startend -{ - unsigned int start; - unsigned int end; -}; - -struct codeview_linetab -{ - unsigned int nline; - unsigned int segno; - unsigned int start; - unsigned int end; - struct symt_compiland* compiland; - const unsigned short* linetab; - const unsigned int* offtab; -}; - - -/* ======================================== * - * PDB file information - * ======================================== */ - - -struct PDB_FILE -{ - DWORD size; - DWORD unknown; -}; - -struct PDB_JG_HEADER -{ - CHAR ident[40]; - DWORD signature; - DWORD block_size; - WORD free_list; - WORD total_alloc; - struct PDB_FILE toc; - WORD toc_block[1]; -}; - -struct PDB_DS_HEADER -{ - char signature[32]; - DWORD block_size; - DWORD unknown1; - DWORD num_pages; - DWORD toc_size; - DWORD unknown2; - DWORD toc_page; -}; - -struct PDB_JG_TOC -{ - DWORD num_files; - struct PDB_FILE file[1]; -}; - -struct PDB_DS_TOC -{ - DWORD num_files; - DWORD file_size[1]; -}; - -struct PDB_JG_ROOT -{ - DWORD Version; - DWORD TimeDateStamp; - DWORD unknown; - DWORD cbNames; - CHAR names[1]; -}; - -struct PDB_DS_ROOT -{ - DWORD Version; - DWORD TimeDateStamp; - DWORD unknown; - GUID guid; - DWORD cbNames; - CHAR names[1]; -}; - -typedef struct _PDB_TYPES_OLD -{ - DWORD version; - WORD first_index; - WORD last_index; - DWORD type_size; - WORD file; - WORD pad; -} PDB_TYPES_OLD, *PPDB_TYPES_OLD; - -typedef struct _PDB_TYPES -{ - DWORD version; - DWORD type_offset; - DWORD first_index; - DWORD last_index; - DWORD type_size; - WORD file; - WORD pad; - DWORD hash_size; - DWORD hash_base; - DWORD hash_offset; - DWORD hash_len; - DWORD search_offset; - DWORD search_len; - DWORD unknown_offset; - DWORD unknown_len; -} PDB_TYPES, *PPDB_TYPES; - -typedef struct _PDB_SYMBOL_RANGE -{ - WORD segment; - WORD pad1; - DWORD offset; - DWORD size; - DWORD characteristics; - WORD index; - WORD pad2; -} PDB_SYMBOL_RANGE, *PPDB_SYMBOL_RANGE; - -typedef struct _PDB_SYMBOL_RANGE_EX -{ - WORD segment; - WORD pad1; - DWORD offset; - DWORD size; - DWORD characteristics; - WORD index; - WORD pad2; - DWORD timestamp; - DWORD unknown; -} PDB_SYMBOL_RANGE_EX, *PPDB_SYMBOL_RANGE_EX; - -typedef struct _PDB_SYMBOL_FILE -{ - DWORD unknown1; - PDB_SYMBOL_RANGE range; - WORD flag; - WORD file; - DWORD symbol_size; - DWORD lineno_size; - DWORD unknown2; - DWORD nSrcFiles; - DWORD attribute; - CHAR filename[1]; -} PDB_SYMBOL_FILE, *PPDB_SYMBOL_FILE; - -typedef struct _PDB_SYMBOL_FILE_EX -{ - DWORD unknown1; - PDB_SYMBOL_RANGE_EX range; - WORD flag; - WORD file; - DWORD symbol_size; - DWORD lineno_size; - DWORD unknown2; - DWORD nSrcFiles; - DWORD attribute; - DWORD reserved[2]; - CHAR filename[1]; -} PDB_SYMBOL_FILE_EX, *PPDB_SYMBOL_FILE_EX; - -typedef struct _PDB_SYMBOL_SOURCE -{ - WORD nModules; - WORD nSrcFiles; - WORD table[1]; -} PDB_SYMBOL_SOURCE, *PPDB_SYMBOL_SOURCE; - -typedef struct _PDB_SYMBOL_IMPORT -{ - DWORD unknown1; - DWORD unknown2; - DWORD TimeDateStamp; - DWORD nRequests; - CHAR filename[1]; -} PDB_SYMBOL_IMPORT, *PPDB_SYMBOL_IMPORT; - -typedef struct _PDB_SYMBOLS_OLD -{ - WORD hash1_file; - WORD hash2_file; - WORD gsym_file; - WORD pad; - DWORD module_size; - DWORD offset_size; - DWORD hash_size; - DWORD srcmodule_size; -} PDB_SYMBOLS_OLD, *PPDB_SYMBOLS_OLD; - -typedef struct _PDB_SYMBOLS -{ - DWORD signature; - DWORD version; - DWORD unknown; - DWORD hash1_file; - DWORD hash2_file; - DWORD gsym_file; - DWORD module_size; - DWORD offset_size; - DWORD hash_size; - DWORD srcmodule_size; - DWORD pdbimport_size; - DWORD resvd[5]; -} PDB_SYMBOLS, *PPDB_SYMBOLS; - -#include "poppack.h" - -/* ---------------------------------------------- - * Information used for parsing - * ---------------------------------------------- */ - -typedef struct -{ - DWORD from; - DWORD to; -} OMAP_DATA; - -struct msc_debug_info -{ - struct module* module; - int nsect; - const IMAGE_SECTION_HEADER* sectp; - int nomap; - const OMAP_DATA* omapp; - const BYTE* root; -}; - -/* coff.c */ -extern BOOL coff_process_info(const struct msc_debug_info* msc_dbg); diff --git a/reactos/dll/win32/dbghelp/path.c b/reactos/dll/win32/dbghelp/path.c index 59be299f370..2e191af791d 100644 --- a/reactos/dll/win32/dbghelp/path.c +++ b/reactos/dll/win32/dbghelp/path.c @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -24,25 +24,36 @@ #include #include "dbghelp_private.h" +#include "winnls.h" +#include "winternl.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); -static __inline BOOL is_sep(char ch) {return ch == '/' || ch == '\\';} +static inline BOOL is_sep(char ch) {return ch == '/' || ch == '\\';} +static inline BOOL is_sepW(WCHAR ch) {return ch == '/' || ch == '\\';} -static __inline char* file_name(char* str) +static inline const char* file_name(const char* str) { - char* p; + const char* p; for (p = str + strlen(str) - 1; p >= str && !is_sep(*p); p--); return p + 1; } +static inline const WCHAR* file_nameW(const WCHAR* str) +{ + const WCHAR* p; + + for (p = str + strlenW(str) - 1; p >= str && !is_sepW(*p); p--); + return p + 1; +} + /****************************************************************** * FindDebugInfoFile (DBGHELP.@) * */ -HANDLE WINAPI FindDebugInfoFile(PSTR FileName, PSTR SymbolPath, PSTR DebugFilePath) +HANDLE WINAPI FindDebugInfoFile(PCSTR FileName, PCSTR SymbolPath, PSTR DebugFilePath) { HANDLE h; @@ -57,28 +68,48 @@ HANDLE WINAPI FindDebugInfoFile(PSTR FileName, PSTR SymbolPath, PSTR DebugFilePa } return (h == INVALID_HANDLE_VALUE) ? NULL : h; } - + /****************************************************************** * FindDebugInfoFileEx (DBGHELP.@) * */ -HANDLE WINAPI FindDebugInfoFileEx(PSTR FileName, PSTR SymbolPath, - PSTR DebugFilePath, +HANDLE WINAPI FindDebugInfoFileEx(PCSTR FileName, PCSTR SymbolPath, + PSTR DebugFilePath, PFIND_DEBUG_FILE_CALLBACK Callback, PVOID CallerData) { - FIXME("(%s %s %p %p %p): stub\n", + FIXME("(%s %s %p %p %p): stub\n", FileName, SymbolPath, DebugFilePath, Callback, CallerData); return NULL; } /****************************************************************** - * FindExecutableImage (DBGHELP.@) + * FindExecutableImageExW (DBGHELP.@) * */ -HANDLE WINAPI FindExecutableImage(PSTR FileName, PSTR SymbolPath, PSTR ImageFilePath) +HANDLE WINAPI FindExecutableImageExW(PCWSTR FileName, PCWSTR SymbolPath, PWSTR ImageFilePath, + PFIND_EXE_FILE_CALLBACKW Callback, PVOID user) { HANDLE h; + + if (Callback) FIXME("Unsupported callback yet\n"); + if (!SearchPathW(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL)) + return NULL; + h = CreateFileW(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + return (h == INVALID_HANDLE_VALUE) ? NULL : h; +} + +/****************************************************************** + * FindExecutableImageEx (DBGHELP.@) + * + */ +HANDLE WINAPI FindExecutableImageEx(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath, + PFIND_EXE_FILE_CALLBACK Callback, PVOID user) +{ + HANDLE h; + + if (Callback) FIXME("Unsupported callback yet\n"); if (!SearchPathA(SymbolPath, FileName, NULL, MAX_PATH, ImageFilePath, NULL)) return NULL; h = CreateFileA(ImageFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, @@ -86,10 +117,19 @@ HANDLE WINAPI FindExecutableImage(PSTR FileName, PSTR SymbolPath, PSTR ImageFile return (h == INVALID_HANDLE_VALUE) ? NULL : h; } +/****************************************************************** + * FindExecutableImage (DBGHELP.@) + * + */ +HANDLE WINAPI FindExecutableImage(PCSTR FileName, PCSTR SymbolPath, PSTR ImageFilePath) +{ + return FindExecutableImageEx(FileName, SymbolPath, ImageFilePath, NULL, NULL); +} + /*********************************************************************** * MakeSureDirectoryPathExists (DBGHELP.@) */ -BOOL WINAPI MakeSureDirectoryPathExists(LPCSTR DirPath) +BOOL WINAPI MakeSureDirectoryPathExists(PCSTR DirPath) { char path[MAX_PATH]; const char *p = DirPath; @@ -113,15 +153,43 @@ BOOL WINAPI MakeSureDirectoryPathExists(LPCSTR DirPath) return TRUE; } +/****************************************************************** + * SymMatchFileNameW (DBGHELP.@) + * + */ +BOOL WINAPI SymMatchFileNameW(PCWSTR file, PCWSTR match, + PWSTR* filestop, PWSTR* matchstop) +{ + PCWSTR fptr; + PCWSTR mptr; + + TRACE("(%s %s %p %p)\n", + debugstr_w(file), debugstr_w(match), filestop, matchstop); + + fptr = file + strlenW(file) - 1; + mptr = match + strlenW(match) - 1; + + while (fptr >= file && mptr >= match) + { + if (toupperW(*fptr) != toupperW(*mptr) && !(is_sepW(*fptr) && is_sepW(*mptr))) + break; + fptr--; mptr--; + } + if (filestop) *filestop = (PWSTR)fptr; + if (matchstop) *matchstop = (PWSTR)mptr; + + return mptr == match - 1; +} + /****************************************************************** * SymMatchFileName (DBGHELP.@) * */ -BOOL WINAPI SymMatchFileName(char* file, char* match, - char** filestop, char** matchstop) +BOOL WINAPI SymMatchFileName(PCSTR file, PCSTR match, + PSTR* filestop, PSTR* matchstop) { - char* fptr; - char* mptr; + PCSTR fptr; + PCSTR mptr; TRACE("(%s %s %p %p)\n", file, match, filestop, matchstop); @@ -134,40 +202,43 @@ BOOL WINAPI SymMatchFileName(char* file, char* match, break; fptr--; mptr--; } - if (filestop) *filestop = fptr; - if (matchstop) *matchstop = mptr; + if (filestop) *filestop = (PSTR)fptr; + if (matchstop) *matchstop = (PSTR)mptr; return mptr == match - 1; } -static BOOL do_search(const char* file, char* buffer, - PENUMDIRTREE_CALLBACK cb, void* user) +static BOOL do_searchW(PCWSTR file, PWSTR buffer, BOOL recurse, + PENUMDIRTREE_CALLBACKW cb, PVOID user) { HANDLE h; - WIN32_FIND_DATAA fd; + WIN32_FIND_DATAW fd; unsigned pos; BOOL found = FALSE; + static const WCHAR S_AllW[] = {'*','.','*','\0'}; + static const WCHAR S_DotW[] = {'.','\0'}; + static const WCHAR S_DotDotW[] = {'.','\0'}; - pos = strlen(buffer); + pos = strlenW(buffer); if (buffer[pos - 1] != '\\') buffer[pos++] = '\\'; - strcpy(buffer + pos, "*.*"); - if ((h = FindFirstFileA(buffer, &fd)) == INVALID_HANDLE_VALUE) + strcpyW(buffer + pos, S_AllW); + if ((h = FindFirstFileW(buffer, &fd)) == INVALID_HANDLE_VALUE) return FALSE; /* doc doesn't specify how the tree is enumerated... * doing a depth first based on, but may be wrong */ do { - if (!strcmp(fd.cFileName, ".") || !strcmp(fd.cFileName, "..")) continue; + if (!strcmpW(fd.cFileName, S_DotW) || !strcmpW(fd.cFileName, S_DotDotW)) continue; - strcpy(buffer + pos, fd.cFileName); - if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) - found = do_search(file, buffer, cb, user); - else if (SymMatchFileName(buffer, (char*)file, NULL, NULL)) + strcpyW(buffer + pos, fd.cFileName); + if (recurse && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + found = do_searchW(file, buffer, TRUE, cb, user); + else if (SymMatchFileNameW(buffer, (WCHAR*)file, NULL, NULL)) { if (!cb || cb(buffer, user)) found = TRUE; } - } while (!found && FindNextFileA(h, &fd)); + } while (!found && FindNextFileW(h, &fd)); if (!found) buffer[--pos] = '\0'; FindClose(h); @@ -175,14 +246,47 @@ static BOOL do_search(const char* file, char* buffer, } /*********************************************************************** - * SearchTreeForFile (DBGHELP.@) + * SearchTreeForFileW (DBGHELP.@) */ -BOOL WINAPI SearchTreeForFile(LPSTR root, LPSTR file, LPSTR buffer) +BOOL WINAPI SearchTreeForFileW(PCWSTR root, PCWSTR file, PWSTR buffer) { TRACE("(%s, %s, %p)\n", - debugstr_a(root), debugstr_a(file), buffer); - strcpy(buffer, root); - return do_search(file, buffer, NULL, NULL); + debugstr_w(root), debugstr_w(file), buffer); + strcpyW(buffer, root); + return do_searchW(file, buffer, TRUE, NULL, NULL); +} + +/*********************************************************************** + * SearchTreeForFile (DBGHELP.@) + */ +BOOL WINAPI SearchTreeForFile(PCSTR root, PCSTR file, PSTR buffer) +{ + WCHAR rootW[MAX_PATH]; + WCHAR fileW[MAX_PATH]; + WCHAR bufferW[MAX_PATH]; + BOOL ret; + + MultiByteToWideChar(CP_ACP, 0, root, -1, rootW, MAX_PATH); + MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH); + ret = SearchTreeForFileW(rootW, fileW, bufferW); + if (ret) + WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL); + return ret; +} + +/****************************************************************** + * EnumDirTreeW (DBGHELP.@) + * + * + */ +BOOL WINAPI EnumDirTreeW(HANDLE hProcess, PCWSTR root, PCWSTR file, + PWSTR buffer, PENUMDIRTREE_CALLBACKW cb, PVOID user) +{ + TRACE("(%p %s %s %p %p %p)\n", + hProcess, debugstr_w(root), debugstr_w(file), buffer, cb, user); + + strcpyW(buffer, root); + return do_searchW(file, buffer, TRUE, cb, user); } /****************************************************************** @@ -190,55 +294,193 @@ BOOL WINAPI SearchTreeForFile(LPSTR root, LPSTR file, LPSTR buffer) * * */ -BOOL WINAPI EnumDirTree(HANDLE hProcess, PCSTR root, PCSTR file, - LPSTR buffer, PENUMDIRTREE_CALLBACK cb, PVOID user) +struct enum_dir_treeWA { - TRACE("(%p %s %s %p %p %p)\n", hProcess, root, file, buffer, cb, user); + PENUMDIRTREE_CALLBACK cb; + void* user; + char name[MAX_PATH]; +}; - strcpy(buffer, root); - return do_search(file, buffer, cb, user); +static BOOL CALLBACK enum_dir_treeWA(PCWSTR name, PVOID user) +{ + struct enum_dir_treeWA* edt = user; + + WideCharToMultiByte(CP_ACP, 0, name, -1, edt->name, MAX_PATH, NULL, NULL); + return edt->cb(edt->name, edt->user); +} + +BOOL WINAPI EnumDirTree(HANDLE hProcess, PCSTR root, PCSTR file, + PSTR buffer, PENUMDIRTREE_CALLBACK cb, PVOID user) +{ + WCHAR rootW[MAX_PATH]; + WCHAR fileW[MAX_PATH]; + WCHAR bufferW[MAX_PATH]; + struct enum_dir_treeWA edt; + BOOL ret; + + edt.cb = cb; + edt.user = user; + MultiByteToWideChar(CP_ACP, 0, root, -1, rootW, MAX_PATH); + MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, MAX_PATH); + if ((ret = EnumDirTreeW(hProcess, rootW, fileW, bufferW, enum_dir_treeWA, &edt))) + WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL); + return ret; } struct sffip { + enum module_type kind; + /* pe: id -> DWORD:timestamp + * two -> size of image (from PE header) + * pdb: id -> PDB signature + * I think either DWORD:timestamp or GUID:guid depending on PDB version + * two -> PDB age ??? + * elf: id -> DWORD:CRC 32 of ELF image (Wine only) + */ PVOID id; DWORD two; DWORD three; DWORD flags; - PFINDFILEINPATHCALLBACK cb; + PFINDFILEINPATHCALLBACKW cb; void* user; }; -static BOOL CALLBACK sffip_cb(LPCSTR buffer, void* user) +/* checks that buffer (as found by matching the name) matches the info + * (information is based on file type) + * returns TRUE when file is found, FALSE to continue searching + * (NB this is the opposite convention of SymFindFileInPathProc) + */ +static BOOL CALLBACK sffip_cb(PCWSTR buffer, PVOID user) { struct sffip* s = (struct sffip*)user; + DWORD size, checksum; /* FIXME: should check that id/two/three match the file pointed * by buffer */ - /* yes, EnumDirTree and SymFindFileInPath callbacks use the opposite + switch (s->kind) + { + case DMT_PE: + { + HANDLE hFile, hMap; + void* mapping; + DWORD timestamp; + + timestamp = ~(DWORD_PTR)s->id; + size = ~s->two; + hFile = CreateFileW(buffer, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (hFile == INVALID_HANDLE_VALUE) return FALSE; + if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL) + { + if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL) + { + IMAGE_NT_HEADERS* nth = RtlImageNtHeader(mapping); + timestamp = nth->FileHeader.TimeDateStamp; + size = nth->OptionalHeader.SizeOfImage; + UnmapViewOfFile(mapping); + } + CloseHandle(hMap); + } + CloseHandle(hFile); + if (timestamp != (DWORD_PTR)s->id || size != s->two) + { + WARN("Found %s, but wrong size or timestamp\n", debugstr_w(buffer)); + return FALSE; + } + } + break; + case DMT_ELF: + if (elf_fetch_file_info(buffer, 0, &size, &checksum)) + { + if (checksum != (DWORD_PTR)s->id) + { + WARN("Found %s, but wrong checksums: %08x %08lx\n", + debugstr_w(buffer), checksum, (DWORD_PTR)s->id); + return FALSE; + } + } + else + { + WARN("Couldn't read %s\n", debugstr_w(buffer)); + return FALSE; + } + break; + case DMT_PDB: + { + struct pdb_lookup pdb_lookup; + char fn[MAX_PATH]; + + WideCharToMultiByte(CP_ACP, 0, buffer, -1, fn, MAX_PATH, NULL, NULL); + pdb_lookup.filename = fn; + + if (!pdb_fetch_file_info(&pdb_lookup)) return FALSE; + switch (pdb_lookup.kind) + { + case PDB_JG: + if (s->flags & SSRVOPT_GUIDPTR) + { + WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer)); + return FALSE; + } + if (pdb_lookup.u.jg.timestamp != (DWORD_PTR)s->id) + { + WARN("Found %s, but wrong signature: %08x %08lx\n", + debugstr_w(buffer), pdb_lookup.u.jg.timestamp, (DWORD_PTR)s->id); + return FALSE; + } + break; + case PDB_DS: + if (!(s->flags & SSRVOPT_GUIDPTR)) + { + WARN("Found %s, but wrong PDB version\n", debugstr_w(buffer)); + return FALSE; + } + if (memcmp(&pdb_lookup.u.ds.guid, (GUID*)s->id, sizeof(GUID))) + { + WARN("Found %s, but wrong GUID: %s %s\n", + debugstr_w(buffer), debugstr_guid(&pdb_lookup.u.ds.guid), + debugstr_guid((GUID*)s->id)); + return FALSE; + } + break; + } + if (pdb_lookup.age != s->two) + { + WARN("Found %s, but wrong age: %08x %08x\n", + debugstr_w(buffer), pdb_lookup.age, s->two); + return FALSE; + } + } + break; + default: + FIXME("What the heck??\n"); + return FALSE; + } + /* yes, EnumDirTree/do_search and SymFindFileInPath callbacks use the opposite * convention to stop/continue enumeration. sigh. */ - return !(s->cb)((char*)buffer, s->user); + return !(s->cb)((WCHAR*)buffer, s->user); } /****************************************************************** - * SymFindFileInPath (DBGHELP.@) + * SymFindFileInPathW (DBGHELP.@) * */ -BOOL WINAPI SymFindFileInPath(HANDLE hProcess, LPSTR searchPath, LPSTR file, - PVOID id, DWORD two, DWORD three, DWORD flags, - LPSTR buffer, PFINDFILEINPATHCALLBACK cb, - PVOID user) +BOOL WINAPI SymFindFileInPathW(HANDLE hProcess, PCWSTR searchPath, PCWSTR full_path, + PVOID id, DWORD two, DWORD three, DWORD flags, + PWSTR buffer, PFINDFILEINPATHCALLBACKW cb, + PVOID user) { struct sffip s; struct process* pcs = process_find_by_handle(hProcess); - char tmp[MAX_PATH]; - char* ptr; + WCHAR tmp[MAX_PATH]; + WCHAR* ptr; + const WCHAR* filename; - TRACE("(%p %s %s %p %08lx %08lx %08lx %p %p %p)\n", - hProcess, searchPath, file, id, two, three, flags, - buffer, cb, user); + TRACE("(%p %s %s %p %08x %08x %08x %p %p %p)\n", + hProcess, debugstr_w(searchPath), debugstr_w(full_path), + id, two, three, flags, buffer, cb, user); if (!pcs) return FALSE; if (!searchPath) searchPath = pcs->search_path; @@ -250,23 +492,66 @@ BOOL WINAPI SymFindFileInPath(HANDLE hProcess, LPSTR searchPath, LPSTR file, s.cb = cb; s.user = user; - file = file_name(file); + filename = file_nameW(full_path); + s.kind = module_get_type_by_name(filename); + + /* first check full path to file */ + if (sffip_cb(full_path, &s)) + { + strcpyW(buffer, full_path); + return TRUE; + } while (searchPath) { - ptr = strchr(searchPath, ';'); + ptr = strchrW(searchPath, ';'); if (ptr) { - memcpy(tmp, searchPath, ptr - searchPath); + memcpy(tmp, searchPath, (ptr - searchPath) * sizeof(WCHAR)); tmp[ptr - searchPath] = 0; searchPath = ptr + 1; } else { - strcpy(tmp, searchPath); + strcpyW(tmp, searchPath); searchPath = NULL; } - if (EnumDirTree(hProcess, tmp, file, buffer, sffip_cb, &s)) return TRUE; + if (do_searchW(filename, tmp, FALSE, sffip_cb, &s)) + { + strcpyW(buffer, tmp); + return TRUE; + } } return FALSE; } + +/****************************************************************** + * SymFindFileInPath (DBGHELP.@) + * + */ +BOOL WINAPI SymFindFileInPath(HANDLE hProcess, PCSTR searchPath, PCSTR full_path, + PVOID id, DWORD two, DWORD three, DWORD flags, + PSTR buffer, PFINDFILEINPATHCALLBACK cb, + PVOID user) +{ + WCHAR searchPathW[MAX_PATH]; + WCHAR full_pathW[MAX_PATH]; + WCHAR bufferW[MAX_PATH]; + struct enum_dir_treeWA edt; + BOOL ret; + + /* a PFINDFILEINPATHCALLBACK and a PENUMDIRTREE_CALLBACK have actually the + * same signature & semantics, hence we can reuse the EnumDirTree W->A + * conversion helper + */ + edt.cb = cb; + edt.user = user; + if (searchPath) + MultiByteToWideChar(CP_ACP, 0, searchPath, -1, searchPathW, MAX_PATH); + MultiByteToWideChar(CP_ACP, 0, full_path, -1, full_pathW, MAX_PATH); + if ((ret = SymFindFileInPathW(hProcess, searchPath ? searchPathW : NULL, full_pathW, + id, two, three, flags, + bufferW, enum_dir_treeWA, &edt))) + WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL); + return ret; +} diff --git a/reactos/dll/win32/dbghelp/pe_module.c b/reactos/dll/win32/dbghelp/pe_module.c index 1ac65ca27ae..3027f5ba00c 100644 --- a/reactos/dll/win32/dbghelp/pe_module.c +++ b/reactos/dll/win32/dbghelp/pe_module.c @@ -3,7 +3,7 @@ * * Copyright (C) 1996, Eric Youngdale. * Copyright (C) 1999-2000, Ulrich Weigand. - * Copyright (C) 2004, Eric Pouech. + * Copyright (C) 2004-2007, Eric Pouech. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -17,7 +17,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * */ @@ -28,7 +28,6 @@ #include #include "dbghelp_private.h" -#include "winreg.h" #include "winternl.h" #include "wine/debug.h" @@ -37,10 +36,10 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); /****************************************************************** * pe_load_stabs * - * look for stabs information in PE header (it's how the mingw compiler provides + * look for stabs information in PE header (it's how the mingw compiler provides * its debugging information) */ -static BOOL pe_load_stabs(const struct process* pcs, struct module* module, +static BOOL pe_load_stabs(const struct process* pcs, struct module* module, const void* mapping, IMAGE_NT_HEADERS* nth) { IMAGE_SECTION_HEADER* section; @@ -52,12 +51,12 @@ static BOOL pe_load_stabs(const struct process* pcs, struct module* module, ((char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader); for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++) { - if (!strcasecmp(section->Name, ".stab")) + if (!strcasecmp((const char*)section->Name, ".stab")) { stabs = section->VirtualAddress; stabsize = section->SizeOfRawData; } - else if (!strncasecmp(section->Name, ".stabstr", 8)) + else if (!strncasecmp((const char*)section->Name, ".stabstr", 8)) { stabstr = section->VirtualAddress; stabstrsize = section->SizeOfRawData; @@ -66,8 +65,8 @@ static BOOL pe_load_stabs(const struct process* pcs, struct module* module, if (stabstrsize && stabsize) { - ret = stabs_parse(module, - module->module.BaseOfImage - nth->OptionalHeader.ImageBase, + ret = stabs_parse(module, + module->module.BaseOfImage - nth->OptionalHeader.ImageBase, RtlImageRvaToVa(nth, (void*)mapping, stabs, NULL), stabsize, RtlImageRvaToVa(nth, (void*)mapping, stabstr, NULL), @@ -76,7 +75,7 @@ static BOOL pe_load_stabs(const struct process* pcs, struct module* module, return ret; } -static BOOL CALLBACK dbg_match(char* file, void* user) +static BOOL CALLBACK dbg_match(const char* file, void* user) { /* accept first file */ return FALSE; @@ -99,12 +98,10 @@ static BOOL pe_load_dbg_file(const struct process* pcs, struct module* module, WINE_TRACE("Processing DBG file %s\n", dbg_name); - if (SymFindFileInPath(pcs->handle, NULL, (char*)dbg_name, - NULL, 0, 0, 0, - tmp, dbg_match, NULL) && + if (SymFindFileInPath(pcs->handle, NULL, dbg_name, NULL, 0, 0, 0, tmp, dbg_match, NULL) && (hFile = CreateFileA(tmp, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) != INVALID_HANDLE_VALUE && - ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0) && + ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0) && ((dbg_mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL)) { hdr = (const IMAGE_SEPARATE_DEBUG_HEADER*)dbg_mapping; @@ -125,8 +122,8 @@ static BOOL pe_load_dbg_file(const struct process* pcs, struct module* module, const IMAGE_SECTION_HEADER *sectp = (const IMAGE_SECTION_HEADER*)(hdr + 1); /* and after that and the exported names comes the debug directory */ - dbg = (const IMAGE_DEBUG_DIRECTORY*) - (dbg_mapping + sizeof(*hdr) + + dbg = (const IMAGE_DEBUG_DIRECTORY*) + (dbg_mapping + sizeof(*hdr) + hdr->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) + hdr->ExportedNamesSize); @@ -141,9 +138,9 @@ static BOOL pe_load_dbg_file(const struct process* pcs, struct module* module, else WINE_ERR("-Unable to peruse .DBG file %s (%s)\n", dbg_name, debugstr_a(tmp)); - if (dbg_mapping) UnmapViewOfFile((void*)dbg_mapping); + if (dbg_mapping) UnmapViewOfFile(dbg_mapping); if (hMap) CloseHandle(hMap); - if (hFile != NULL) CloseHandle(hFile); + if (hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile); return ret; } @@ -152,7 +149,7 @@ static BOOL pe_load_dbg_file(const struct process* pcs, struct module* module, * * Process MSC debug information in PE file. */ -static BOOL pe_load_msc_debug_info(const struct process* pcs, +static BOOL pe_load_msc_debug_info(const struct process* pcs, struct module* module, const void* mapping, IMAGE_NT_HEADERS* nth) { @@ -179,11 +176,11 @@ static BOOL pe_load_msc_debug_info(const struct process* pcs, misc->DataType != IMAGE_DEBUG_MISC_EXENAME) { WINE_ERR("-Debug info stripped, but no .DBG file in module %s\n", - module->module.ModuleName); + debugstr_w(module->module.ModuleName)); } else { - ret = pe_load_dbg_file(pcs, module, misc->Data, nth->FileHeader.TimeDateStamp); + ret = pe_load_dbg_file(pcs, module, (const char*)misc->Data, nth->FileHeader.TimeDateStamp); } } else @@ -200,8 +197,8 @@ static BOOL pe_load_msc_debug_info(const struct process* pcs, /*********************************************************************** * pe_load_export_debug_info */ -static BOOL pe_load_export_debug_info(const struct process* pcs, - struct module* module, +static BOOL pe_load_export_debug_info(const struct process* pcs, + struct module* module, const void* mapping, IMAGE_NT_HEADERS* nth) { unsigned int i; @@ -214,26 +211,26 @@ static BOOL pe_load_export_debug_info(const struct process* pcs, #if 0 /* Add start of DLL (better use the (yet unimplemented) Exe SymTag for this) */ /* FIXME: module.ModuleName isn't correctly set yet if it's passed in SymLoadModule */ - symt_new_public(module, NULL, module->module.ModuleName, base, 0, + symt_new_public(module, NULL, module->module.ModuleName, base, 1, TRUE /* FIXME */, TRUE /* FIXME */); #endif - + /* Add entry point */ - symt_new_public(module, NULL, "EntryPoint", - base + nth->OptionalHeader.AddressOfEntryPoint, 0, + symt_new_public(module, NULL, "EntryPoint", + base + nth->OptionalHeader.AddressOfEntryPoint, 1, TRUE, TRUE); #if 0 - /* FIXME: we'd better store addresses linked to sections rather than + /* FIXME: we'd better store addresses linked to sections rather than absolute values */ IMAGE_SECTION_HEADER* section; /* Add start of sections */ section = (IMAGE_SECTION_HEADER*) ((char*)&nth->OptionalHeader + nth->FileHeader.SizeOfOptionalHeader); - for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++) + for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++) { - symt_new_public(module, NULL, section->Name, - RtlImageRvaToVa(nth, (void*)mapping, section->VirtualAddress, NULL), - 0, TRUE /* FIXME */, TRUE /* FIXME */); + symt_new_public(module, NULL, section->Name, + RtlImageRvaToVa(nth, (void*)mapping, section->VirtualAddress, NULL), + 1, TRUE /* FIXME */, TRUE /* FIXME */); } #endif @@ -251,25 +248,28 @@ static BOOL pe_load_export_debug_info(const struct process* pcs, ordinals = RtlImageRvaToVa(nth, (void*)mapping, exports->AddressOfNameOrdinals, NULL); names = RtlImageRvaToVa(nth, (void*)mapping, exports->AddressOfNames, NULL); - for (i = 0; i < exports->NumberOfNames; i++) + if (functions && ordinals && names) { - if (!names[i]) continue; - symt_new_public(module, NULL, - RtlImageRvaToVa(nth, (void*)mapping, names[i], NULL), - base + functions[ordinals[i]], - 0, TRUE /* FIXME */, TRUE /* FIXME */); - } + for (i = 0; i < exports->NumberOfNames; i++) + { + if (!names[i]) continue; + symt_new_public(module, NULL, + RtlImageRvaToVa(nth, (void*)mapping, names[i], NULL), + base + functions[ordinals[i]], + 1, TRUE /* FIXME */, TRUE /* FIXME */); + } - 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), "%ld", i + exports->Base); - symt_new_public(module, NULL, buffer, base + (DWORD)functions[i], 0, - TRUE /* FIXME */, TRUE /* FIXME */); + 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), "%d", i + exports->Base); + symt_new_public(module, NULL, buffer, base + (DWORD)functions[i], 1, + TRUE /* FIXME */, TRUE /* FIXME */); + } } } /* no real debug info, only entry points */ @@ -290,10 +290,10 @@ BOOL pe_load_debug_info(const struct process* pcs, struct module* module) void* mapping; IMAGE_NT_HEADERS* nth; - hFile = CreateFileA(module->module.LoadedImageName, GENERIC_READ, FILE_SHARE_READ, + hFile = CreateFileW(module->module.LoadedImageName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) return ret; - if ((hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0) + if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != 0) { if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL) { @@ -304,7 +304,7 @@ BOOL pe_load_debug_info(const struct process* pcs, struct module* module) ret = pe_load_stabs(pcs, module, mapping, nth) || pe_load_msc_debug_info(pcs, module, mapping, nth); /* if we still have no debug info (we could only get SymExport at this - * point), then do the SymExport except if we have an ELF container, + * point), then do the SymExport except if we have an ELF container, * in which case we'll rely on the export's on the ELF side */ } @@ -321,36 +321,35 @@ BOOL pe_load_debug_info(const struct process* pcs, struct module* module) } /****************************************************************** - * pe_load_module + * pe_load_native_module * */ -struct module* pe_load_module(struct process* pcs, char* name, - HANDLE hFile, DWORD base, DWORD size) +struct module* pe_load_native_module(struct process* pcs, const WCHAR* name, + HANDLE hFile, DWORD base, DWORD size) { struct module* module = NULL; BOOL opened = FALSE; HANDLE hMap; - void* mapping; - char loaded_name[MAX_PATH]; + WCHAR loaded_name[MAX_PATH]; loaded_name[0] = '\0'; if (!hFile) { - if (!name) - { - /* FIXME SetLastError */ - return NULL; - } - if ((hFile = FindExecutableImage(name, NULL, loaded_name)) == NULL) + + assert(name); + + if ((hFile = FindExecutableImageExW(name, pcs->search_path, loaded_name, NULL, NULL)) == NULL) return NULL; opened = TRUE; } - else if (name) strcpy(loaded_name, name); + else if (name) strcpyW(loaded_name, name); else if (dbghelp_options & SYMOPT_DEFERRED_LOADS) FIXME("Trouble ahead (no module name passed in deferred mode)\n"); - if (!(module = module_find_by_name(pcs, loaded_name, DMT_PE)) && - (hMap = CreateFileMappingA(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL) + + if ((hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL)) != NULL) { + void* mapping; + if ((mapping = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0)) != NULL) { IMAGE_NT_HEADERS* nth = RtlImageNtHeader(mapping); @@ -360,7 +359,7 @@ struct module* pe_load_module(struct process* pcs, char* name, if (!base) base = nth->OptionalHeader.ImageBase; if (!size) size = nth->OptionalHeader.SizeOfImage; - module = module_new(pcs, loaded_name, DMT_PE, base, size, + module = module_new(pcs, loaded_name, DMT_PE, FALSE, base, size, nth->FileHeader.TimeDateStamp, nth->OptionalHeader.CheckSum); if (module) @@ -381,43 +380,39 @@ struct module* pe_load_module(struct process* pcs, char* name, } /****************************************************************** - * pe_load_module_from_pcs + * pe_load_nt_header * */ -struct module* pe_load_module_from_pcs(struct process* pcs, const char* name, - const char* mod_name, DWORD base, DWORD size) +BOOL pe_load_nt_header(HANDLE hProc, DWORD base, IMAGE_NT_HEADERS* nth) { - struct module* module; - const char* ptr; + IMAGE_DOS_HEADER dos; + + return ReadProcessMemory(hProc, (char*)base, &dos, sizeof(dos), NULL) && + dos.e_magic == IMAGE_DOS_SIGNATURE && + ReadProcessMemory(hProc, (char*)(base + dos.e_lfanew), + nth, sizeof(*nth), NULL) && + nth->Signature == IMAGE_NT_SIGNATURE; +} + +/****************************************************************** + * pe_load_builtin_module + * + */ +struct module* pe_load_builtin_module(struct process* pcs, const WCHAR* name, + DWORD base, DWORD size) +{ + struct module* module = NULL; - if ((module = module_find_by_name(pcs, name, DMT_PE))) return module; - if (mod_name) ptr = mod_name; - else - { - for (ptr = name + strlen(name) - 1; ptr >= name; ptr--) - { - if (*ptr == '/' || *ptr == '\\') - { - ptr++; - break; - } - } - } - if (ptr && (module = module_find_by_name(pcs, ptr, DMT_PE))) return module; if (base && pcs->dbg_hdr_addr) { - IMAGE_DOS_HEADER dos; IMAGE_NT_HEADERS nth; - if (ReadProcessMemory(pcs->handle, (char*)base, &dos, sizeof(dos), NULL) && - dos.e_magic == IMAGE_DOS_SIGNATURE && - ReadProcessMemory(pcs->handle, (char*)(base + dos.e_lfanew), - &nth, sizeof(nth), NULL) && - nth.Signature == IMAGE_NT_SIGNATURE) + if (pe_load_nt_header(pcs->handle, base, &nth)) { if (!size) size = nth.OptionalHeader.SizeOfImage; - module = module_new(pcs, name, DMT_PE, base, size, - nth.FileHeader.TimeDateStamp, nth.OptionalHeader.CheckSum); + module = module_new(pcs, name, DMT_PE, FALSE, base, size, + nth.FileHeader.TimeDateStamp, + nth.OptionalHeader.CheckSum); } } return module; diff --git a/reactos/dll/win32/dbghelp/regex.h b/reactos/dll/win32/dbghelp/regex.h deleted file mode 100644 index 2bca5378a41..00000000000 --- a/reactos/dll/win32/dbghelp/regex.h +++ /dev/null @@ -1,572 +0,0 @@ -/* Definitions for data structures and routines for the regular - expression library, version 0.12. - Copyright (C) 1985,89,90,91,92,93,95,96,97,98 Free Software Foundation, Inc. - - This file is part of the GNU C Library. Its master source is NOT part of - the C library, however. The master source lives in /gd/gnu/lib. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public License as - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. - - The GNU C 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 - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public - License along with the GNU C Library; see the file COPYING.LIB. If not, - write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -#ifndef _REGEX_H -#define _REGEX_H 1 - -/* Allow the use in C++ code. */ -#ifdef __cplusplus -extern "C" { -#endif - -/* POSIX says that must be included (by the caller) before - . */ - -#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS -/* VMS doesn't have `size_t' in , even though POSIX says it - should be there. */ -# include -#endif - -/* The following two types have to be signed and unsigned integer type - wide enough to hold a value of a pointer. For most ANSI compilers - ptrdiff_t and size_t should be likely OK. Still size of these two - types is 2 for Microsoft C. Ugh... */ -typedef long int s_reg_t; -typedef unsigned long int active_reg_t; - -/* The following bits are used to determine the regexp syntax we - recognize. The set/not-set meanings are chosen so that Emacs syntax - remains the value 0. The bits are given in alphabetical order, and - the definitions shifted by one from the previous bit; thus, when we - add or remove a bit, only one other definition need change. */ -typedef unsigned long int reg_syntax_t; - -/* If this bit is not set, then \ inside a bracket expression is literal. - If set, then such a \ quotes the following character. */ -#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1) - -/* If this bit is not set, then + and ? are operators, and \+ and \? are - literals. - If set, then \+ and \? are operators and + and ? are literals. */ -#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1) - -/* If this bit is set, then character classes are supported. They are: - [:alpha:], [:upper:], [:lower:], [:digit:], [:alnum:], [:xdigit:], - [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:]. - If not set, then character classes are not supported. */ -#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1) - -/* If this bit is set, then ^ and $ are always anchors (outside bracket - expressions, of course). - If this bit is not set, then it depends: - ^ is an anchor if it is at the beginning of a regular - expression or after an open-group or an alternation operator; - $ is an anchor if it is at the end of a regular expression, or - before a close-group or an alternation operator. - - This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because - POSIX draft 11.2 says that * etc. in leading positions is undefined. - We already implemented a previous draft which made those constructs - invalid, though, so we haven't changed the code back. */ -#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1) - -/* If this bit is set, then special characters are always special - regardless of where they are in the pattern. - If this bit is not set, then special characters are special only in - some contexts; otherwise they are ordinary. Specifically, - * + ? and intervals are only special when not after the beginning, - open-group, or alternation operator. */ -#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1) - -/* If this bit is set, then *, +, ?, and { cannot be first in an re or - immediately after an alternation or begin-group operator. */ -#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1) - -/* If this bit is set, then . matches newline. - If not set, then it doesn't. */ -#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1) - -/* If this bit is set, then . doesn't match NUL. - If not set, then it does. */ -#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1) - -/* If this bit is set, nonmatching lists [^...] do not match newline. - If not set, they do. */ -#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1) - -/* If this bit is set, either \{...\} or {...} defines an - interval, depending on RE_NO_BK_BRACES. - If not set, \{, \}, {, and } are literals. */ -#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1) - -/* If this bit is set, +, ? and | aren't recognized as operators. - If not set, they are. */ -#define RE_LIMITED_OPS (RE_INTERVALS << 1) - -/* If this bit is set, newline is an alternation operator. - If not set, newline is literal. */ -#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1) - -/* If this bit is set, then `{...}' defines an interval, and \{ and \} - are literals. - If not set, then `\{...\}' defines an interval. */ -#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1) - -/* If this bit is set, (...) defines a group, and \( and \) are literals. - If not set, \(...\) defines a group, and ( and ) are literals. */ -#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1) - -/* If this bit is set, then \ matches . - If not set, then \ is a back-reference. */ -#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1) - -/* If this bit is set, then | is an alternation operator, and \| is literal. - If not set, then \| is an alternation operator, and | is literal. */ -#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1) - -/* If this bit is set, then an ending range point collating higher - than the starting range point, as in [z-a], is invalid. - If not set, then when ending range point collates higher than the - starting range point, the range is ignored. */ -#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1) - -/* If this bit is set, then an unmatched ) is ordinary. - If not set, then an unmatched ) is invalid. */ -#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1) - -/* If this bit is set, succeed as soon as we match the whole pattern, - without further backtracking. */ -#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1) - -/* If this bit is set, do not process the GNU regex operators. - If not set, then the GNU regex operators are recognized. */ -#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1) - -/* If this bit is set, turn on internal regex debugging. - If not set, and debugging was on, turn it off. - This only works if regex.c is compiled -DDEBUG. - We define this bit always, so that all that's needed to turn on - debugging is to recompile regex.c; the calling code can always have - this bit set, and it won't affect anything in the normal case. */ -#define RE_DEBUG (RE_NO_GNU_OPS << 1) - -/* This global variable defines the particular regexp syntax to use (for - some interfaces). When a regexp is compiled, the syntax used is - stored in the pattern buffer, so changing this does not affect - already-compiled regexps. */ -extern reg_syntax_t re_syntax_options; - -/* Define combinations of the above bits for the standard possibilities. - (The [[[ comments delimit what gets put into the Texinfo file, so - don't delete them!) */ -/* [[[begin syntaxes]]] */ -#define RE_SYNTAX_EMACS 0 - -#define RE_SYNTAX_AWK \ - (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL \ - | RE_NO_BK_PARENS | RE_NO_BK_REFS \ - | RE_NO_BK_VBAR | RE_NO_EMPTY_RANGES \ - | RE_DOT_NEWLINE | RE_CONTEXT_INDEP_ANCHORS \ - | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS) - -#define RE_SYNTAX_GNU_AWK \ - ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG) \ - & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS)) - -#define RE_SYNTAX_POSIX_AWK \ - (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS \ - | RE_INTERVALS | RE_NO_GNU_OPS) - -#define RE_SYNTAX_GREP \ - (RE_BK_PLUS_QM | RE_CHAR_CLASSES \ - | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS \ - | RE_NEWLINE_ALT) - -#define RE_SYNTAX_EGREP \ - (RE_CHAR_CLASSES | RE_CONTEXT_INDEP_ANCHORS \ - | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE \ - | RE_NEWLINE_ALT | RE_NO_BK_PARENS \ - | RE_NO_BK_VBAR) - -#define RE_SYNTAX_POSIX_EGREP \ - (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) - -/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff. */ -#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC - -#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC - -/* Syntax bits common to both basic and extended POSIX regex syntax. */ -#define _RE_SYNTAX_POSIX_COMMON \ - (RE_CHAR_CLASSES | RE_DOT_NEWLINE | RE_DOT_NOT_NULL \ - | RE_INTERVALS | RE_NO_EMPTY_RANGES) - -#define RE_SYNTAX_POSIX_BASIC \ - (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM) - -/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes - RE_LIMITED_OPS, i.e., \? \+ \| are not recognized. Actually, this - isn't minimal, since other operators, such as \`, aren't disabled. */ -#define RE_SYNTAX_POSIX_MINIMAL_BASIC \ - (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS) - -#define RE_SYNTAX_POSIX_EXTENDED \ - (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ - | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES \ - | RE_NO_BK_PARENS | RE_NO_BK_VBAR \ - | RE_UNMATCHED_RIGHT_PAREN_ORD) - -/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS - replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */ -#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED \ - (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS \ - | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES \ - | RE_NO_BK_PARENS | RE_NO_BK_REFS \ - | RE_NO_BK_VBAR | RE_UNMATCHED_RIGHT_PAREN_ORD) -/* [[[end syntaxes]]] */ - -/* Maximum number of duplicates an interval can allow. Some systems - (erroneously) define this in other header files, but we want our - value, so remove any previous define. */ -#ifdef RE_DUP_MAX -# undef RE_DUP_MAX -#endif -/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows. */ -#define RE_DUP_MAX (0x7fff) - - -/* POSIX `cflags' bits (i.e., information for `regcomp'). */ - -/* If this bit is set, then use extended regular expression syntax. - If not set, then use basic regular expression syntax. */ -#define REG_EXTENDED 1 - -/* If this bit is set, then ignore case when matching. - If not set, then case is significant. */ -#define REG_ICASE (REG_EXTENDED << 1) - -/* If this bit is set, then anchors do not match at newline - characters in the string. - If not set, then anchors do match at newlines. */ -#define REG_NEWLINE (REG_ICASE << 1) - -/* If this bit is set, then report only success or fail in regexec. - If not set, then returns differ between not matching and errors. */ -#define REG_NOSUB (REG_NEWLINE << 1) - - -/* POSIX `eflags' bits (i.e., information for regexec). */ - -/* If this bit is set, then the beginning-of-line operator doesn't match - the beginning of the string (presumably because it's not the - beginning of a line). - If not set, then the beginning-of-line operator does match the - beginning of the string. */ -#define REG_NOTBOL 1 - -/* Like REG_NOTBOL, except for the end-of-line. */ -#define REG_NOTEOL (1 << 1) - - -/* If any error codes are removed, changed, or added, update the - `re_error_msg' table in regex.c. */ -typedef enum -{ -#ifdef _XOPEN_SOURCE - REG_ENOSYS = -1, /* This will never happen for this implementation. */ -#endif - - REG_NOERROR = 0, /* Success. */ - REG_NOMATCH, /* Didn't find a match (for regexec). */ - - /* POSIX regcomp return error codes. (In the order listed in the - standard.) */ - REG_BADPAT, /* Invalid pattern. */ - REG_ECOLLATE, /* Not implemented. */ - REG_ECTYPE, /* Invalid character class name. */ - REG_EESCAPE, /* Trailing backslash. */ - REG_ESUBREG, /* Invalid back reference. */ - REG_EBRACK, /* Unmatched left bracket. */ - REG_EPAREN, /* Parenthesis imbalance. */ - REG_EBRACE, /* Unmatched \{. */ - REG_BADBR, /* Invalid contents of \{\}. */ - REG_ERANGE, /* Invalid range end. */ - REG_ESPACE, /* Ran out of memory. */ - REG_BADRPT, /* No preceding re for repetition op. */ - - /* Error codes we've added. */ - REG_EEND, /* Premature end. */ - REG_ESIZE, /* Compiled pattern bigger than 2^16 bytes. */ - REG_ERPAREN /* Unmatched ) or \); not returned from regcomp. */ -} reg_errcode_t; - -/* This data structure represents a compiled pattern. Before calling - the pattern compiler, the fields `buffer', `allocated', `fastmap', - `translate', and `no_sub' can be set. After the pattern has been - compiled, the `re_nsub' field is available. All other fields are - private to the regex routines. */ - -#ifndef RE_TRANSLATE_TYPE -# define RE_TRANSLATE_TYPE char * -#endif - -struct re_pattern_buffer -{ -/* [[[begin pattern_buffer]]] */ - /* Space that holds the compiled pattern. It is declared as - `unsigned char *' because its elements are - sometimes used as array indexes. */ - unsigned char *buffer; - - /* Number of bytes to which `buffer' points. */ - unsigned long int allocated; - - /* Number of bytes actually used in `buffer'. */ - unsigned long int used; - - /* Syntax setting with which the pattern was compiled. */ - reg_syntax_t syntax; - - /* Pointer to a fastmap, if any, otherwise zero. re_search uses - the fastmap, if there is one, to skip over impossible - starting points for matches. */ - char *fastmap; - - /* Either a translate table to apply to all characters before - comparing them, or zero for no translation. The translation - is applied to a pattern when it is compiled and to a string - when it is matched. */ - RE_TRANSLATE_TYPE translate; - - /* Number of subexpressions found by the compiler. */ - size_t re_nsub; - - /* Zero if this pattern cannot match the empty string, one else. - Well, in truth it's used only in `re_search_2', to see - whether or not we should use the fastmap, so we don't set - this absolutely perfectly; see `re_compile_fastmap' (the - `duplicate' case). */ - unsigned can_be_null : 1; - - /* If REGS_UNALLOCATED, allocate space in the `regs' structure - for `max (RE_NREGS, re_nsub + 1)' groups. - If REGS_REALLOCATE, reallocate space if necessary. - If REGS_FIXED, use what's there. */ -#define REGS_UNALLOCATED 0 -#define REGS_REALLOCATE 1 -#define REGS_FIXED 2 - unsigned regs_allocated : 2; - - /* Set to zero when `regex_compile' compiles a pattern; set to one - by `re_compile_fastmap' if it updates the fastmap. */ - unsigned fastmap_accurate : 1; - - /* If set, `re_match_2' does not return information about - subexpressions. */ - unsigned no_sub : 1; - - /* If set, a beginning-of-line anchor doesn't match at the - beginning of the string. */ - unsigned not_bol : 1; - - /* Similarly for an end-of-line anchor. */ - unsigned not_eol : 1; - - /* If true, an anchor at a newline matches. */ - unsigned newline_anchor : 1; - -/* [[[end pattern_buffer]]] */ -}; - -typedef struct re_pattern_buffer regex_t; - -/* Type for byte offsets within the string. POSIX mandates this. */ -typedef int regoff_t; - - -/* This is the structure we store register match data in. See - regex.texinfo for a full description of what registers match. */ -struct re_registers -{ - unsigned num_regs; - regoff_t *start; - regoff_t *end; -}; - - -/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer, - `re_match_2' returns information about at least this many registers - the first time a `regs' structure is passed. */ -#ifndef RE_NREGS -# define RE_NREGS 30 -#endif - - -/* POSIX specification for registers. Aside from the different names than - `re_registers', POSIX uses an array of structures, instead of a - structure of arrays. */ -typedef struct -{ - regoff_t rm_so; /* Byte offset from string's start to substring's start. */ - regoff_t rm_eo; /* Byte offset from string's start to substring's end. */ -} regmatch_t; - -/* Declarations for routines. */ - -/* To avoid duplicating every routine declaration -- once with a - prototype (if we are ANSI), and once without (if we aren't) -- we - use the following macro to declare argument types. This - unfortunately clutters up the declarations a bit, but I think it's - worth it. */ - -#if __STDC__ - -# define _RE_ARGS(args) args - -#else /* not __STDC__ */ - -# define _RE_ARGS(args) () - -#endif /* not __STDC__ */ - -/* Sets the current default syntax to SYNTAX, and return the old syntax. - You can also simply assign to the `re_syntax_options' variable. */ -extern reg_syntax_t __re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); -extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax)); - -/* Compile the regular expression PATTERN, with length LENGTH - and syntax given by the global `re_syntax_options', into the buffer - BUFFER. Return NULL if successful, and an error string if not. */ -extern const char *__re_compile_pattern - _RE_ARGS ((const char *pattern, size_t length, - struct re_pattern_buffer *buffer)); -extern const char *re_compile_pattern - _RE_ARGS ((const char *pattern, size_t length, - struct re_pattern_buffer *buffer)); - - -/* Compile a fastmap for the compiled pattern in BUFFER; used to - accelerate searches. Return 0 if successful and -2 if was an - internal error. */ -extern int __re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); -extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer)); - - -/* Search in the string STRING (with length LENGTH) for the pattern - compiled into BUFFER. Start searching at position START, for RANGE - characters. Return the starting position of the match, -1 for no - match, or -2 for an internal error. Also return register - information in REGS (if REGS and BUFFER->no_sub are nonzero). */ -extern int __re_search - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, - int length, int start, int range, struct re_registers *regs)); -extern int re_search - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, - int length, int start, int range, struct re_registers *regs)); - - -/* Like `re_search', but search in the concatenation of STRING1 and - STRING2. Also, stop searching at index START + STOP. */ -extern int __re_search_2 - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, - int length1, const char *string2, int length2, - int start, int range, struct re_registers *regs, int stop)); -extern int re_search_2 - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, - int length1, const char *string2, int length2, - int start, int range, struct re_registers *regs, int stop)); - - -/* Like `re_search', but return how many characters in STRING the regexp - in BUFFER matched, starting at position START. */ -extern int __re_match - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, - int length, int start, struct re_registers *regs)); -extern int re_match - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string, - int length, int start, struct re_registers *regs)); - - -/* Relates to `re_match' as `re_search_2' relates to `re_search'. */ -extern int __re_match_2 - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, - int length1, const char *string2, int length2, - int start, struct re_registers *regs, int stop)); -extern int re_match_2 - _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1, - int length1, const char *string2, int length2, - int start, struct re_registers *regs, int stop)); - - -/* Set REGS to hold NUM_REGS registers, storing them in STARTS and - ENDS. Subsequent matches using BUFFER and REGS will use this memory - for recording register information. STARTS and ENDS must be - allocated with malloc, and must each be at least `NUM_REGS * sizeof - (regoff_t)' bytes long. - - If NUM_REGS == 0, then subsequent matches should allocate their own - register data. - - Unless this function is called, the first search or match using - PATTERN_BUFFER will allocate its own register data, without - freeing the old data. */ -extern void __re_set_registers - _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, - unsigned num_regs, regoff_t *starts, regoff_t *ends)); -extern void re_set_registers - _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs, - unsigned num_regs, regoff_t *starts, regoff_t *ends)); - -#ifdef _REGEX_RE_COMP -# ifndef _CRAY -/* 4.2 bsd compatibility. */ -extern char *re_comp _RE_ARGS ((const char *)); -extern int re_exec _RE_ARGS ((const char *)); -# endif -#endif - -/* POSIX compatibility. */ -extern int __regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern, - int __cflags)); -extern int regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern, - int __cflags)); - -extern int __regexec _RE_ARGS ((const regex_t *__preg, - const char *__string, size_t __nmatch, - regmatch_t __pmatch[], int __eflags)); -extern int regexec _RE_ARGS ((const regex_t *__preg, - const char *__string, size_t __nmatch, - regmatch_t __pmatch[], int __eflags)); - -extern size_t __regerror _RE_ARGS ((int __errcode, const regex_t *__preg, - char *__errbuf, size_t __errbuf_size)); -extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg, - char *__errbuf, size_t __errbuf_size)); - -extern void __regfree _RE_ARGS ((regex_t *__preg)); -extern void regfree _RE_ARGS ((regex_t *__preg)); - - -#ifdef __cplusplus -} -#endif /* C++ */ - -#endif /* regex.h */ - -/* -Local variables: -make-backup-files: t -version-control: t -trim-versions-without-asking: nil -End: -*/ diff --git a/reactos/dll/win32/dbghelp/source.c b/reactos/dll/win32/dbghelp/source.c index 9271ce7dc81..14a48cc26bf 100644 --- a/reactos/dll/win32/dbghelp/source.c +++ b/reactos/dll/win32/dbghelp/source.c @@ -15,7 +15,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * */ #include "config.h" @@ -26,6 +26,9 @@ #include "dbghelp_private.h" #include "wine/debug.h" +#ifdef HAVE_REGEX_H +# include +#endif WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); @@ -51,30 +54,45 @@ static unsigned source_find(const struct module* module, const char* name) * * checks if source exists. if not, add it */ -unsigned source_new(struct module* module, const char* name) +unsigned source_new(struct module* module, const char* base, const char* name) { - int len; unsigned ret; + const char* full; + char* tmp = NULL; if (!name) return (unsigned)-1; - if (module->sources && (ret = source_find(module, name)) != (unsigned)-1) - return ret; - - len = strlen(name) + 1; - if (module->sources_used + len + 1 > module->sources_alloc) + if (!base || *name == '/') + full = name; + else { - /* Alloc by block of 256 bytes */ - module->sources_alloc = (module->sources_used + len + 1 + 255) & ~255; - if (!module->sources) - module->sources = HeapAlloc(GetProcessHeap(), 0, module->sources_alloc); - else - module->sources = HeapReAlloc(GetProcessHeap(), 0, module->sources, - module->sources_alloc); + unsigned bsz = strlen(base); + + tmp = HeapAlloc(GetProcessHeap(), 0, bsz + 1 + strlen(name) + 1); + if (!tmp) return (unsigned)-1; + full = tmp; + strcpy(tmp, base); + if (tmp[bsz - 1] != '/') tmp[bsz++] = '/'; + strcpy(&tmp[bsz], name); } - ret = module->sources_used; - strcpy(module->sources + module->sources_used, name); - module->sources_used += len; - module->sources[module->sources_used] = '\0'; + if (!module->sources || (ret = source_find(module, full)) == (unsigned)-1) + { + int len = strlen(full) + 1; + if (module->sources_used + len + 1 > module->sources_alloc) + { + /* Alloc by block of 256 bytes */ + module->sources_alloc = (module->sources_used + len + 1 + 255) & ~255; + if (!module->sources) + module->sources = HeapAlloc(GetProcessHeap(), 0, module->sources_alloc); + else + module->sources = HeapReAlloc(GetProcessHeap(), 0, module->sources, + module->sources_alloc); + } + ret = module->sources_used; + memcpy(module->sources + module->sources_used, full, len); + module->sources_used += len; + module->sources[module->sources_used] = '\0'; + } + HeapFree(GetProcessHeap(), 0, tmp); return ret; } @@ -94,30 +112,29 @@ const char* source_get(const struct module* module, unsigned idx) * SymEnumSourceFiles (DBGHELP.@) * */ -BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, LPSTR Mask, - PSYM_ENUMSOURCFILES_CALLBACK cbSrcFiles, +BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, PCSTR Mask, + PSYM_ENUMSOURCEFILES_CALLBACK cbSrcFiles, PVOID UserContext) { - struct process* pcs; - struct module* module; + struct module_pair pair; SOURCEFILE sf; char* ptr; - + if (!cbSrcFiles) return FALSE; - pcs = process_find_by_handle(hProcess); - if (!pcs) return FALSE; - + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + if (ModBase) { - module = module_find_by_addr(pcs, ModBase, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; } else { if (Mask[0] == '!') { - module = module_find_by_name(pcs, Mask + 1, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; + pair.requested = module_find_by_nameA(pair.pcs, Mask + 1); + if (!module_get_debug(&pair)) return FALSE; } else { @@ -125,8 +142,8 @@ BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, LPSTR Mask, return FALSE; } } - if (!module->sources) return FALSE; - for (ptr = module->sources; *ptr; ptr += strlen(ptr) + 1) + if (!pair.effective->sources) return FALSE; + for (ptr = pair.effective->sources; *ptr; ptr += strlen(ptr) + 1) { /* FIXME: not using Mask */ sf.ModBase = ModBase; @@ -136,3 +153,93 @@ BOOL WINAPI SymEnumSourceFiles(HANDLE hProcess, ULONG64 ModBase, LPSTR Mask, return TRUE; } + +/****************************************************************** + * SymEnumLines (DBGHELP.@) + * + */ +BOOL WINAPI SymEnumLines(HANDLE hProcess, ULONG64 base, PCSTR compiland, + PCSTR srcfile, PSYM_ENUMLINES_CALLBACK cb, PVOID user) +{ + struct module_pair pair; + struct hash_table_iter hti; + struct symt_ht* sym; + regex_t re; + struct line_info* dli; + void* ptr; + SRCCODEINFO sci; + const char* file; + + if (!cb) return FALSE; + if (!(dbghelp_options & SYMOPT_LOAD_LINES)) return TRUE; + if (regcomp(&re, srcfile, REG_NOSUB)) + { + FIXME("Couldn't compile %s\n", srcfile); + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + if (compiland) FIXME("Unsupported yet (filtering on compiland %s)\n", compiland); + pair.requested = module_find_by_addr(pair.pcs, base, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; + + sci.SizeOfStruct = sizeof(sci); + sci.ModBase = base; + + hash_table_iter_init(&pair.effective->ht_symbols, &hti, NULL); + while ((ptr = hash_table_iter_up(&hti))) + { + int i; + + sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); + if (sym->symt.tag != SymTagFunction) continue; + + sci.FileName[0] = '\0'; + for (i=0; ivlines); i++) + { + dli = vector_at(&((struct symt_function*)sym)->vlines, i); + if (dli->is_source_file) + { + file = source_get(pair.effective, dli->u.source_file); + if (regexec(&re, file, 0, NULL, 0) != 0) file = ""; + strcpy(sci.FileName, file); + } + else if (sci.FileName[0]) + { + sci.Key = dli; + sci.Obj[0] = '\0'; /* FIXME */ + sci.LineNumber = dli->line_number; + sci.Address = dli->u.pc_offset; + if (!cb(&sci, user)) break; + } + } + } + return TRUE; +} + +/****************************************************************** + * SymGetSourceFileToken (DBGHELP.@) + * + */ +BOOL WINAPI SymGetSourceFileToken(HANDLE hProcess, ULONG64 base, + PCSTR src, PVOID* token, DWORD* size) +{ + FIXME("%p %s %s %p %p: stub!\n", + hProcess, wine_dbgstr_longlong(base), debugstr_a(src), token, size); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} + +/****************************************************************** + * SymGetSourceFileTokenW (DBGHELP.@) + * + */ +BOOL WINAPI SymGetSourceFileTokenW(HANDLE hProcess, ULONG64 base, + PCWSTR src, PVOID* token, DWORD* size) +{ + FIXME("%p %s %s %p %p: stub!\n", + hProcess, wine_dbgstr_longlong(base), debugstr_w(src), token, size); + SetLastError(ERROR_NOT_SUPPORTED); + return FALSE; +} diff --git a/reactos/dll/win32/dbghelp/stabs.c b/reactos/dll/win32/dbghelp/stabs.c index 3a07e434d6f..8f651b18cba 100644 --- a/reactos/dll/win32/dbghelp/stabs.c +++ b/reactos/dll/win32/dbghelp/stabs.c @@ -2,7 +2,7 @@ * File stabs.c - read stabs information from the modules * * Copyright (C) 1996, Eric Youngdale. - * 1999-2004, Eric Pouech + * 1999-2005, Eric Pouech * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -16,7 +16,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * * Maintenance Information @@ -33,7 +33,9 @@ #include #include -#include +#ifdef HAVE_SYS_STAT_H +# include +#endif #ifdef HAVE_SYS_MMAN_H #include #endif @@ -52,7 +54,6 @@ #include "windef.h" #include "winbase.h" -#include "winreg.h" #include "winnls.h" #include "dbghelp_private.h" @@ -61,8 +62,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(dbghelp_stabs); -UINT64 _strtoui64( const char *nptr, char **endptr, int base ); - #ifndef N_UNDF #define N_UNDF 0x00 #endif @@ -73,9 +72,11 @@ UINT64 _strtoui64( const char *nptr, char **endptr, int base ); #define N_LCSYM 0x28 #define N_MAIN 0x2a #define N_ROSYM 0x2c +#define N_BNSYM 0x2e #define N_OPT 0x3c #define N_RSYM 0x40 #define N_SLINE 0x44 +#define N_ENSYM 0x4e #define N_SO 0x64 #define N_LSYM 0x80 #define N_BINCL 0x82 @@ -102,27 +103,36 @@ struct stab_nlist static void stab_strcpy(char* dest, int sz, const char* source) { + char* ptr = dest; /* * A strcpy routine that stops when we hit the ':' character. * Faster than copying the whole thing, and then nuking the * ':'. + * Takes also care of (valid) a::b constructs */ - while (*source != '\0' && *source != ':' && sz-- > 0) - *dest++ = *source++; - *dest-- = '\0'; - /* GCC seems to emit, in some cases, a .+ suffix. + while (*source != '\0') + { + if (source[0] != ':' && sz-- > 0) *ptr++ = *source++; + else if (source[1] == ':' && (sz -= 2) > 0) + { + *ptr++ = *source++; + *ptr++ = *source++; + } + else break; + } + *ptr-- = '\0'; + /* GCC emits, in some cases, a .+ suffix. * This is used for static variable inside functions, so * that we can have several such variables with same name in * the same compilation unit * We simply ignore that suffix when present (we also get rid * of it in ELF symtab parsing) */ - if (isdigit(*dest)) + if (ptr >= dest && isdigit(*ptr)) { - while (isdigit(*dest)) dest--; - if (*dest == '.') *dest = '\0'; + while (ptr > dest && isdigit(*ptr)) ptr--; + if (*ptr == '.') *ptr = '\0'; } - assert(sz > 0); } @@ -151,7 +161,7 @@ static int stabs_new_include(const char* file, unsigned long val) { num_alloc_include_def += 256; if (!include_defs) - include_defs = HeapAlloc(GetProcessHeap(), 0, + include_defs = HeapAlloc(GetProcessHeap(), 0, sizeof(include_defs[0]) * num_alloc_include_def); else include_defs = HeapReAlloc(GetProcessHeap(), 0, include_defs, @@ -232,10 +242,10 @@ static struct symt** stabs_find_ref(long filenr, long subnr) if (cu_nrofentries <= subnr) { if (!cu_vector) - cu_vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + cu_vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(cu_vector[0]) * (subnr+1)); else - cu_vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + cu_vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cu_vector, sizeof(cu_vector[0]) * (subnr+1)); cu_nrofentries = subnr + 1; } @@ -251,10 +261,10 @@ static struct symt** stabs_find_ref(long filenr, long subnr) if (idef->nrofentries <= subnr) { if (!idef->vector) - idef->vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + idef->vector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(idef->vector[0]) * (subnr+1)); else - idef->vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, + idef->vector = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, idef->vector, sizeof(idef->vector[0]) * (subnr+1)); idef->nrofentries = subnr + 1; } @@ -267,20 +277,25 @@ static struct symt** stabs_find_ref(long filenr, long subnr) static struct symt** stabs_read_type_enum(const char** x) { long filenr, subnr; + const char* iter; + char* end; - if (**x == '(') + iter = *x; + if (*iter == '(') { - (*x)++; /* '(' */ - filenr = strtol(*x, (char**)x, 10); /* */ - (*x)++; /* ',' */ - subnr = strtol(*x, (char**)x, 10); /* */ - (*x)++; /* ')' */ + ++iter; /* '(' */ + filenr = strtol(iter, &end, 10); /* */ + iter = ++end; /* ',' */ + subnr = strtol(iter, &end, 10); /* */ + iter = ++end; /* ')' */ } else { - filenr = 0; - subnr = strtol(*x, (char**)x, 10); /* */ + filenr = 0; + subnr = strtol(iter, &end, 10); /* */ + iter = end; } + *x = iter; return stabs_find_ref(filenr, subnr); } @@ -292,7 +307,7 @@ struct ParseTypedefData int idx; struct module* module; #ifdef PTS_DEBUG - struct PTS_Error + struct PTS_Error { const char* ptr; unsigned line; @@ -349,27 +364,40 @@ static int stabs_get_basic(struct ParseTypedefData* ptd, unsigned basic, struct case 35: stabs_basic[basic] = symt_new_basic(ptd->module, btComplex, "long double complex", 24); break; default: PTS_ABORTIF(ptd, 1); } - } + } *symt = &stabs_basic[basic]->symt; return 0; } -static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, +static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typename, struct symt** dt); static int stabs_pts_read_id(struct ParseTypedefData* ptd) { const char* first = ptd->ptr; - unsigned int len; + unsigned int template = 0; + char ch; - PTS_ABORTIF(ptd, (ptd->ptr = strchr(ptd->ptr, ':')) == NULL); - len = ptd->ptr - first; - PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx); - memcpy(ptd->buf + ptd->idx, first, len); - ptd->buf[ptd->idx + len] = '\0'; - ptd->idx += len + 1; - ptd->ptr++; /* ':' */ - return 0; + while ((ch = *ptd->ptr++) != '\0') + { + switch (ch) + { + case ':': + if (template == 0) + { + unsigned int len = ptd->ptr - first - 1; + PTS_ABORTIF(ptd, len >= sizeof(ptd->buf) - ptd->idx); + memcpy(ptd->buf + ptd->idx, first, len); + ptd->buf[ptd->idx + len] = '\0'; + ptd->idx += len + 1; + return 0; + } + break; + case '<': template++; break; + case '>': PTS_ABORTIF(ptd, template == 0); template--; break; + } + } + return -1; } static int stabs_pts_read_number(struct ParseTypedefData* ptd, long* v) @@ -404,7 +432,7 @@ static int stabs_pts_read_type_reference(struct ParseTypedefData* ptd, struct pts_range_value { - unsigned long long val; + ULONGLONG val; int sign; }; @@ -420,7 +448,7 @@ static int stabs_pts_read_range_value(struct ParseTypedefData* ptd, struct pts_r { switch (ptd->ptr[1]) { - case '0': + case '0': PTS_ABORTIF(ptd, ptd->ptr[0] != '1'); prv->sign = -1; prv->val = 0; @@ -437,13 +465,13 @@ static int stabs_pts_read_range_value(struct ParseTypedefData* ptd, struct pts_r break; case '-': prv->sign = -1; - prv->val = _strtoui64(++ptd->ptr, &last, 10); + prv->val = strtoull(++ptd->ptr, &last, 10); ptd->ptr = last; break; case '+': - default: + default: prv->sign = 1; - prv->val = _strtoui64(ptd->ptr, &last, 10); + prv->val = strtoull(ptd->ptr, &last, 10); ptd->ptr = last; break; } @@ -459,7 +487,7 @@ static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typena unsigned size; enum BasicType bt; int i; - unsigned long long v; + ULONGLONG v; /* type ';' ';' ';' */ PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref) == -1); @@ -532,7 +560,7 @@ static int stabs_pts_read_range(struct ParseTypedefData* ptd, const char* typena return 0; } -static __inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd) +static inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd) { struct symt* dt; char* tmp; @@ -572,7 +600,7 @@ static __inline int stabs_pts_read_method_info(struct ParseTypedefData* ptd) return 0; } -static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, +static inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, struct symt_udt* sdt) { long sz, ofs; @@ -603,11 +631,11 @@ static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, { char tmp[256]; WCHAR* name; - DWORD size; + DWORD64 size; symt_get_info(adt, TI_GET_SYMNAME, &name); - strcmp(tmp, "__inherited_class_"); - WideCharToMultiByte(CP_ACP, 0, name, -1, + strcpy(tmp, "__inherited_class_"); + WideCharToMultiByte(CP_ACP, 0, name, -1, tmp + strlen(tmp), sizeof(tmp) - strlen(tmp), NULL, NULL); HeapFree(GetProcessHeap(), 0, name); @@ -618,11 +646,11 @@ static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, * be much of a problem */ symt_get_info(adt, TI_GET_LENGTH, &size); - symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, size * 8); + symt_add_udt_element(ptd->module, sdt, tmp, adt, ofs, (DWORD)size * 8); } PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); } - + } /* if the structure has already been filled, just redo the parsing * but don't store results into the struct @@ -630,7 +658,7 @@ static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, */ /* Now parse the individual elements of the structure/union. */ - while (*ptd->ptr != ';') + while (*ptd->ptr != ';') { /* agg_name : type ',' ',' */ idx = ptd->idx; @@ -672,7 +700,7 @@ static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, */ if (*ptd->ptr == ':') { - ptd->ptr++; + ptd->ptr++; stabs_pts_read_method_info(ptd); ptd->idx = idx; continue; @@ -718,7 +746,7 @@ static __inline int stabs_pts_read_aggregate(struct ParseTypedefData* ptd, return 0; } -static __inline int stabs_pts_read_enum(struct ParseTypedefData* ptd, +static inline int stabs_pts_read_enum(struct ParseTypedefData* ptd, struct symt_enum* edt) { long value; @@ -737,26 +765,27 @@ static __inline int stabs_pts_read_enum(struct ParseTypedefData* ptd, return 0; } -static __inline int stabs_pts_read_array(struct ParseTypedefData* ptd, +static inline int stabs_pts_read_array(struct ParseTypedefData* ptd, struct symt** adt) { long lo, hi; - struct symt* rdt; + struct symt* range_dt; + struct symt* base_dt; /* ar;;; */ PTS_ABORTIF(ptd, *ptd->ptr++ != 'r'); - /* FIXME: range type is lost, always assume int */ - PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &rdt) == -1); + + PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &range_dt) == -1); PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &lo) == -1); PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &hi) == -1); PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ - PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &rdt) == -1); + PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &base_dt) == -1); - *adt = &symt_new_array(ptd->module, lo, hi, rdt)->symt; + *adt = &symt_new_array(ptd->module, lo, hi, base_dt, range_dt)->symt; return 0; } @@ -781,7 +810,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ PTS_ABORTIF(ptd, new_dt != btNoType); /* first handle attribute if any */ - switch (*ptd->ptr) + switch (*ptd->ptr) { case '@': if (*++ptd->ptr == 's') @@ -824,7 +853,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ break; case 'f': PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1); - new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt; + new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt; break; case 'e': new_dt = &symt_new_enum(ptd->module, typename)->symt; @@ -847,16 +876,28 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ } else { + unsigned l1, l2; if (udt->symt.tag != SymTagUDT) { ERR("Forward declaration (%p/%s) is not an aggregate (%u)\n", udt, symt_get_name(&udt->symt), udt->symt.tag); return -1; } - if (strcmp(udt->hash_elt.name, typename)) + /* FIXME: we currently don't correctly construct nested C++ + * classes names. Therefore, we could be here with either: + * - typename and udt->hash_elt.name being the same string + * (non embedded case) + * - typename being foo::bar while udt->hash_elt.name being + * just bar + * So, we twist the comparison to test both occurrences. When + * we have proper C++ types in this file, this twist has to be + * removed + */ + l1 = strlen(udt->hash_elt.name); + l2 = strlen(typename); + if (l1 > l2 || strcmp(udt->hash_elt.name, typename + l2 - l1)) ERR("Forward declaration name mismatch %s <> %s\n", udt->hash_elt.name, typename); - /* should check typename is the same too */ new_dt = &udt->symt; } PTS_ABORTIF(ptd, stabs_pts_read_aggregate(ptd, udt) == -1); @@ -894,7 +935,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ { ptd->ptr++; PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1); - new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt; + new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt; } else { @@ -904,7 +945,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &cls_dt) == -1); PTS_ABORTIF(ptd, *ptd->ptr++ != ','); PTS_ABORTIF(ptd, stabs_pts_read_type_def(ptd, NULL, &ref_dt) == -1); - new_dt = &symt_new_function_signature(ptd->module, ref_dt)->symt; + new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt; while (*ptd->ptr == ',') { ptd->ptr++; @@ -916,7 +957,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ { long type, len, unk; int basic; - + PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &type) == -1); PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */ PTS_ABORTIF(ptd, stabs_pts_read_number(ptd, &len) == -1); @@ -955,7 +996,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ new_dt = &symt_new_basic(ptd->module, btVoid, typename, 0)->symt; PTS_ABORTIF(ptd, strcmp(typename, "void")); } - } + } *stabs_find_ref(filenr1, subnr1) = *ret_dt = new_dt; @@ -964,7 +1005,7 @@ static int stabs_pts_read_type_def(struct ParseTypedefData* ptd, const char* typ return 0; } -static int stabs_parse_typedef(struct module* module, const char* ptr, +static int stabs_parse_typedef(struct module* module, const char* ptr, const char* typename) { struct ParseTypedefData ptd; @@ -973,7 +1014,7 @@ static int stabs_parse_typedef(struct module* module, const char* ptr, /* check for already existing definition */ - TRACE("%s\n", debugstr_a(ptr)); + TRACE("%s => %s\n", typename, debugstr_a(ptr)); ptd.module = module; ptd.idx = 0; #ifdef PTS_DEBUG @@ -992,7 +1033,7 @@ static int stabs_parse_typedef(struct module* module, const char* ptr, ret = stabs_pts_read_type_def(&ptd, typename, &dt); } - if (ret == -1 || *ptd.ptr) + if (ret == -1 || *ptd.ptr) { #ifdef PTS_DEBUG int i; @@ -1001,13 +1042,13 @@ static int stabs_parse_typedef(struct module* module, const char* ptr, { for (i = 0; i < ptd.err_idx; i++) { - TRACE("[%d]: line %d => %s\n", + TRACE("[%d]: line %d => %s\n", i, ptd.errors[i].line, debugstr_a(ptd.errors[i].ptr)); } } else TRACE("[0]: => %s\n", debugstr_a(ptd.ptr)); - + #else ERR("Failure on %s at %s\n", debugstr_a(ptr), debugstr_a(ptd.ptr)); #endif @@ -1052,23 +1093,66 @@ struct pending_loc_var { char name[256]; struct symt* type; - unsigned offset; - unsigned regno; + enum DataKind kind; + struct location loc; }; +struct pending_block +{ + struct pending_loc_var* vars; + unsigned num; + unsigned allocated; +}; + +static inline void pending_add(struct pending_block* pending, const char* name, + enum DataKind dt, const struct location* loc) +{ + if (pending->num == pending->allocated) + { + pending->allocated += 8; + if (!pending->vars) + pending->vars = HeapAlloc(GetProcessHeap(), 0, + pending->allocated * sizeof(pending->vars[0])); + else + pending->vars = HeapReAlloc(GetProcessHeap(), 0, pending->vars, + pending->allocated * sizeof(pending->vars[0])); + } + stab_strcpy(pending->vars[pending->num].name, + sizeof(pending->vars[pending->num].name), name); + pending->vars[pending->num].type = stabs_parse_type(name); + pending->vars[pending->num].kind = dt; + pending->vars[pending->num].loc = *loc; + pending->num++; +} + +static void pending_flush(struct pending_block* pending, struct module* module, + struct symt_function* func, struct symt_block* block) +{ + int i; + + for (i = 0; i < pending->num; i++) + { + symt_add_func_local(module, func, + pending->vars[i].kind, &pending->vars[i].loc, + block, pending->vars[i].type, pending->vars[i].name); + } + pending->num = 0; +} + /****************************************************************** * stabs_finalize_function * * Ends function creation: mainly: * - cleans up line number information * - tries to set up a debug-start tag (FIXME: heuristic to be enhanced) - * - for stabs which have abolute address in them, initializes the size of the + * - for stabs which have abolute address in them, initializes the size of the * function (assuming that current function ends where next function starts) */ static void stabs_finalize_function(struct module* module, struct symt_function* func, - unsigned long end) + unsigned long size) { IMAGEHLP_LINE il; + struct location loc; if (!func) return; symt_normalize_function(module, func); @@ -1078,22 +1162,23 @@ static void stabs_finalize_function(struct module* module, struct symt_function* if (symt_fill_func_line_info(module, func, func->address, &il) && symt_get_func_line_next(module, &il)) { - symt_add_function_point(module, func, SymTagFuncDebugStart, - il.Address - func->address, NULL); + loc.kind = loc_absolute; + loc.offset = il.Address - func->address; + symt_add_function_point(module, func, SymTagFuncDebugStart, + &loc, NULL); } - if (end) func->size = end - func->address; + if (size) func->size = size; } -BOOL stabs_parse(struct module* module, unsigned long load_offset, +BOOL stabs_parse(struct module* module, unsigned long load_offset, const void* pv_stab_ptr, int stablen, const char* strs, int strtablen) { struct symt_function* curr_func = NULL; struct symt_block* block = NULL; struct symt_compiland* compiland = NULL; - char currpath[PATH_MAX]; /* path to current file */ char srcpath[PATH_MAX]; /* path to directory source file is in */ - int i, j; + int i; int nstab; const char* ptr; char* stabbuff; @@ -1105,16 +1190,16 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, unsigned incl[32]; int incl_stk = -1; int source_idx = -1; - struct pending_loc_var* pending_vars = NULL; - unsigned num_pending_vars = 0; - unsigned num_allocated_pending_vars = 0; + struct pending_block pending; BOOL ret = TRUE; + struct location loc; nstab = stablen / sizeof(struct stab_nlist); strs_end = strs + strtablen; memset(srcpath, 0, sizeof(srcpath)); memset(stabs_basic, 0, sizeof(stabs_basic)); + memset(&pending, 0, sizeof(pending)); /* * Allocate a buffer into which we can build stab strings for cases @@ -1133,7 +1218,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, WARN("Bad stabs string %p\n", ptr); continue; } - if (ptr[strlen(ptr) - 1] == '\\') + if (*ptr != '\0' && (ptr[strlen(ptr) - 1] == '\\')) { /* * Indicates continuation. Append this to the buffer, and go onto the @@ -1164,6 +1249,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, case N_RSYM: case N_LSYM: case N_ROSYM: + case N_PSYM: if (strchr(ptr, '=') != NULL) { /* @@ -1185,42 +1271,6 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, } } -#if 0 - const char* defs[] = {"","","","", /* 00 */ - "","","","", /* 08 */ - "","","","", /* 10 */ - "","","","", /* 18 */ - "gsym","","fun","stsym", /* 20 */ - "lcsym","main","rosym","", /* 28 */ - "","","","", /* 30 */ - "","","opt","", /* 38 */ - "rsym","","sline","", /* 40 */ - "","","","", /* 48 */ - "","","","", /* 50 */ - "","","","", /* 58 */ - "","","so","", /* 60 */ - "","","","", /* 68 */ - "","","","", /* 70 */ - "","","","", /* 78 */ - "lsym","bincl","sol","", /* 80 */ - "","","","", /* 88 */ - "","","","", /* 90 */ - "","","","", /* 98 */ - "psym","eincl","","", /* a0 */ - "","","","", /* a8 */ - "","","","", /* b0 */ - "","","","", /* b8 */ - "lbrac","excl","","", /* c0 */ - "","","","", /* c8 */ - "","","","", /* d0 */ - "","","","", /* d8 */ - "rbrac","","","", /* e0 */ - }; - - FIXME("Got %s<%u> %u/%lu (%s)\n", - defs[stab_ptr->n_type / 2], stab_ptr->n_type, stab_ptr->n_desc, stab_ptr->n_value, debugstr_a(ptr)); -#endif - switch (stab_ptr->n_type) { case N_GSYM: @@ -1246,19 +1296,17 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, stabs_parse_type(ptr)); break; case N_LBRAC: - block = symt_open_func_block(module, curr_func, block, - stab_ptr->n_value, 0); - for (j = 0; j < num_pending_vars; j++) + if (curr_func) { - symt_add_func_local(module, curr_func, pending_vars[j].regno, - pending_vars[j].offset, - block, pending_vars[j].type, pending_vars[j].name); + block = symt_open_func_block(module, curr_func, block, + stab_ptr->n_value, 0); + pending_flush(&pending, module, curr_func, block); } - num_pending_vars = 0; break; case N_RBRAC: - block = symt_close_func_block(module, curr_func, block, - stab_ptr->n_value); + if (curr_func) + block = symt_close_func_block(module, curr_func, block, + stab_ptr->n_value); break; case N_PSYM: /* These are function parameters. */ @@ -1266,10 +1314,14 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, { struct symt* param_type = stabs_parse_type(ptr); stab_strcpy(symname, sizeof(symname), ptr); - symt_add_func_local(module, curr_func, 0, stab_ptr->n_value, - NULL, param_type, symname); - symt_add_function_signature_parameter(module, - (struct symt_function_signature*)curr_func->type, + loc.kind = loc_regrel; + loc.reg = 0; /* FIXME */ + loc.offset = stab_ptr->n_value; + symt_add_func_local(module, curr_func, + (long)stab_ptr->n_value >= 0 ? DataIsParam : DataIsLocal, + &loc, NULL, param_type, symname); + symt_add_function_signature_parameter(module, + (struct symt_function_signature*)curr_func->type, param_type); } break; @@ -1277,28 +1329,19 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, /* These are registers (as local variables) */ if (curr_func != NULL) { - unsigned reg; + loc.kind = loc_register; + loc.offset = 0; - if (num_pending_vars == num_allocated_pending_vars) - { - num_allocated_pending_vars += 8; - if (!pending_vars) - pending_vars = HeapAlloc(GetProcessHeap(), 0, - num_allocated_pending_vars * sizeof(pending_vars[0])); - else - pending_vars = HeapReAlloc(GetProcessHeap(), 0, pending_vars, - num_allocated_pending_vars * sizeof(pending_vars[0])); - } switch (stab_ptr->n_value) { - case 0: reg = CV_REG_EAX; break; - case 1: reg = CV_REG_ECX; break; - case 2: reg = CV_REG_EDX; break; - case 3: reg = CV_REG_EBX; break; - case 4: reg = CV_REG_ESP; break; - case 5: reg = CV_REG_EBP; break; - case 6: reg = CV_REG_ESI; break; - case 7: reg = CV_REG_EDI; break; + case 0: loc.reg = CV_REG_EAX; break; + case 1: loc.reg = CV_REG_ECX; break; + case 2: loc.reg = CV_REG_EDX; break; + case 3: loc.reg = CV_REG_EBX; break; + case 4: loc.reg = CV_REG_ESP; break; + case 5: loc.reg = CV_REG_EBP; break; + case 6: loc.reg = CV_REG_ESI; break; + case 7: loc.reg = CV_REG_EDI; break; case 11: case 12: case 13: @@ -1307,42 +1350,33 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, case 16: case 17: case 18: - case 19: reg = CV_REG_ST0 + stab_ptr->n_value - 12; break; + case 19: loc.reg = CV_REG_ST0 + stab_ptr->n_value - 12; break; default: FIXME("Unknown register value (%lu)\n", stab_ptr->n_value); - reg = CV_REG_NONE; + loc.reg = CV_REG_NONE; break; } - - stab_strcpy(pending_vars[num_pending_vars].name, - sizeof(pending_vars[num_pending_vars].name), ptr); - pending_vars[num_pending_vars].type = stabs_parse_type(ptr); - pending_vars[num_pending_vars].offset = 0; - pending_vars[num_pending_vars].regno = reg; - num_pending_vars++; + stab_strcpy(symname, sizeof(symname), ptr); + if (ptr[strlen(symname) + 1] == 'P') + { + struct symt* param_type = stabs_parse_type(ptr); + stab_strcpy(symname, sizeof(symname), ptr); + symt_add_func_local(module, curr_func, DataIsParam, &loc, + NULL, param_type, symname); + symt_add_function_signature_parameter(module, + (struct symt_function_signature*)curr_func->type, + param_type); + } + else + pending_add(&pending, ptr, DataIsLocal, &loc); } break; case N_LSYM: /* These are local variables */ - if (curr_func != NULL) - { - if (num_pending_vars == num_allocated_pending_vars) - { - num_allocated_pending_vars += 8; - if (!pending_vars) - pending_vars = HeapAlloc(GetProcessHeap(), 0, - num_allocated_pending_vars * sizeof(pending_vars[0])); - else - pending_vars = HeapReAlloc(GetProcessHeap(), 0, pending_vars, - num_allocated_pending_vars * sizeof(pending_vars[0])); - } - stab_strcpy(pending_vars[num_pending_vars].name, - sizeof(pending_vars[num_pending_vars].name), ptr); - pending_vars[num_pending_vars].type = stabs_parse_type(ptr); - pending_vars[num_pending_vars].offset = stab_ptr->n_value; - pending_vars[num_pending_vars].regno = 0; - num_pending_vars++; - } + loc.kind = loc_regrel; + loc.reg = 0; /* FIXME */ + loc.offset = stab_ptr->n_value; + if (curr_func != NULL) pending_add(&pending, ptr, DataIsLocal, &loc); break; case N_SLINE: /* @@ -1352,15 +1386,11 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, if (curr_func != NULL) { assert(source_idx >= 0); - symt_add_func_line(module, curr_func, source_idx, + symt_add_func_line(module, curr_func, source_idx, stab_ptr->n_desc, stab_ptr->n_value); } break; case N_FUN: - /* First, clean up the previous function we were working on. */ - stabs_finalize_function(module, curr_func, - stab_ptr->n_value ? load_offset + stab_ptr->n_value : 0); - /* * For now, just declare the various functions. Later * on, we will add the line number information and the @@ -1377,15 +1407,29 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, if (*symname) { struct symt_function_signature* func_type; - func_type = symt_new_function_signature(module, - stabs_parse_type(ptr)); - curr_func = symt_new_function(module, compiland, symname, + + if (curr_func) + { + /* First, clean up the previous function we were working on. + * Assume size of the func is the delta between current offset + * and offset of last function + */ + stabs_finalize_function(module, curr_func, + stab_ptr->n_value ? + (load_offset + stab_ptr->n_value - curr_func->address) : 0); + } + func_type = symt_new_function_signature(module, + stabs_parse_type(ptr), -1); + curr_func = symt_new_function(module, compiland, symname, load_offset + stab_ptr->n_value, 0, &func_type->symt); } else { - /* some GCC seem to use a N_FUN "" to mark the end of a function */ + /* some versions of GCC to use a N_FUN "" to mark the end of a function + * and n_value contains the size of the func + */ + stabs_finalize_function(module, curr_func, stab_ptr->n_value); curr_func = NULL; } break; @@ -1398,8 +1442,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, { /* Nuke old path. */ srcpath[0] = '\0'; - stabs_finalize_function(module, curr_func, - stab_ptr->n_value ? load_offset + stab_ptr->n_value : 0); + stabs_finalize_function(module, curr_func, 0); curr_func = NULL; source_idx = -1; incl_stk = -1; @@ -1411,33 +1454,27 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, int len = strlen(ptr); if (ptr[len-1] != '/') { - strcpy(currpath, srcpath); - strcat(currpath, ptr); stabs_reset_includes(); - compiland = symt_new_compiland(module, currpath); - source_idx = source_new(module, currpath); + source_idx = source_new(module, srcpath, ptr); + compiland = symt_new_compiland(module, 0 /* FIXME */, source_idx); } else strcpy(srcpath, ptr); } break; case N_SOL: - if (*ptr != '/') - { - strcpy(currpath, srcpath); - strcat(currpath, ptr); - } - else - strcpy(currpath, ptr); - source_idx = source_new(module, currpath); + source_idx = source_new(module, srcpath, ptr); break; case N_UNDF: strs += strtabinc; strtabinc = stab_ptr->n_value; /* I'm not sure this is needed, so trace it before we obsolete it */ - if (curr_func) FIXME("UNDF: curr_func %s\n", curr_func->hash_elt.name); - stabs_finalize_function(module, curr_func, 0); /* FIXME */ - curr_func = NULL; + if (curr_func) + { + FIXME("UNDF: curr_func %s\n", curr_func->hash_elt.name); + stabs_finalize_function(module, curr_func, 0); /* FIXME */ + curr_func = NULL; + } break; case N_OPT: /* Ignore this. We don't care what it points to. */ @@ -1446,7 +1483,7 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, stabs_add_include(stabs_new_include(ptr, stab_ptr->n_value)); assert(incl_stk < (int)(sizeof(incl) / sizeof(incl[0])) - 1); incl[++incl_stk] = source_idx; - source_idx = source_new(module, ptr); + source_idx = source_new(module, NULL, ptr); break; case N_EINCL: assert(incl_stk >= 0); @@ -1464,19 +1501,30 @@ BOOL stabs_parse(struct module* module, unsigned long load_offset, case N_MAIN: /* Always ignore these. GCC doesn't even generate them. */ break; + case N_BNSYM: + case N_ENSYM: + /* Always ignore these, they seem to be used only on Darwin. */ + break; default: ERR("Unknown stab type 0x%02x\n", stab_ptr->n_type); break; } stabbuff[0] = '\0'; - TRACE("0x%02x %lx %s\n", + TRACE("0x%02x %lx %s\n", stab_ptr->n_type, stab_ptr->n_value, debugstr_a(strs + stab_ptr->n_un.n_strx)); } module->module.SymType = SymDia; + module->module.CVSig = 'S' | ('T' << 8) | ('A' << 16) | ('B' << 24); + /* FIXME: we could have a finer grain here */ + module->module.LineNumbers = TRUE; + module->module.GlobalSymbols = TRUE; + module->module.TypeInfo = TRUE; + module->module.SourceIndexed = TRUE; + module->module.Publics = TRUE; done: HeapFree(GetProcessHeap(), 0, stabbuff); stabs_free_includes(); - if (pending_vars) HeapFree(GetProcessHeap(), 0, pending_vars); + HeapFree(GetProcessHeap(), 0, pending.vars); return ret; } diff --git a/reactos/dll/win32/dbghelp/stack.c b/reactos/dll/win32/dbghelp/stack.c index 248de457700..9b70f09a13a 100644 --- a/reactos/dll/win32/dbghelp/stack.c +++ b/reactos/dll/win32/dbghelp/stack.c @@ -18,7 +18,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" @@ -27,11 +27,12 @@ #include #include +#include "ntstatus.h" +#define WIN32_NO_STATUS #include "dbghelp_private.h" -#include "winreg.h" -#include "thread.h" /* FIXME: must be included before winternl.h */ +#include "winternl.h" +#include "wine/winbase16.h" #include "wine/debug.h" -#include "stackframe.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); @@ -43,18 +44,36 @@ static const char* wine_dbgstr_addr(const ADDRESS* addr) switch (addr->Mode) { case AddrModeFlat: - return wine_dbg_sprintf("flat<%08lx>", addr->Offset); + return wine_dbg_sprintf("flat<%08x>", addr->Offset); case AddrMode1616: - return wine_dbg_sprintf("1616<%04x:%04lx>", addr->Segment, addr->Offset); + return wine_dbg_sprintf("1616<%04x:%04x>", addr->Segment, addr->Offset); case AddrMode1632: - return wine_dbg_sprintf("1632<%04x:%08lx>", addr->Segment, addr->Offset); + return wine_dbg_sprintf("1632<%04x:%08x>", addr->Segment, addr->Offset); case AddrModeReal: - return wine_dbg_sprintf("real<%04x:%04lx>", addr->Segment, addr->Offset); + return wine_dbg_sprintf("real<%04x:%04x>", addr->Segment, addr->Offset); default: return "unknown"; } } +static BOOL CALLBACK read_mem(HANDLE hProcess, DWORD addr, void* buffer, + DWORD size, LPDWORD nread) +{ + SIZE_T r; + if (!ReadProcessMemory(hProcess, (void*)addr, buffer, size, &r)) return FALSE; + if (nread) *nread = r; + return TRUE; +} + +static BOOL CALLBACK read_mem64(HANDLE hProcess, DWORD64 addr, void* buffer, + DWORD size, LPDWORD nread) +{ + SIZE_T r; + if (!ReadProcessMemory(hProcess, (void*)(DWORD_PTR)addr, buffer, size, &r)) return FALSE; + if (nread) *nread = r; + return TRUE; +} + /* indexes in Reserved array */ #define __CurrentMode 0 #define __CurrentSwitch 1 @@ -64,15 +83,83 @@ static const char* wine_dbgstr_addr(const ADDRESS* addr) #define curr_switch (frame->Reserved[__CurrentSwitch]) #define next_switch (frame->Reserved[__NextSwitch]) -/*********************************************************************** - * StackWalk (DBGHELP.@) - */ -BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, - LPSTACKFRAME frame, LPVOID ctx, - PREAD_PROCESS_MEMORY_ROUTINE f_read_mem, - PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, - PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, - PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr) +struct stack_walk_callback +{ + HANDLE hProcess; + HANDLE hThread; + BOOL is32; + union + { + struct + { + PREAD_PROCESS_MEMORY_ROUTINE f_read_mem; + PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr; + PFUNCTION_TABLE_ACCESS_ROUTINE f_tabl_acs; + PGET_MODULE_BASE_ROUTINE f_modl_bas; + } s32; + struct + { + PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem; + PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr; + PFUNCTION_TABLE_ACCESS_ROUTINE64 f_tabl_acs; + PGET_MODULE_BASE_ROUTINE64 f_modl_bas; + } s64; + } u; +}; + +static inline void addr_32to64(const ADDRESS* addr32, ADDRESS64* addr64) +{ + addr64->Offset = (ULONG64)addr32->Offset; + addr64->Segment = addr32->Segment; + addr64->Mode = addr32->Mode; +} + +static inline void addr_64to32(const ADDRESS64* addr64, ADDRESS* addr32) +{ + addr32->Offset = (ULONG)addr64->Offset; + addr32->Segment = addr64->Segment; + addr32->Mode = addr64->Mode; +} + +static inline BOOL sw_read_mem(struct stack_walk_callback* cb, DWORD addr, void* ptr, DWORD sz) +{ + if (cb->is32) + return cb->u.s32.f_read_mem(cb->hProcess, addr, ptr, sz, NULL); + else + return cb->u.s64.f_read_mem(cb->hProcess, addr, ptr, sz, NULL); +} + +static inline DWORD sw_xlat_addr(struct stack_walk_callback* cb, ADDRESS* addr) +{ + if (addr->Mode == AddrModeFlat) return addr->Offset; + if (cb->is32) return cb->u.s32.f_xlat_adr(cb->hProcess, cb->hThread, addr); + if (cb->u.s64.f_xlat_adr) + { + ADDRESS64 addr64; + + addr_32to64(addr, &addr64); + return cb->u.s64.f_xlat_adr(cb->hProcess, cb->hThread, &addr64); + } + return addr_to_linear(cb->hProcess, cb->hThread, addr); +} + +static inline void* sw_tabl_acs(struct stack_walk_callback* cb, DWORD addr) +{ + if (cb->is32) + return cb->u.s32.f_tabl_acs(cb->hProcess, addr); + else + return cb->u.s64.f_tabl_acs(cb->hProcess, addr); +} + +static inline DWORD sw_modl_bas(struct stack_walk_callback* cb, DWORD addr) +{ + if (cb->is32) + return cb->u.s32.f_modl_bas(cb->hProcess, addr); + else + return cb->u.s64.f_modl_bas(cb->hProcess, addr); +} + +static BOOL stack_walk(struct stack_walk_callback* cb, LPSTACKFRAME frame) { STACK32FRAME frame32; STACK16FRAME frame16; @@ -82,34 +169,20 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, WORD val; BOOL do_switch; - TRACE("(%ld, %p, %p, %p, %p, %p, %p, %p, %p)\n", - MachineType, hProcess, hThread, frame, ctx, - f_read_mem, FunctionTableAccessRoutine, - GetModuleBaseRoutine, f_xlat_adr); - - if (MachineType != IMAGE_FILE_MACHINE_I386) - { - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; - } - /* sanity check */ if (curr_mode >= stm_done) return FALSE; - if (!f_read_mem) f_read_mem = ReadProcessMemory; - if (!f_xlat_adr) f_xlat_adr = addr_to_linear; - - TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx\n", + TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08x nSwitch=%08x\n", wine_dbgstr_addr(&frame->AddrPC), wine_dbgstr_addr(&frame->AddrFrame), wine_dbgstr_addr(&frame->AddrReturn), - wine_dbgstr_addr(&frame->AddrStack), + wine_dbgstr_addr(&frame->AddrStack), curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"), curr_switch, next_switch); if (curr_mode == stm_start) { - /*THREAD_BASIC_INFORMATION info;*/ + THREAD_BASIC_INFORMATION info; if ((frame->AddrPC.Mode == AddrModeFlat) && (frame->AddrFrame.Mode != AddrModeFlat)) @@ -119,60 +192,62 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, } /* Init done */ - curr_mode = (frame->AddrPC.Mode == AddrModeFlat) ? + curr_mode = (frame->AddrPC.Mode == AddrModeFlat) ? stm_32bit : stm_16bit; - /* cur_switch holds address of curr_stack's field in TEB in debuggee + /* cur_switch holds address of WOW32Reserved field in TEB in debuggee * address space */ - /* - if (NtQueryInformationThread(hThread, ThreadBasicInformation, &info, - sizeof(info), NULL) != STATUS_SUCCESS) - goto done_err; - curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, cur_stack); */ - if (!f_read_mem(hProcess, (void*)curr_switch, &next_switch, - sizeof(next_switch), NULL)) + if (NtQueryInformationThread(cb->hThread, ThreadBasicInformation, &info, + sizeof(info), NULL) == STATUS_SUCCESS) { - WARN("Can't read TEB:cur_stack\n"); - goto done_err; - } - if (curr_mode == stm_16bit) - { - if (!f_read_mem(hProcess, (void*)next_switch, &frame32, - sizeof(frame32), NULL)) + curr_switch = (unsigned long)info.TebBaseAddress + FIELD_OFFSET(TEB, WOW32Reserved); + if (!sw_read_mem(cb, curr_switch, &next_switch, sizeof(next_switch))) { - WARN("Bad stack frame 0x%08lx\n", next_switch); + WARN("Can't read TEB:WOW32Reserved\n"); goto done_err; } - curr_switch = (DWORD)frame32.frame16; - tmp.Mode = AddrMode1616; - tmp.Segment = SELECTOROF(curr_switch); - tmp.Offset = OFFSETOF(curr_switch); - if (!f_read_mem(hProcess, (void*)f_xlat_adr(hProcess, hThread, &tmp), - &ch, sizeof(ch), NULL)) - curr_switch = 0xFFFFFFFF; - frame->AddrReturn.Mode = frame->AddrStack.Mode = AddrMode1616; + if (curr_mode == stm_16bit) + { + if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32))) + { + WARN("Bad stack frame 0x%08x\n", next_switch); + goto done_err; + } + curr_switch = (DWORD)frame32.frame16; + tmp.Mode = AddrMode1616; + tmp.Segment = SELECTOROF(curr_switch); + tmp.Offset = OFFSETOF(curr_switch); + if (!sw_read_mem(cb, sw_xlat_addr(cb, &tmp), &ch, sizeof(ch))) + curr_switch = 0xFFFFFFFF; + } + else + { + tmp.Mode = AddrMode1616; + tmp.Segment = SELECTOROF(next_switch); + tmp.Offset = OFFSETOF(next_switch); + p = sw_xlat_addr(cb, &tmp); + if (!sw_read_mem(cb, p, &frame16, sizeof(frame16))) + { + WARN("Bad stack frame 0x%08x\n", p); + goto done_err; + } + curr_switch = (DWORD)frame16.frame32; + + if (!sw_read_mem(cb, curr_switch, &ch, sizeof(ch))) + curr_switch = 0xFFFFFFFF; + } } else - { - tmp.Mode = AddrMode1616; - tmp.Segment = SELECTOROF(next_switch); - tmp.Offset = OFFSETOF(next_switch); - p = f_xlat_adr(hProcess, hThread, &tmp); - if (!f_read_mem(hProcess, (void*)p, &frame16, sizeof(frame16), NULL)) - { - WARN("Bad stack frame 0x%08lx\n", p); - goto done_err; - } - curr_switch = (DWORD)frame16.frame32; - - if (!f_read_mem(hProcess, (void*)curr_switch, &ch, sizeof(ch), NULL)) - curr_switch = 0xFFFFFFFF; - frame->AddrReturn.Mode = frame->AddrStack.Mode = AddrModeFlat; - } + /* FIXME: this will allow to work when we're not attached to a live target, + * but the 16 <=> 32 switch facility won't be available. + */ + curr_switch = 0; + frame->AddrReturn.Mode = frame->AddrStack.Mode = (curr_mode == stm_16bit) ? AddrMode1616 : AddrModeFlat; /* don't set up AddrStack on first call. Either the caller has set it up, or * we will get it in the next frame */ + memset(&frame->AddrBStore, 0, sizeof(frame->AddrBStore)); } else { @@ -185,19 +260,18 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, else { assert(curr_mode == stm_16bit); - do_switch = OFFSETOF(curr_switch) && + do_switch = curr_switch && frame->AddrFrame.Segment == SELECTOROF(curr_switch) && frame->AddrFrame.Offset >= OFFSETOF(curr_switch); } - + if (do_switch) { if (curr_mode == stm_16bit) { - if (!f_read_mem(hProcess, (void*)next_switch, &frame32, - sizeof(frame32), NULL)) + if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32))) { - WARN("Bad stack frame 0x%08lx\n", next_switch); + WARN("Bad stack frame 0x%08x\n", next_switch); goto done_err; } @@ -217,37 +291,37 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, tmp.Mode = AddrMode1616; tmp.Segment = SELECTOROF(next_switch); tmp.Offset = OFFSETOF(next_switch); - p = f_xlat_adr(hProcess, hThread, &tmp); + p = sw_xlat_addr(cb, &tmp); - if (!f_read_mem(hProcess, (void*)p, &frame16, sizeof(frame16), NULL)) + if (!sw_read_mem(cb, p, &frame16, sizeof(frame16))) { - WARN("Bad stack frame 0x%08lx\n", p); + WARN("Bad stack frame 0x%08x\n", p); goto done_err; } curr_switch = (DWORD)frame16.frame32; curr_mode = stm_32bit; - if (!f_read_mem(hProcess, (void*)curr_switch, &ch, sizeof(ch), NULL)) - curr_switch = 0xFFFFFFFF; + if (!sw_read_mem(cb, curr_switch, &ch, sizeof(ch))) + curr_switch = 0; } else { tmp.Mode = AddrMode1616; tmp.Segment = SELECTOROF(next_switch); tmp.Offset = OFFSETOF(next_switch); - p = f_xlat_adr(hProcess, hThread, &tmp); + p = sw_xlat_addr(cb, &tmp); - if (!f_read_mem(hProcess, (void*)p, &frame16, sizeof(frame16), NULL)) + if (!sw_read_mem(cb, p, &frame16, sizeof(frame16))) { - WARN("Bad stack frame 0x%08lx\n", p); + WARN("Bad stack frame 0x%08x\n", p); goto done_err; } TRACE("Got a 16 bit stack switch:" "\n\tframe32: %08lx" - "\n\tedx:%08lx ecx:%08lx ebp:%08lx" + "\n\tedx:%08x ecx:%08x ebp:%08x" "\n\tds:%04x es:%04x fs:%04x gs:%04x" - "\n\tcall_from_ip:%08lx module_cs:%04lx relay=%08lx" - "\n\tentry_ip:%04x entry_point:%08lx" + "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x" + "\n\tentry_ip:%04x entry_point:%08x" "\n\tbp:%04x ip:%04x cs:%04x\n", (unsigned long)frame16.frame32, frame16.edx, frame16.ecx, frame16.ebp, @@ -256,7 +330,7 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, frame16.entry_ip, frame16.entry_point, frame16.bp, frame16.ip, frame16.cs); - + frame->AddrPC.Mode = AddrMode1616; frame->AddrPC.Segment = frame16.cs; frame->AddrPC.Offset = frame16.ip; @@ -272,10 +346,9 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, frame->AddrReturn.Segment = frame16.cs; next_switch = curr_switch; - if (!f_read_mem(hProcess, (void*)next_switch, &frame32, sizeof(frame32), - NULL)) + if (!sw_read_mem(cb, next_switch, &frame32, sizeof(frame32))) { - WARN("Bad stack frame 0x%08lx\n", next_switch); + WARN("Bad stack frame 0x%08x\n", next_switch); goto done_err; } curr_switch = (DWORD)frame32.frame16; @@ -283,9 +356,8 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, tmp.Segment = SELECTOROF(curr_switch); tmp.Offset = OFFSETOF(curr_switch); - if (!f_read_mem(hProcess, (void*)f_xlat_adr(hProcess, hThread, &tmp), - &ch, sizeof(ch), NULL)) - curr_switch = 0xFFFFFFFF; + if (!sw_read_mem(cb, sw_xlat_addr(cb, &tmp), &ch, sizeof(ch))) + curr_switch = 0; curr_mode = stm_16bit; } } @@ -296,9 +368,8 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, { frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(WORD); /* "pop up" previous BP value */ - if (!f_read_mem(hProcess, - (void*)f_xlat_adr(hProcess, hThread, &frame->AddrFrame), - &val, sizeof(WORD), NULL)) + if (!sw_read_mem(cb, sw_xlat_addr(cb, &frame->AddrFrame), + &val, sizeof(WORD))) goto done_err; frame->AddrFrame.Offset = val; } @@ -306,8 +377,8 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, { frame->AddrStack.Offset = frame->AddrFrame.Offset + 2 * sizeof(DWORD); /* "pop up" previous EBP value */ - if (!f_read_mem(hProcess, (void*)frame->AddrFrame.Offset, - &frame->AddrFrame.Offset, sizeof(DWORD), NULL)) + if (!sw_read_mem(cb, frame->AddrFrame.Offset, + &frame->AddrFrame.Offset, sizeof(DWORD))) goto done_err; } } @@ -317,30 +388,29 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, { int i; - p = f_xlat_adr(hProcess, hThread, &frame->AddrFrame); - if (!f_read_mem(hProcess, (void*)(p + sizeof(WORD)), &val, sizeof(WORD), NULL)) + p = sw_xlat_addr(cb, &frame->AddrFrame); + if (!sw_read_mem(cb, p + sizeof(WORD), &val, sizeof(WORD))) goto done_err; frame->AddrReturn.Offset = val; /* get potential cs if a far call was used */ - if (!f_read_mem(hProcess, (void*)(p + 2 * sizeof(WORD)), - &val, sizeof(WORD), NULL)) + if (!sw_read_mem(cb, p + 2 * sizeof(WORD), &val, sizeof(WORD))) goto done_err; if (frame->AddrFrame.Offset & 1) frame->AddrReturn.Segment = val; /* far call assumed */ else { - /* not explicitly marked as far call, + /* not explicitly marked as far call, * but check whether it could be anyway */ if ((val & 7) == 7 && val != frame->AddrReturn.Segment) { LDT_ENTRY le; - if (GetThreadSelectorEntry(hThread, val, &le) && + if (GetThreadSelectorEntry(cb->hThread, val, &le) && (le.HighWord.Bits.Type & 0x08)) /* code segment */ { /* it is very uncommon to push a code segment cs as - * a parameter, so this should work in most cases + * a parameter, so this should work in most cases */ frame->AddrReturn.Segment = val; } @@ -353,35 +423,181 @@ BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, */ for (i = 0; i < sizeof(frame->Params) / sizeof(frame->Params[0]); i++) { - f_read_mem(hProcess, (void*)(p + (2 + i) * sizeof(WORD)), - &val, sizeof(val), NULL); + sw_read_mem(cb, p + (2 + i) * sizeof(WORD), &val, sizeof(val)); frame->Params[i] = val; } } else { - if (!f_read_mem(hProcess, - (void*)(frame->AddrFrame.Offset + sizeof(DWORD)), - &frame->AddrReturn.Offset, sizeof(DWORD), NULL)) + if (!sw_read_mem(cb, frame->AddrFrame.Offset + sizeof(DWORD), + &frame->AddrReturn.Offset, sizeof(DWORD))) + { + WARN("Cannot read new frame offset %08x\n", frame->AddrFrame.Offset + (int)sizeof(DWORD)); goto done_err; - f_read_mem(hProcess, - (void*)(frame->AddrFrame.Offset + 2 * sizeof(DWORD)), - frame->Params, sizeof(frame->Params), NULL); + } + sw_read_mem(cb, frame->AddrFrame.Offset + 2 * sizeof(DWORD), + frame->Params, sizeof(frame->Params)); } - frame->Far = FALSE; - frame->Virtual = FALSE; + frame->Far = TRUE; + frame->Virtual = TRUE; + p = sw_xlat_addr(cb, &frame->AddrPC); + if (p && sw_modl_bas(cb, p)) + frame->FuncTableEntry = sw_tabl_acs(cb, p); + else + frame->FuncTableEntry = NULL; - TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx\n", + TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08x nSwitch=%08x FuncTable=%p\n", wine_dbgstr_addr(&frame->AddrPC), wine_dbgstr_addr(&frame->AddrFrame), wine_dbgstr_addr(&frame->AddrReturn), - wine_dbgstr_addr(&frame->AddrStack), + wine_dbgstr_addr(&frame->AddrStack), curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"), - curr_switch, next_switch); + curr_switch, next_switch, frame->FuncTableEntry); return TRUE; done_err: curr_mode = stm_done; return FALSE; } + +/*********************************************************************** + * StackWalk (DBGHELP.@) + */ +BOOL WINAPI StackWalk(DWORD MachineType, HANDLE hProcess, HANDLE hThread, + LPSTACKFRAME frame, PVOID ctx, + PREAD_PROCESS_MEMORY_ROUTINE f_read_mem, + PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine, + PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine, + PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr) +{ + struct stack_walk_callback swcb; + + TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", + MachineType, hProcess, hThread, frame, ctx, + f_read_mem, FunctionTableAccessRoutine, + GetModuleBaseRoutine, f_xlat_adr); + + if (MachineType != IMAGE_FILE_MACHINE_I386) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + swcb.hProcess = hProcess; + swcb.hThread = hThread; + swcb.is32 = TRUE; + /* sigh... MS isn't even consistent in the func prototypes */ + swcb.u.s32.f_read_mem = (f_read_mem) ? f_read_mem : read_mem; + swcb.u.s32.f_xlat_adr = (f_xlat_adr) ? f_xlat_adr : addr_to_linear; + swcb.u.s32.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess; + swcb.u.s32.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase; + + return stack_walk(&swcb, frame); +} + + +/*********************************************************************** + * StackWalk64 (DBGHELP.@) + */ +BOOL WINAPI StackWalk64(DWORD MachineType, HANDLE hProcess, HANDLE hThread, + LPSTACKFRAME64 frame64, PVOID ctx, + PREAD_PROCESS_MEMORY_ROUTINE64 f_read_mem, + PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, + PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, + PTRANSLATE_ADDRESS_ROUTINE64 f_xlat_adr) +{ + struct stack_walk_callback swcb; + STACKFRAME frame32; + BOOL ret; + + TRACE("(%d, %p, %p, %p, %p, %p, %p, %p, %p)\n", + MachineType, hProcess, hThread, frame64, ctx, + f_read_mem, FunctionTableAccessRoutine, + GetModuleBaseRoutine, f_xlat_adr); + + if (MachineType != IMAGE_FILE_MACHINE_I386) + { + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + addr_64to32(&frame64->AddrPC, &frame32.AddrPC); + addr_64to32(&frame64->AddrReturn, &frame32.AddrReturn); + addr_64to32(&frame64->AddrFrame, &frame32.AddrFrame); + addr_64to32(&frame64->AddrStack, &frame32.AddrStack); + addr_64to32(&frame64->AddrBStore, &frame32.AddrBStore); + frame32.FuncTableEntry = frame64->FuncTableEntry; /* FIXME */ + frame32.Far = frame64->Far; + frame32.Virtual = frame64->Virtual; + frame32.Reserved[0] = (ULONG)frame64->Reserved[0]; + frame32.Reserved[1] = (ULONG)frame64->Reserved[1]; + frame32.Reserved[2] = (ULONG)frame64->Reserved[2]; + /* we don't handle KdHelp */ + + swcb.hProcess = hProcess; + swcb.hThread = hThread; + swcb.is32 = FALSE; + /* sigh... MS isn't even consistent in the func prototypes */ + swcb.u.s64.f_read_mem = (f_read_mem) ? f_read_mem : read_mem64; + swcb.u.s64.f_xlat_adr = f_xlat_adr; + swcb.u.s64.f_tabl_acs = (FunctionTableAccessRoutine) ? FunctionTableAccessRoutine : SymFunctionTableAccess64; + swcb.u.s64.f_modl_bas = (GetModuleBaseRoutine) ? GetModuleBaseRoutine : SymGetModuleBase64; + + ret = stack_walk(&swcb, &frame32); + + addr_32to64(&frame32.AddrPC, &frame64->AddrPC); + addr_32to64(&frame32.AddrReturn, &frame64->AddrReturn); + addr_32to64(&frame32.AddrFrame, &frame64->AddrFrame); + addr_32to64(&frame32.AddrStack, &frame64->AddrStack); + addr_32to64(&frame32.AddrBStore, &frame64->AddrBStore); + frame64->FuncTableEntry = frame32.FuncTableEntry; /* FIXME */ + frame64->Params[0] = frame32.Params[0]; + frame64->Params[1] = frame32.Params[1]; + frame64->Params[2] = frame32.Params[2]; + frame64->Params[3] = frame32.Params[3]; + frame64->Far = frame32.Far; + frame64->Virtual = frame32.Virtual; + frame64->Reserved[0] = frame32.Reserved[0]; + frame64->Reserved[1] = frame32.Reserved[1]; + frame64->Reserved[2] = frame32.Reserved[2]; + /* we don't handle KdHelp */ + frame64->KdHelp.Thread = 0xC000FADE; + frame64->KdHelp.ThCallbackStack = 0x10; + frame64->KdHelp.ThCallbackBStore = 0; + frame64->KdHelp.NextCallback = 0; + frame64->KdHelp.FramePointer = 0; + frame64->KdHelp.KiCallUserMode = 0xD000DAFE; + frame64->KdHelp.KeUserCallbackDispatcher = 0xE000F000; + frame64->KdHelp.SystemRangeStart = 0xC0000000; + frame64->KdHelp.Reserved[0] /* KiUserExceptionDispatcher */ = 0xE0005000; + + return ret; +} + +/****************************************************************** + * SymRegisterFunctionEntryCallback (DBGHELP.@) + * + * + */ +BOOL WINAPI SymRegisterFunctionEntryCallback(HANDLE hProc, + PSYMBOL_FUNCENTRY_CALLBACK cb, PVOID user) +{ + FIXME("(%p %p %p): stub!\n", hProc, cb, user); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} + +/****************************************************************** + * SymRegisterFunctionEntryCallback64 (DBGHELP.@) + * + * + */ +BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE hProc, + PSYMBOL_FUNCENTRY_CALLBACK64 cb, + ULONG64 user) +{ + FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user)); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} diff --git a/reactos/dll/win32/dbghelp/storage.c b/reactos/dll/win32/dbghelp/storage.c index 820e603a4e6..88c9b1de60e 100644 --- a/reactos/dll/win32/dbghelp/storage.c +++ b/reactos/dll/win32/dbghelp/storage.c @@ -16,7 +16,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ @@ -51,41 +51,46 @@ void pool_destroy(struct pool* pool) #ifdef USE_STATS unsigned alloc, used, num; - - for (alloc = used = num = 0, arena = pool->first; arena; arena = arena->next) + + alloc = used = num = 0; + arena = pool->first; + while (arena) { alloc += pool->arena_size; used += arena->current - (char*)arena; num++; + arena = arena->next; } + if (alloc == 0) alloc = 1; /* avoid division by zero */ FIXME("STATS: pool %p has allocated %u kbytes, used %u kbytes in %u arenas,\n" "\t\t\t\tnon-allocation ratio: %.2f%%\n", pool, alloc >> 10, used >> 10, num, 100.0 - (float)used / (float)alloc * 100.0); #endif - for (arena = pool->first; arena; arena = next) + arena = pool->first; + while (arena) { next = arena->next; HeapFree(GetProcessHeap(), 0, arena); + arena = next; } pool_init(pool, 0); } void* pool_alloc(struct pool* pool, unsigned len) { - struct pool_arena** parena; struct pool_arena* arena; void* ret; len = (len + 3) & ~3; /* round up size on DWORD boundary */ assert(sizeof(struct pool_arena) + len <= pool->arena_size && len); - for (parena = &pool->first; *parena; parena = &(*parena)->next) + for (arena = pool->first; arena; arena = arena->next) { - if ((char*)(*parena) + pool->arena_size - (*parena)->current >= len) + if ((char*)arena + pool->arena_size - arena->current >= len) { - ret = (*parena)->current; - (*parena)->current += len; + ret = arena->current; + arena->current += len; return ret; } } @@ -93,41 +98,13 @@ void* pool_alloc(struct pool* pool, unsigned len) arena = HeapAlloc(GetProcessHeap(), 0, pool->arena_size); if (!arena) {FIXME("OOM\n");return NULL;} - *parena = arena; - ret = (char*)arena + sizeof(*arena); - arena->next = NULL; + arena->next = pool->first; + pool->first = arena; arena->current = (char*)ret + len; return ret; } -static struct pool_arena* pool_is_last(struct pool* pool, void* p, unsigned old_size) -{ - struct pool_arena* arena; - - for (arena = pool->first; arena; arena = arena->next) - { - if (arena->current == (char*)p + old_size) return arena; - } - return NULL; -} - -void* pool_realloc(struct pool* pool, void* p, unsigned old_size, unsigned new_size) -{ - struct pool_arena* arena; - void* new; - - if ((arena = pool_is_last(pool, p, old_size)) && - (char*)p + new_size <= (char*)arena + pool->arena_size) - { - arena->current = (char*)p + new_size; - return p; - } - if ((new = pool_alloc(pool, new_size)) && old_size) - memcpy(new, p, min(old_size, new_size)); - return new; -} - char* pool_strdup(struct pool* pool, const char* str) { char* ret; @@ -155,6 +132,7 @@ void vector_init(struct vector* v, unsigned esz, unsigned bucket_sz) default: assert(0); } v->num_buckets = 0; + v->buckets_allocated = 0; v->num_elts = 0; } @@ -180,49 +158,144 @@ void* vector_add(struct vector* v, struct pool* pool) assert(v->num_elts > ncurr); if (ncurr == (v->num_buckets << v->shift)) { - v->buckets = pool_realloc(pool, v->buckets, - v->num_buckets * sizeof(void*), - (v->num_buckets + 1) * sizeof(void*)); + if(v->num_buckets == v->buckets_allocated) + { + /* Double the bucket cache, so it scales well with big vectors.*/ + unsigned new_reserved; + void* new; + + new_reserved = 2*v->buckets_allocated; + if(new_reserved == 0) new_reserved = 1; + + /* Don't even try to resize memory. + Pool datastructure is very inefficient with reallocs. */ + new = pool_alloc(pool, new_reserved * sizeof(void*)); + memcpy(new, v->buckets, v->buckets_allocated * sizeof(void*)); + v->buckets = new; + v->buckets_allocated = new_reserved; + } v->buckets[v->num_buckets] = pool_alloc(pool, v->elt_size << v->shift); return v->buckets[v->num_buckets++]; } return vector_at(v, ncurr); } -static unsigned vector_position(const struct vector* v, const void* elt) +/* We construct the sparse array as two vectors (of equal size) + * The first vector (key2index) is the lookup table between the key and + * an index in the second vector (elements) + * When inserting an element, it's always appended in second vector (and + * never moved in memory later on), only the first vector is reordered + */ +struct key2index { - int i; + unsigned long key; + unsigned index; +}; - for (i = 0; i < v->num_buckets; i++) +void sparse_array_init(struct sparse_array* sa, unsigned elt_sz, unsigned bucket_sz) +{ + vector_init(&sa->key2index, sizeof(struct key2index), bucket_sz); + vector_init(&sa->elements, elt_sz, bucket_sz); +} + +/****************************************************************** + * sparse_array_lookup + * + * Returns the first index which key is >= at passed key + */ +static struct key2index* sparse_array_lookup(const struct sparse_array* sa, + unsigned long key, unsigned* idx) +{ + struct key2index* pk2i; + unsigned low, high; + + if (!sa->elements.num_elts) { - if (v->buckets[i] <= elt && - (const char*)elt < (const char*)v->buckets[i] + (v->elt_size << v->shift)) + *idx = 0; + return NULL; + } + high = sa->elements.num_elts; + pk2i = vector_at(&sa->key2index, high - 1); + if (pk2i->key < key) + { + *idx = high; + return NULL; + } + if (pk2i->key == key) + { + *idx = high - 1; + return pk2i; + } + low = 0; + pk2i = vector_at(&sa->key2index, low); + if (pk2i->key >= key) + { + *idx = 0; + return pk2i; + } + /* now we have: sa(lowest key) < key < sa(highest key) */ + while (low < high) + { + *idx = (low + high) / 2; + pk2i = vector_at(&sa->key2index, *idx); + if (pk2i->key > key) high = *idx; + else if (pk2i->key < key) low = *idx + 1; + else return pk2i; + } + /* binary search could return exact item, we search for highest one + * below the key + */ + if (pk2i->key < key) + pk2i = vector_at(&sa->key2index, ++(*idx)); + return pk2i; +} + +void* sparse_array_find(const struct sparse_array* sa, unsigned long key) +{ + unsigned idx; + struct key2index* pk2i; + + if ((pk2i = sparse_array_lookup(sa, key, &idx)) && pk2i->key == key) + return vector_at(&sa->elements, pk2i->index); + return NULL; +} + +void* sparse_array_add(struct sparse_array* sa, unsigned long key, + struct pool* pool) +{ + unsigned idx, i; + struct key2index* pk2i; + struct key2index* to; + + pk2i = sparse_array_lookup(sa, key, &idx); + if (pk2i && pk2i->key == key) + { + FIXME("re adding an existing key\n"); + return NULL; + } + to = vector_add(&sa->key2index, pool); + if (pk2i) + { + /* we need to shift vector's content... */ + /* let's do it brute force... (FIXME) */ + assert(sa->key2index.num_elts >= 2); + for (i = sa->key2index.num_elts - 1; i > idx; i--) { - return (i << v->shift) + - ((const char*)elt - (const char*)v->buckets[i]) / v->elt_size; + pk2i = vector_at(&sa->key2index, i - 1); + *to = *pk2i; + to = pk2i; } } - assert(0); - return 0; + + to->key = key; + to->index = sa->elements.num_elts; + + return vector_add(&sa->elements, pool); } -void* vector_iter_up(const struct vector* v, void* elt) +unsigned sparse_array_length(const struct sparse_array* sa) { - unsigned pos; - - if (!elt) return vector_at(v, 0); - pos = vector_position(v, elt) + 1; - if (pos >= vector_length(v)) return NULL; - return vector_at(v, pos); -} - -void* vector_iter_down(const struct vector* v, void* elt) -{ - unsigned pos; - if (!elt) return vector_at(v, vector_length(v) - 1); - pos = vector_position(v, elt); - if (pos == 0) return NULL; - return vector_at(v, pos - 1); + return sa->elements.num_elts; } unsigned hash_table_hash(const char* name, unsigned num_buckets) @@ -242,10 +315,10 @@ unsigned hash_table_hash(const char* name, unsigned num_buckets) void hash_table_init(struct pool* pool, struct hash_table* ht, unsigned num_buckets) { - ht->buckets = pool_alloc(pool, num_buckets * sizeof(struct hash_table_elt*)); - assert(ht->buckets); + ht->num_elts = 0; ht->num_buckets = num_buckets; - memset(ht->buckets, 0, num_buckets * sizeof(struct hash_table_elt*)); + ht->pool = pool; + ht->buckets = NULL; } void hash_table_destroy(struct hash_table* ht) @@ -253,7 +326,7 @@ void hash_table_destroy(struct hash_table* ht) #if defined(USE_STATS) int i; unsigned len; - unsigned num = 0, min = 0xffffffff, max = 0, sq = 0; + unsigned min = 0xffffffff, max = 0, sq = 0; struct hash_table_elt* elt; double mean, variance; @@ -262,13 +335,12 @@ void hash_table_destroy(struct hash_table* ht) for (len = 0, elt = ht->buckets[i]; elt; elt = elt->next) len++; if (len < min) min = len; if (len > max) max = len; - num += len; sq += len * len; } - mean = (double)num / ht->num_buckets; + mean = (double)ht->num_elts / ht->num_buckets; variance = (double)sq / ht->num_buckets - mean * mean; FIXME("STATS: elts[num:%-4u size:%u mean:%f] buckets[min:%-4u variance:%+f max:%-4u]\n", - num, ht->num_buckets, mean, min, variance, max); + ht->num_elts, ht->num_buckets, mean, min, variance, max); #if 1 for (i = 0; i < ht->num_buckets; i++) { @@ -291,12 +363,20 @@ void hash_table_add(struct hash_table* ht, struct hash_table_elt* elt) unsigned hash = hash_table_hash(elt->name, ht->num_buckets); struct hash_table_elt** p; + if (!ht->buckets) + { + ht->buckets = pool_alloc(ht->pool, ht->num_buckets * sizeof(struct hash_table_elt*)); + assert(ht->buckets); + memset(ht->buckets, 0, ht->num_buckets * sizeof(struct hash_table_elt*)); + } + /* in some cases, we need to get back the symbols of same name in the order * in which they've been inserted. So insert new elements at the end of the list. */ for (p = &ht->buckets[hash]; *p; p = &((*p)->next)); *p = elt; elt->next = NULL; + ht->num_elts++; } void* hash_table_find(const struct hash_table* ht, const char* name) @@ -304,12 +384,14 @@ void* hash_table_find(const struct hash_table* ht, const char* name) unsigned hash = hash_table_hash(name, ht->num_buckets); struct hash_table_elt* elt; + if(!ht->buckets) return NULL; + for (elt = ht->buckets[hash]; elt; elt = elt->next) if (!strcmp(name, elt->name)) return elt; return NULL; } -void hash_table_iter_init(const struct hash_table* ht, +void hash_table_iter_init(const struct hash_table* ht, struct hash_table_iter* hti, const char* name) { hti->ht = ht; @@ -328,8 +410,10 @@ void hash_table_iter_init(const struct hash_table* ht, void* hash_table_iter_up(struct hash_table_iter* hti) { + if(!hti->ht->buckets) return NULL; + if (hti->element) hti->element = hti->element->next; - while (!hti->element && hti->index < hti->last) + while (!hti->element && hti->index < hti->last) hti->element = hti->ht->buckets[++hti->index]; return hti->element; } diff --git a/reactos/dll/win32/dbghelp/symbol.c b/reactos/dll/win32/dbghelp/symbol.c index 1cc89ea4394..d76811b114d 100644 --- a/reactos/dll/win32/dbghelp/symbol.c +++ b/reactos/dll/win32/dbghelp/symbol.c @@ -16,7 +16,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #define NONAMELESSUNION @@ -30,38 +30,25 @@ #include #include #include -#define HAVE_REGEX_H 1 #ifdef HAVE_REGEX_H -# include "regex.h" +# include #endif #include "wine/debug.h" #include "dbghelp_private.h" +#include "winnls.h" WINE_DEFAULT_DEBUG_CHANNEL(dbghelp); WINE_DECLARE_DEBUG_CHANNEL(dbghelp_symt); -struct line_info -{ - unsigned long is_first : 1, - is_last : 1, - is_source_file : 1, - line_number; - union - { - unsigned long pc_offset; /* if is_source_file isn't set */ - unsigned source_file; /* if is_source_file is set */ - } u; -}; - -__inline static int cmp_addr(ULONG64 a1, ULONG64 a2) +static inline int cmp_addr(ULONG64 a1, ULONG64 a2) { if (a1 > a2) return 1; if (a1 < a2) return -1; return 0; } -__inline static int cmp_sorttab_addr(const struct module* module, int idx, ULONG64 addr) +static inline int cmp_sorttab_addr(const struct module* module, int idx, ULONG64 addr) { ULONG64 ref; @@ -80,7 +67,7 @@ int symt_cmp_addr(const void* p1, const void* p2) return cmp_addr(a1, a2); } -static __inline void re_append(char** mask, unsigned* len, char ch) +static inline void re_append(char** mask, unsigned* len, char ch) { *mask = HeapReAlloc(GetProcessHeap(), 0, *mask, ++(*len)); (*mask)[*len - 2] = ch; @@ -95,11 +82,12 @@ static __inline void re_append(char** mask, unsigned* len, char ch) * + 1 or more of preceding char * escapes \ on #, ?, [, ], *, +. don't work on - */ -static void compile_regex(const char* str, int numchar, regex_t* re) +static void compile_regex(const char* str, int numchar, regex_t* re, BOOL _case) { char* mask = HeapAlloc(GetProcessHeap(), 0, 1); unsigned len = 1; BOOL in_escape = FALSE; + unsigned flags = REG_NOSUB; re_append(&mask, &len, '^'); @@ -132,26 +120,29 @@ static void compile_regex(const char* str, int numchar, regex_t* re) } re_append(&mask, &len, '$'); mask[len - 1] = '\0'; - if (regcomp(re, mask, REG_NOSUB)) FIXME("Couldn't compile %s\n", mask); + if (_case) flags |= REG_ICASE; + if (regcomp(re, mask, flags)) FIXME("Couldn't compile %s\n", mask); HeapFree(GetProcessHeap(), 0, mask); } -struct symt_compiland* symt_new_compiland(struct module* module, const char* name) +struct symt_compiland* symt_new_compiland(struct module* module, + unsigned long address, unsigned src_idx) { struct symt_compiland* sym; TRACE_(dbghelp_symt)("Adding compiland symbol %s:%s\n", - module->module.ModuleName, name); + debugstr_w(module->module.ModuleName), source_get(module, src_idx)); if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { sym->symt.tag = SymTagCompiland; - sym->source = source_new(module, name); + sym->address = address; + sym->source = src_idx; vector_init(&sym->vchildren, sizeof(struct symt*), 32); } return sym; } -struct symt_public* symt_new_public(struct module* module, +struct symt_public* symt_new_public(struct module* module, struct symt_compiland* compiland, const char* name, unsigned long address, unsigned size, @@ -161,9 +152,9 @@ struct symt_public* symt_new_public(struct module* module, struct symt** p; TRACE_(dbghelp_symt)("Adding public symbol %s:%s @%lx\n", - module->module.ModuleName, name, address); + debugstr_w(module->module.ModuleName), name, address); if ((dbghelp_options & SYMOPT_AUTO_PUBLICS) && - symt_find_nearest(module, address) != -1) + symt_find_nearest(module, address) != NULL) return NULL; if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { @@ -185,18 +176,18 @@ struct symt_public* symt_new_public(struct module* module, return sym; } -struct symt_data* symt_new_global_variable(struct module* module, - struct symt_compiland* compiland, +struct symt_data* symt_new_global_variable(struct module* module, + struct symt_compiland* compiland, const char* name, unsigned is_static, unsigned long addr, unsigned long size, struct symt* type) { struct symt_data* sym; struct symt** p; - DWORD tsz; + DWORD64 tsz; TRACE_(dbghelp_symt)("Adding global symbol %s:%s @%lx %p\n", - module->module.ModuleName, name, addr, type); + debugstr_w(module->module.ModuleName), name, addr, type); if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { sym->symt.tag = SymTagData; @@ -206,12 +197,13 @@ struct symt_data* symt_new_global_variable(struct module* module, sym->kind = is_static ? DataIsFileStatic : DataIsGlobal; sym->container = compiland ? &compiland->symt : NULL; sym->type = type; - sym->u.address = addr; + sym->u.var.offset = addr; if (type && size && symt_get_info(type, TI_GET_LENGTH, &tsz)) { if (tsz != size) - FIXME("Size mismatch for %s.%s between type (%lu) and src (%lu)\n", - module->module.ModuleName, name, tsz, size); + FIXME("Size mismatch for %s.%s between type (%s) and src (%lu)\n", + debugstr_w(module->module.ModuleName), name, + wine_dbgstr_longlong(tsz), size); } if (compiland) { @@ -222,8 +214,8 @@ struct symt_data* symt_new_global_variable(struct module* module, return sym; } -struct symt_function* symt_new_function(struct module* module, - struct symt_compiland* compiland, +struct symt_function* symt_new_function(struct module* module, + struct symt_compiland* compiland, const char* name, unsigned long addr, unsigned long size, struct symt* sig_type) @@ -232,7 +224,7 @@ struct symt_function* symt_new_function(struct module* module, struct symt** p; TRACE_(dbghelp_symt)("Adding global function %s:%s @%lx-%lx\n", - module->module.ModuleName, name, addr, addr + size - 1); + debugstr_w(module->module.ModuleName), name, addr, addr + size - 1); assert(!sig_type || sig_type->tag == SymTagFunctionType); if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) @@ -261,18 +253,19 @@ void symt_add_func_line(struct module* module, struct symt_function* func, { struct line_info* dli; BOOL last_matches = FALSE; + int i; if (func == NULL || !(dbghelp_options & SYMOPT_LOAD_LINES)) return; - TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n", - func, func->hash_elt.name, offset, + TRACE_(dbghelp_symt)("(%p)%s:%lx %s:%u\n", + func, func->hash_elt.name, offset, source_get(module, source_idx), line_num); assert(func->symt.tag == SymTagFunction); - dli = NULL; - while ((dli = vector_iter_down(&func->vlines, dli))) + for (i=vector_length(&func->vlines)-1; i>=0; i--) { + dli = vector_at(&func->vlines, i); if (dli->is_source_file) { last_matches = (source_idx == dli->u.source_file); @@ -296,40 +289,43 @@ void symt_add_func_line(struct module* module, struct symt_function* func, dli->u.pc_offset = func->address + offset; } -struct symt_data* symt_add_func_local(struct module* module, - struct symt_function* func, - int regno, int offset, - struct symt_block* block, +/****************************************************************** + * symt_add_func_local + * + * Adds a new local/parameter to a given function: + * In any cases, dt tells whether it's a local variable or a parameter + * If regno it's not 0: + * - then variable is stored in a register + * - otherwise, value is referenced by register + offset + * Otherwise, the variable is stored on the stack: + * - offset is then the offset from the frame register + */ +struct symt_data* symt_add_func_local(struct module* module, + struct symt_function* func, + enum DataKind dt, + const struct location* loc, + struct symt_block* block, struct symt* type, const char* name) { struct symt_data* locsym; struct symt** p; + TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n", + debugstr_w(module->module.ModuleName), func->hash_elt.name, + name, type); + assert(func); assert(func->symt.tag == SymTagFunction); + assert(dt == DataIsParam || dt == DataIsLocal); - TRACE_(dbghelp_symt)("Adding local symbol (%s:%s): %s %p\n", - module->module.ModuleName, func->hash_elt.name, - name, type); locsym = pool_alloc(&module->pool, sizeof(*locsym)); locsym->symt.tag = SymTagData; locsym->hash_elt.name = pool_strdup(&module->pool, name); locsym->hash_elt.next = NULL; - locsym->kind = (offset < 0) ? DataIsParam : DataIsLocal; + locsym->kind = dt; locsym->container = &block->symt; locsym->type = type; - if (regno) - { - locsym->u.s.reg_id = regno; - locsym->u.s.offset = 0; - locsym->u.s.length = 0; - } - else - { - locsym->u.s.reg_id = 0; - locsym->u.s.offset = offset * 8; - locsym->u.s.length = 0; - } + locsym->u.var = *loc; if (block) p = vector_add(&block->vchildren, &module->pool); else @@ -338,9 +334,10 @@ struct symt_data* symt_add_func_local(struct module* module, return locsym; } -struct symt_block* symt_open_func_block(struct module* module, + +struct symt_block* symt_open_func_block(struct module* module, struct symt_function* func, - struct symt_block* parent_block, + struct symt_block* parent_block, unsigned pc, unsigned len) { struct symt_block* block; @@ -365,21 +362,23 @@ struct symt_block* symt_open_func_block(struct module* module, return block; } -struct symt_block* symt_close_func_block(struct module* module, +struct symt_block* symt_close_func_block(struct module* module, struct symt_function* func, struct symt_block* block, unsigned pc) { + assert(func); assert(func->symt.tag == SymTagFunction); if (pc) block->size = func->address + pc - block->address; - return (block->container->tag == SymTagBlock) ? + return (block->container->tag == SymTagBlock) ? GET_ENTRY(block->container, struct symt_block, symt) : NULL; } -struct symt_function_point* symt_add_function_point(struct module* module, +struct symt_function_point* symt_add_function_point(struct module* module, struct symt_function* func, - enum SymTagEnum point, - unsigned offset, const char* name) + enum SymTagEnum point, + const struct location* loc, + const char* name) { struct symt_function_point* sym; struct symt** p; @@ -388,7 +387,7 @@ struct symt_function_point* symt_add_function_point(struct module* module, { sym->symt.tag = point; sym->parent = func; - sym->offset = offset; + sym->loc = *loc; sym->name = name ? pool_strdup(&module->pool, name) : NULL; p = vector_add(&func->vchildren, &module->pool); *p = &sym->symt; @@ -419,15 +418,15 @@ BOOL symt_normalize_function(struct module* module, struct symt_function* func) return TRUE; } -struct symt_thunk* symt_new_thunk(struct module* module, - struct symt_compiland* compiland, +struct symt_thunk* symt_new_thunk(struct module* module, + struct symt_compiland* compiland, const char* name, THUNK_ORDINAL ord, unsigned long addr, unsigned long size) { struct symt_thunk* sym; TRACE_(dbghelp_symt)("Adding global thunk %s:%s @%lx-%lx\n", - module->module.ModuleName, name, addr, addr + size - 1); + debugstr_w(module->module.ModuleName), name, addr, addr + size - 1); if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { @@ -449,17 +448,57 @@ struct symt_thunk* symt_new_thunk(struct module* module, return sym; } +struct symt_data* symt_new_constant(struct module* module, + struct symt_compiland* compiland, + const char* name, struct symt* type, + const VARIANT* v) +{ + struct symt_data* sym; + + TRACE_(dbghelp_symt)("Adding constant value %s:%s\n", + debugstr_w(module->module.ModuleName), name); + + if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) + { + sym->symt.tag = SymTagData; + sym->hash_elt.name = pool_strdup(&module->pool, name); + hash_table_add(&module->ht_symbols, &sym->hash_elt); + module->sortlist_valid = FALSE; + sym->kind = DataIsConstant; + sym->container = compiland ? &compiland->symt : NULL; + sym->type = type; + sym->u.value = *v; + if (compiland) + { + struct symt** p; + p = vector_add(&compiland->vchildren, &module->pool); + *p = &sym->symt; + } + } + return sym; +} + /* expect sym_info->MaxNameLen to be set before being called */ -static void symt_fill_sym_info(const struct module* module, +static void symt_fill_sym_info(const struct module_pair* pair, + const struct symt_function* func, const struct symt* sym, SYMBOL_INFO* sym_info) { const char* name; + DWORD64 size; - sym_info->TypeIndex = (DWORD)sym; - sym_info->info = 0; /* TBD */ - symt_get_info(sym, TI_GET_LENGTH, &sym_info->Size); - sym_info->ModBase = module->module.BaseOfImage; + if (!symt_get_info(sym, TI_GET_TYPE, &sym_info->TypeIndex)) + sym_info->TypeIndex = 0; + sym_info->info = (DWORD)sym; + sym_info->Reserved[0] = sym_info->Reserved[1] = 0; + if (!symt_get_info(sym, TI_GET_LENGTH, &size) && + (!sym_info->TypeIndex || + !symt_get_info((struct symt*)sym_info->TypeIndex, TI_GET_LENGTH, &size))) + size = 0; + sym_info->Size = (DWORD)size; + sym_info->ModBase = pair->requested->module.BaseOfImage; sym_info->Flags = 0; + sym_info->Value = 0; + switch (sym->tag) { case SymTagData: @@ -467,23 +506,37 @@ static void symt_fill_sym_info(const struct module* module, const struct symt_data* data = (const struct symt_data*)sym; switch (data->kind) { - case DataIsLocal: case DataIsParam: - if (data->u.s.reg_id) + sym_info->Flags |= SYMFLAG_PARAMETER; + /* fall through */ + case DataIsLocal: { - sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_REGISTER; - sym_info->Register = data->u.s.reg_id; - sym_info->Address = 0; - } - else - { - if (data->u.s.offset < 0) - sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_FRAMEREL; - else - sym_info->Flags |= SYMFLAG_PARAMETER | SYMFLAG_FRAMEREL; - /* FIXME: needed ? moreover, it's i386 dependent !!! */ - sym_info->Register = CV_REG_EBP; - sym_info->Address = data->u.s.offset; + struct location loc = data->u.var; + + if (loc.kind >= loc_user) + pair->effective->loc_compute(pair->pcs, pair->effective, func, &loc); + + switch (loc.kind) + { + case loc_error: + /* for now we report error cases as a negative register number */ + sym_info->Flags |= SYMFLAG_LOCAL; + /* fall through */ + case loc_register: + sym_info->Flags |= SYMFLAG_REGISTER; + sym_info->Register = loc.reg; + sym_info->Address = 0; + break; + case loc_regrel: + sym_info->Flags |= SYMFLAG_LOCAL | SYMFLAG_REGREL; + /* FIXME: it's i386 dependent !!! */ + sym_info->Register = loc.reg ? loc.reg : CV_REG_EBP; + sym_info->Address = loc.offset; + break; + default: + FIXME("Shouldn't happen (kind=%d), debug reader backend is broken\n", loc.kind); + assert(0); + } } break; case DataIsGlobal: @@ -501,8 +554,11 @@ static void symt_fill_sym_info(const struct module* module, case VT_UI4: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.ulVal; break; case VT_UI2: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.uiVal; break; case VT_UI1: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.bVal; break; + case VT_I1 | VT_BYREF: sym_info->Value = (ULONG)data->u.value.n1.n2.n3.byref; break; default: FIXME("Unsupported variant type (%u)\n", data->u.value.n1.n2.vt); + sym_info->Value = 0; + break; } break; default: @@ -533,41 +589,59 @@ static void symt_fill_sym_info(const struct module* module, if (sym_info->MaxNameLen) { if (sym->tag != SymTagPublicSymbol || !(dbghelp_options & SYMOPT_UNDNAME) || - (sym_info->NameLen = UnDecorateSymbolName(sym_info->Name, sym_info->Name, + (sym_info->NameLen = UnDecorateSymbolName(name, sym_info->Name, sym_info->MaxNameLen, UNDNAME_COMPLETE) == 0)) { sym_info->NameLen = min(strlen(name), sym_info->MaxNameLen - 1); - strncpy(sym_info->Name, name, sym_info->NameLen); + memcpy(sym_info->Name, name, sym_info->NameLen); sym_info->Name[sym_info->NameLen] = '\0'; } } - TRACE_(dbghelp_symt)("%p => %s %lu %s\n", + TRACE_(dbghelp_symt)("%p => %s %u %s\n", sym, sym_info->Name, sym_info->Size, wine_dbgstr_longlong(sym_info->Address)); } -static BOOL symt_enum_module(struct module* module, regex_t* regex, - PSYM_ENUMERATESYMBOLS_CALLBACK cb, PVOID user) +struct sym_enum +{ + PSYM_ENUMERATESYMBOLS_CALLBACK cb; + PVOID user; + SYMBOL_INFO* sym_info; + DWORD index; + DWORD tag; + DWORD64 addr; + char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; +}; + +static BOOL send_symbol(const struct sym_enum* se, const struct module_pair* pair, + const struct symt_function* func, const struct symt* sym) +{ + symt_fill_sym_info(pair, func, sym, se->sym_info); + if (se->index && se->sym_info->info != se->index) return FALSE; + if (se->tag && se->sym_info->Tag != se->tag) return FALSE; + if (se->addr && !(se->addr >= se->sym_info->Address && se->addr < se->sym_info->Address + se->sym_info->Size)) return FALSE; + return !se->cb(se->sym_info, se->sym_info->Size, se->user); +} + +static BOOL symt_enum_module(struct module_pair* pair, const regex_t* regex, + const struct sym_enum* se) { - char buffer[sizeof(SYMBOL_INFO) + 256]; - SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer; void* ptr; struct symt_ht* sym = NULL; struct hash_table_iter hti; - hash_table_iter_init(&module->ht_symbols, &hti, NULL); + hash_table_iter_init(&pair->effective->ht_symbols, &hti, NULL); while ((ptr = hash_table_iter_up(&hti))) { sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); if (sym->hash_elt.name && regexec(regex, sym->hash_elt.name, 0, NULL, 0) == 0) { - sym_info->SizeOfStruct = sizeof(SYMBOL_INFO); - sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO); - symt_fill_sym_info(module, &sym->symt, sym_info); - if (!cb(sym_info, sym_info->Size, user)) return TRUE; + se->sym_info->SizeOfStruct = sizeof(SYMBOL_INFO); + se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO); + if (send_symbol(se, pair, NULL, &sym->symt)) return TRUE; } - } + } return FALSE; } @@ -578,67 +652,68 @@ static BOOL symt_enum_module(struct module* module, regex_t* regex, */ static BOOL resort_symbols(struct module* module) { - int nsym = 0; void* ptr; struct symt_ht* sym; struct hash_table_iter hti; + ULONG64 addr; - hash_table_iter_init(&module->ht_symbols, &hti, NULL); - while ((ptr = hash_table_iter_up(&hti))) - nsym++; - - if (!(module->module.NumSyms = nsym)) return FALSE; - + if (!(module->module.NumSyms = module->ht_symbols.num_elts)) + return FALSE; + if (module->addr_sorttab) module->addr_sorttab = HeapReAlloc(GetProcessHeap(), 0, - module->addr_sorttab, - nsym * sizeof(struct symt_ht*)); + module->addr_sorttab, + module->module.NumSyms * sizeof(struct symt_ht*)); else module->addr_sorttab = HeapAlloc(GetProcessHeap(), 0, - nsym * sizeof(struct symt_ht*)); + module->module.NumSyms * sizeof(struct symt_ht*)); if (!module->addr_sorttab) return FALSE; - nsym = 0; + module->num_sorttab = 0; hash_table_iter_init(&module->ht_symbols, &hti, NULL); while ((ptr = hash_table_iter_up(&hti))) { sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); assert(sym); - module->addr_sorttab[nsym++] = sym; + /* Don't store in sorttab symbol without address, they are of + * no use here (e.g. constant values) + * As the number of those symbols is very couple (a couple per module) + * we don't bother for the unused spots at the end of addr_sorttab + */ + if (symt_get_info(&sym->symt, TI_GET_ADDRESS, &addr)) + module->addr_sorttab[module->num_sorttab++] = sym; } - - qsort(module->addr_sorttab, nsym, sizeof(struct symt_ht*), symt_cmp_addr); + qsort(module->addr_sorttab, module->num_sorttab, sizeof(struct symt_ht*), symt_cmp_addr); return module->sortlist_valid = TRUE; } /* assume addr is in module */ -int symt_find_nearest(struct module* module, DWORD addr) +struct symt_ht* symt_find_nearest(struct module* module, DWORD addr) { int mid, high, low; - ULONG64 ref_addr; - DWORD ref_size; + ULONG64 ref_addr, ref_size; if (!module->sortlist_valid || !module->addr_sorttab) { - if (!resort_symbols(module)) return -1; + if (!resort_symbols(module)) return NULL; } /* * Binary search to find closest symbol. */ low = 0; - high = module->module.NumSyms; + high = module->num_sorttab; symt_get_info(&module->addr_sorttab[0]->symt, TI_GET_ADDRESS, &ref_addr); - if (addr < ref_addr) return -1; + if (addr < ref_addr) return NULL; if (high) { symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_ADDRESS, &ref_addr); - if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size) + if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size) ref_size = 0x1000; /* arbitrary value */ - if (addr >= ref_addr + ref_size) return -1; + if (addr >= ref_addr + ref_size) return NULL; } - + while (high > low + 1) { mid = (high + low) / 2; @@ -647,7 +722,7 @@ int symt_find_nearest(struct module* module, DWORD addr) else high = mid; } - if (low != high && high != module->module.NumSyms && + if (low != high && high != module->num_sorttab && cmp_sorttab_addr(module, high, addr) <= 0) low = high; @@ -655,39 +730,38 @@ int symt_find_nearest(struct module* module, DWORD addr) * might also have the same address, but would get better information */ if (module->addr_sorttab[low]->symt.tag == SymTagPublicSymbol) - { + { symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr); if (low > 0 && module->addr_sorttab[low - 1]->symt.tag != SymTagPublicSymbol && !cmp_sorttab_addr(module, low - 1, ref_addr)) low--; - else if (low < module->module.NumSyms - 1 && + else if (low < module->num_sorttab - 1 && module->addr_sorttab[low + 1]->symt.tag != SymTagPublicSymbol && !cmp_sorttab_addr(module, low + 1, ref_addr)) low++; } /* finally check that we fit into the found symbol */ symt_get_info(&module->addr_sorttab[low]->symt, TI_GET_ADDRESS, &ref_addr); - if (addr < ref_addr) return -1; + if (addr < ref_addr) return NULL; if (!symt_get_info(&module->addr_sorttab[high - 1]->symt, TI_GET_LENGTH, &ref_size) || !ref_size) ref_size = 0x1000; /* arbitrary value */ - if (addr >= ref_addr + ref_size) return -1; + if (addr >= ref_addr + ref_size) return NULL; - return low; + return module->addr_sorttab[low]; } -static BOOL symt_enum_locals_helper(struct process* pcs, struct module* module, - regex_t* preg, PSYM_ENUMERATESYMBOLS_CALLBACK cb, - PVOID user, SYMBOL_INFO* sym_info, - struct vector* v) +static BOOL symt_enum_locals_helper(struct module_pair* pair, + regex_t* preg, const struct sym_enum* se, + struct symt_function* func, const struct vector* v) { - struct symt** plsym = NULL; struct symt* lsym = NULL; - DWORD pc = pcs->ctx_frame.InstructionOffset; + DWORD pc = pair->pcs->ctx_frame.InstructionOffset; + int i; - while ((plsym = vector_iter_up(v, plsym))) + for (i=0; itag) { case SymTagBlock: @@ -695,22 +769,20 @@ static BOOL symt_enum_locals_helper(struct process* pcs, struct module* module, struct symt_block* block = (struct symt_block*)lsym; if (pc < block->address || block->address + block->size <= pc) continue; - if (!symt_enum_locals_helper(pcs, module, preg, cb, user, - sym_info, &block->vchildren)) + if (!symt_enum_locals_helper(pair, preg, se, func, &block->vchildren)) return FALSE; } break; case SymTagData: if (regexec(preg, symt_get_name(lsym), 0, NULL, 0) == 0) { - symt_fill_sym_info(module, lsym, sym_info); - if (!cb(sym_info, sym_info->Size, user)) - return FALSE; + if (send_symbol(se, pair, func, lsym)) return FALSE; } break; case SymTagLabel: case SymTagFuncDebugStart: case SymTagFuncDebugEnd: + case SymTagCustom: break; default: FIXME("Unknown type: %u (%x)\n", lsym->tag, lsym->tag); @@ -720,40 +792,134 @@ static BOOL symt_enum_locals_helper(struct process* pcs, struct module* module, return TRUE; } -static BOOL symt_enum_locals(struct process* pcs, const char* mask, - PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, - PVOID UserContext) +static BOOL symt_enum_locals(struct process* pcs, const char* mask, + const struct sym_enum* se) { - struct module* module; + struct module_pair pair; struct symt_ht* sym; - char buffer[sizeof(SYMBOL_INFO) + 256]; - SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer; DWORD pc = pcs->ctx_frame.InstructionOffset; - int idx; - sym_info->SizeOfStruct = sizeof(*sym_info); - sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO); + se->sym_info->SizeOfStruct = sizeof(*se->sym_info); + se->sym_info->MaxNameLen = sizeof(se->buffer) - sizeof(SYMBOL_INFO); - module = module_find_by_addr(pcs, pc, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; - if ((idx = symt_find_nearest(module, pc)) == -1) return FALSE; + pair.pcs = pcs; + pair.requested = module_find_by_addr(pair.pcs, pc, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; + if ((sym = symt_find_nearest(pair.effective, pc)) == NULL) return FALSE; - sym = module->addr_sorttab[idx]; if (sym->symt.tag == SymTagFunction) { BOOL ret; regex_t preg; - compile_regex(mask ? mask : "*", -1, &preg); - ret = symt_enum_locals_helper(pcs, module, &preg, EnumSymbolsCallback, - UserContext, sym_info, + compile_regex(mask ? mask : "*", -1, &preg, + dbghelp_options & SYMOPT_CASE_INSENSITIVE); + ret = symt_enum_locals_helper(&pair, &preg, se, (struct symt_function*)sym, &((struct symt_function*)sym)->vchildren); regfree(&preg); return ret; - + } - symt_fill_sym_info(module, &sym->symt, sym_info); - return EnumSymbolsCallback(sym_info, sym_info->Size, UserContext); + return send_symbol(se, &pair, NULL, &sym->symt); +} + +/****************************************************************** + * copy_symbolW + * + * Helper for transforming an ANSI symbol info into an UNICODE one. + * Assume that MaxNameLen is the same for both version (A & W). + */ +void copy_symbolW(SYMBOL_INFOW* siw, const SYMBOL_INFO* si) +{ + siw->SizeOfStruct = si->SizeOfStruct; + siw->TypeIndex = si->TypeIndex; + siw->Reserved[0] = si->Reserved[0]; + siw->Reserved[1] = si->Reserved[1]; + siw->Index = si->info; /* FIXME: see dbghelp.h */ + siw->Size = si->Size; + siw->ModBase = si->ModBase; + siw->Flags = si->Flags; + siw->Value = si->Value; + siw->Address = si->Address; + siw->Register = si->Register; + siw->Scope = si->Scope; + siw->Tag = si->Tag; + siw->NameLen = si->NameLen; + siw->MaxNameLen = si->MaxNameLen; + MultiByteToWideChar(CP_ACP, 0, si->Name, -1, siw->Name, siw->MaxNameLen); +} + +/****************************************************************** + * sym_enum + * + * Core routine for most of the enumeration of symbols + */ +static BOOL sym_enum(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, + const struct sym_enum* se) +{ + struct module_pair pair; + const char* bang; + regex_t mod_regex, sym_regex; + + pair.pcs = process_find_by_handle(hProcess); + if (BaseOfDll == 0) + { + /* do local variables ? */ + if (!Mask || !(bang = strchr(Mask, '!'))) + return symt_enum_locals(pair.pcs, Mask, se); + + if (bang == Mask) return FALSE; + + compile_regex(Mask, bang - Mask, &mod_regex, TRUE); + compile_regex(bang + 1, -1, &sym_regex, + dbghelp_options & SYMOPT_CASE_INSENSITIVE); + + for (pair.requested = pair.pcs->lmodules; pair.requested; pair.requested = pair.requested->next) + { + if (pair.requested->type == DMT_PE && module_get_debug(&pair)) + { + if (regexec(&mod_regex, pair.requested->module_name, 0, NULL, 0) == 0 && + symt_enum_module(&pair, &sym_regex, se)) + break; + } + } + /* not found in PE modules, retry on the ELF ones + */ + if (!pair.requested && (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES)) + { + for (pair.requested = pair.pcs->lmodules; pair.requested; pair.requested = pair.requested->next) + { + if (pair.requested->type == DMT_ELF && + !module_get_containee(pair.pcs, pair.requested) && + module_get_debug(&pair)) + { + if (regexec(&mod_regex, pair.requested->module_name, 0, NULL, 0) == 0 && + symt_enum_module(&pair, &sym_regex, se)) + break; + } + } + } + regfree(&mod_regex); + regfree(&sym_regex); + return TRUE; + } + pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN); + if (!module_get_debug(&pair)) + return FALSE; + + /* we always ignore module name from Mask when BaseOfDll is defined */ + if (Mask && (bang = strchr(Mask, '!'))) + { + if (bang == Mask) return FALSE; + Mask = bang + 1; + } + + compile_regex(Mask ? Mask : "*", -1, &sym_regex, + dbghelp_options & SYMOPT_CASE_INSENSITIVE); + symt_enum_module(&pair, &sym_regex, se); + regfree(&sym_regex); + + return TRUE; } /****************************************************************** @@ -771,75 +937,67 @@ BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; - struct module* dbg_module; - const char* bang; - regex_t mod_regex, sym_regex; + struct sym_enum se; - TRACE("(%p %s %s %p %p)\n", + TRACE("(%p %s %s %p %p)\n", hProcess, wine_dbgstr_longlong(BaseOfDll), debugstr_a(Mask), EnumSymbolsCallback, UserContext); - if (!pcs) return FALSE; + se.cb = EnumSymbolsCallback; + se.user = UserContext; + se.index = 0; + se.tag = 0; + se.addr = 0; + se.sym_info = (PSYMBOL_INFO)se.buffer; - if (BaseOfDll == 0) + return sym_enum(hProcess, BaseOfDll, Mask, &se); +} + +struct sym_enumW +{ + PSYM_ENUMERATESYMBOLS_CALLBACKW cb; + void* ctx; + PSYMBOL_INFOW sym_info; + char buffer[sizeof(SYMBOL_INFOW) + MAX_SYM_NAME]; + +}; + +static BOOL CALLBACK sym_enumW(PSYMBOL_INFO si, ULONG size, PVOID ctx) +{ + struct sym_enumW* sew = ctx; + + copy_symbolW(sew->sym_info, si); + + return (sew->cb)(sew->sym_info, size, sew->ctx); +} + +/****************************************************************** + * SymEnumSymbolsW (DBGHELP.@) + * + */ +BOOL WINAPI SymEnumSymbolsW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR Mask, + PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, + PVOID UserContext) +{ + struct sym_enumW sew; + BOOL ret = FALSE; + char* maskA = NULL; + + sew.ctx = UserContext; + sew.cb = EnumSymbolsCallback; + sew.sym_info = (PSYMBOL_INFOW)sew.buffer; + + if (Mask) { - /* do local variables ? */ - if (!Mask || !(bang = strchr(Mask, '!'))) - return symt_enum_locals(pcs, Mask, EnumSymbolsCallback, UserContext); - - if (bang == Mask) return FALSE; - - compile_regex(Mask, bang - Mask, &mod_regex); - compile_regex(bang + 1, -1, &sym_regex); - - for (module = pcs->lmodules; module; module = module->next) - { - if (module->type == DMT_PE && (dbg_module = module_get_debug(pcs, module))) - { - if (regexec(&mod_regex, module->module.ModuleName, 0, NULL, 0) == 0 && - symt_enum_module(dbg_module, &sym_regex, - EnumSymbolsCallback, UserContext)) - break; - } - } - /* not found in PE modules, retry on the ELF ones - */ - if (!module && (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES)) - { - for (module = pcs->lmodules; module; module = module->next) - { - if (module->type == DMT_ELF && - !module_get_containee(pcs, module) && - (dbg_module = module_get_debug(pcs, module))) - { - if (regexec(&mod_regex, module->module.ModuleName, 0, NULL, 0) == 0 && - symt_enum_module(dbg_module, &sym_regex, EnumSymbolsCallback, UserContext)) - break; - } - } - } - regfree(&mod_regex); - regfree(&sym_regex); - return TRUE; + unsigned len = WideCharToMultiByte(CP_ACP, 0, Mask, -1, NULL, 0, NULL, NULL); + maskA = HeapAlloc(GetProcessHeap(), 0, len); + if (!maskA) return FALSE; + WideCharToMultiByte(CP_ACP, 0, Mask, -1, maskA, len, NULL, NULL); } - module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) - return FALSE; + ret = SymEnumSymbols(hProcess, BaseOfDll, maskA, sym_enumW, &sew); + HeapFree(GetProcessHeap(), 0, maskA); - /* we always ignore module name from Mask when BaseOfDll is defined */ - if (Mask && (bang = strchr(Mask, '!'))) - { - if (bang == Mask) return FALSE; - Mask = bang + 1; - } - - compile_regex(Mask ? Mask : "*", -1, &sym_regex); - symt_enum_module(module, &sym_regex, EnumSymbolsCallback, UserContext); - regfree(&sym_regex); - - return TRUE; + return ret; } struct sym_enumerate @@ -858,14 +1016,14 @@ static BOOL CALLBACK sym_enumerate_cb(PSYMBOL_INFO syminfo, ULONG size, void* ct * SymEnumerateSymbols (DBGHELP.@) */ BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll, - PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, + PSYM_ENUMSYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext) { struct sym_enumerate se; se.ctx = UserContext; se.cb = EnumSymbolsCallback; - + return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb, &se); } @@ -873,26 +1031,48 @@ BOOL WINAPI SymEnumerateSymbols(HANDLE hProcess, DWORD BaseOfDll, * SymFromAddr (DBGHELP.@) * */ -BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address, +BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address, DWORD64* Displacement, PSYMBOL_INFO Symbol) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; + struct module_pair pair; struct symt_ht* sym; - int idx; - if (!pcs) return FALSE; - module = module_find_by_addr(pcs, Address, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; - if ((idx = symt_find_nearest(module, Address)) == -1) return FALSE; + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, Address, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; + if ((sym = symt_find_nearest(pair.effective, Address)) == NULL) return FALSE; - sym = module->addr_sorttab[idx]; - - symt_fill_sym_info(module, &sym->symt, Symbol); - if (Displacement) *Displacement = Address - Symbol->Address; + symt_fill_sym_info(&pair, NULL, &sym->symt, Symbol); + *Displacement = Address - Symbol->Address; return TRUE; } +/****************************************************************** + * SymFromAddrW (DBGHELP.@) + * + */ +BOOL WINAPI SymFromAddrW(HANDLE hProcess, DWORD64 Address, + DWORD64* Displacement, PSYMBOL_INFOW Symbol) +{ + PSYMBOL_INFO si; + unsigned len; + BOOL ret; + + len = sizeof(*si) + Symbol->MaxNameLen * sizeof(WCHAR); + si = HeapAlloc(GetProcessHeap(), 0, len); + if (!si) return FALSE; + + si->SizeOfStruct = sizeof(*si); + si->MaxNameLen = Symbol->MaxNameLen; + if ((ret = SymFromAddr(hProcess, Address, Displacement, si))) + { + copy_symbolW(Symbol, si); + } + HeapFree(GetProcessHeap(), 0, si); + return ret; +} + /****************************************************************** * SymGetSymFromAddr (DBGHELP.@) * @@ -900,14 +1080,14 @@ BOOL WINAPI SymFromAddr(HANDLE hProcess, DWORD64 Address, BOOL WINAPI SymGetSymFromAddr(HANDLE hProcess, DWORD Address, PDWORD Displacement, PIMAGEHLP_SYMBOL Symbol) { - char buffer[sizeof(SYMBOL_INFO) + 256]; + char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; SYMBOL_INFO*si = (SYMBOL_INFO*)buffer; size_t len; DWORD64 Displacement64; if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE; si->SizeOfStruct = sizeof(*si); - si->MaxNameLen = 256; + si->MaxNameLen = MAX_SYM_NAME; if (!SymFromAddr(hProcess, Address, &Displacement64, si)) return FALSE; @@ -917,22 +1097,72 @@ BOOL WINAPI SymGetSymFromAddr(HANDLE hProcess, DWORD Address, Symbol->Size = si->Size; Symbol->Flags = si->Flags; len = min(Symbol->MaxNameLength, si->MaxNameLen); - strncpy(Symbol->Name, si->Name, len); - Symbol->Name[len - 1] = '\0'; + lstrcpynA(Symbol->Name, si->Name, len); return TRUE; } /****************************************************************** - * SymFromName (DBGHELP.@) + * SymGetSymFromAddr64 (DBGHELP.@) * */ -BOOL WINAPI SymFromName(HANDLE hProcess, LPSTR Name, PSYMBOL_INFO Symbol) +BOOL WINAPI SymGetSymFromAddr64(HANDLE hProcess, DWORD64 Address, + PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol) +{ + char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; + SYMBOL_INFO*si = (SYMBOL_INFO*)buffer; + size_t len; + DWORD64 Displacement64; + + if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE; + si->SizeOfStruct = sizeof(*si); + si->MaxNameLen = MAX_SYM_NAME; + if (!SymFromAddr(hProcess, Address, &Displacement64, si)) + return FALSE; + + if (Displacement) + *Displacement = Displacement64; + Symbol->Address = si->Address; + Symbol->Size = si->Size; + Symbol->Flags = si->Flags; + len = min(Symbol->MaxNameLength, si->MaxNameLen); + lstrcpynA(Symbol->Name, si->Name, len); + return TRUE; +} + +static BOOL find_name(struct process* pcs, struct module* module, const char* name, + SYMBOL_INFO* symbol) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; struct hash_table_iter hti; void* ptr; struct symt_ht* sym = NULL; + struct module_pair pair; + + pair.pcs = pcs; + if (!(pair.requested = module)) return FALSE; + if (!module_get_debug(&pair)) return FALSE; + + hash_table_iter_init(&pair.effective->ht_symbols, &hti, name); + while ((ptr = hash_table_iter_up(&hti))) + { + sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); + + if (!strcmp(sym->hash_elt.name, name)) + { + symt_fill_sym_info(&pair, NULL, &sym->symt, symbol); + return TRUE; + } + } + return FALSE; + +} +/****************************************************************** + * SymFromName (DBGHELP.@) + * + */ +BOOL WINAPI SymFromName(HANDLE hProcess, PCSTR Name, PSYMBOL_INFO Symbol) +{ + struct process* pcs = process_find_by_handle(hProcess); + struct module* module; const char* name; TRACE("(%p, %s, %p)\n", hProcess, Name, Symbol); @@ -945,31 +1175,23 @@ BOOL WINAPI SymFromName(HANDLE hProcess, LPSTR Name, PSYMBOL_INFO Symbol) assert(name - Name < sizeof(tmp)); memcpy(tmp, Name, name - Name); tmp[name - Name] = '\0'; - module = module_find_by_name(pcs, tmp, DMT_UNKNOWN); - if (!module) return FALSE; - Name = (char*)(name + 1); + module = module_find_by_nameA(pcs, tmp); + return find_name(pcs, module, name + 1, Symbol); } - else module = pcs->lmodules; - - /* FIXME: Name could be made out of a regular expression */ - for (; module; module = (name) ? NULL : module->next) + for (module = pcs->lmodules; module; module = module->next) { - if (module->module.SymType == SymNone) continue; - if (module->module.SymType == SymDeferred) + if (module->type == DMT_PE && find_name(pcs, module, Name, Symbol)) + return TRUE; + } + /* not found in PE modules, retry on the ELF ones + */ + if (dbghelp_options & SYMOPT_WINE_WITH_ELF_MODULES) + { + for (module = pcs->lmodules; module; module = module->next) { - struct module* xmodule = module_get_debug(pcs, module); - if (!xmodule || xmodule != module) continue; - } - hash_table_iter_init(&module->ht_symbols, &hti, Name); - while ((ptr = hash_table_iter_up(&hti))) - { - sym = GET_ENTRY(ptr, struct symt_ht, hash_elt); - - if (!strcmp(sym->hash_elt.name, Name)) - { - symt_fill_sym_info(module, &sym->symt, Symbol); + if (module->type == DMT_ELF && !module_get_containee(pcs, module) && + find_name(pcs, module, Name, Symbol)) return TRUE; - } } } return FALSE; @@ -978,23 +1200,22 @@ BOOL WINAPI SymFromName(HANDLE hProcess, LPSTR Name, PSYMBOL_INFO Symbol) /*********************************************************************** * SymGetSymFromName (DBGHELP.@) */ -BOOL WINAPI SymGetSymFromName(HANDLE hProcess, LPSTR Name, PIMAGEHLP_SYMBOL Symbol) +BOOL WINAPI SymGetSymFromName(HANDLE hProcess, PCSTR Name, PIMAGEHLP_SYMBOL Symbol) { - char buffer[sizeof(SYMBOL_INFO) + 256]; + char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME]; SYMBOL_INFO*si = (SYMBOL_INFO*)buffer; size_t len; if (Symbol->SizeOfStruct < sizeof(*Symbol)) return FALSE; si->SizeOfStruct = sizeof(*si); - si->MaxNameLen = 256; + si->MaxNameLen = MAX_SYM_NAME; if (!SymFromName(hProcess, Name, si)) return FALSE; Symbol->Address = si->Address; Symbol->Size = si->Size; Symbol->Flags = si->Flags; len = min(Symbol->MaxNameLength, si->MaxNameLen); - strncpy(Symbol->Name, si->Name, len); - Symbol->Name[len - 1] = '\0'; + lstrcpynA(Symbol->Name, si->Name, len); return TRUE; } @@ -1003,16 +1224,18 @@ BOOL WINAPI SymGetSymFromName(HANDLE hProcess, LPSTR Name, PIMAGEHLP_SYMBOL Symb * * fills information about a file */ -BOOL symt_fill_func_line_info(struct module* module, struct symt_function* func, +BOOL symt_fill_func_line_info(const struct module* module, const struct symt_function* func, DWORD addr, IMAGEHLP_LINE* line) { struct line_info* dli = NULL; BOOL found = FALSE; + int i; assert(func->symt.tag == SymTagFunction); - while ((dli = vector_iter_down(&func->vlines, dli))) + for (i=vector_length(&func->vlines)-1; i>=0; i--) { + dli = vector_at(&func->vlines, i); if (!dli->is_source_file) { if (found || dli->u.pc_offset > addr) continue; @@ -1062,27 +1285,106 @@ BOOL WINAPI SymGetSymPrev(HANDLE hProcess, PIMAGEHLP_SYMBOL Symbol) * SymGetLineFromAddr (DBGHELP.@) * */ -BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr, +BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr, PDWORD pdwDisplacement, PIMAGEHLP_LINE Line) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; - int idx; + struct module_pair pair; + struct symt_ht* symt; - TRACE("%p %08lx %p %p\n", hProcess, dwAddr, pdwDisplacement, Line); + TRACE("%p %08x %p %p\n", hProcess, dwAddr, pdwDisplacement, Line); if (Line->SizeOfStruct < sizeof(*Line)) return FALSE; - if (!pcs) return FALSE; - module = module_find_by_addr(pcs, dwAddr, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; - if ((idx = symt_find_nearest(module, dwAddr)) == -1) return FALSE; + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, dwAddr, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; + if ((symt = symt_find_nearest(pair.effective, dwAddr)) == NULL) return FALSE; - if (module->addr_sorttab[idx]->symt.tag != SymTagFunction) return FALSE; - if (!symt_fill_func_line_info(module, - (struct symt_function*)module->addr_sorttab[idx], + if (symt->symt.tag != SymTagFunction) return FALSE; + if (!symt_fill_func_line_info(pair.effective, (struct symt_function*)symt, dwAddr, Line)) return FALSE; - if (pdwDisplacement) *pdwDisplacement = dwAddr - Line->Address; + *pdwDisplacement = dwAddr - Line->Address; + return TRUE; +} + +/****************************************************************** + * copy_line_64_from_32 (internal) + * + */ +static void copy_line_64_from_32(IMAGEHLP_LINE64* l64, const IMAGEHLP_LINE* l32) + +{ + l64->Key = l32->Key; + l64->LineNumber = l32->LineNumber; + l64->FileName = l32->FileName; + l64->Address = l32->Address; +} + +/****************************************************************** + * copy_line_W64_from_32 (internal) + * + */ +static void copy_line_W64_from_32(struct process* pcs, IMAGEHLP_LINEW64* l64, const IMAGEHLP_LINE* l32) +{ + unsigned len; + + l64->Key = l32->Key; + l64->LineNumber = l32->LineNumber; + len = MultiByteToWideChar(CP_ACP, 0, l32->FileName, -1, NULL, 0); + if ((l64->FileName = fetch_buffer(pcs, len * sizeof(WCHAR)))) + MultiByteToWideChar(CP_ACP, 0, l32->FileName, -1, l64->FileName, len); + l64->Address = l32->Address; +} + +/****************************************************************** + * copy_line_32_from_64 (internal) + * + */ +static void copy_line_32_from_64(IMAGEHLP_LINE* l32, const IMAGEHLP_LINE64* l64) + +{ + l32->Key = l64->Key; + l32->LineNumber = l64->LineNumber; + l32->FileName = l64->FileName; + l32->Address = l64->Address; +} + +/****************************************************************** + * SymGetLineFromAddr64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr, + PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line) +{ + IMAGEHLP_LINE line32; + + if (Line->SizeOfStruct < sizeof(*Line)) return FALSE; + if (!validate_addr64(dwAddr)) return FALSE; + line32.SizeOfStruct = sizeof(line32); + if (!SymGetLineFromAddr(hProcess, (DWORD)dwAddr, pdwDisplacement, &line32)) + return FALSE; + copy_line_64_from_32(Line, &line32); + return TRUE; +} + +/****************************************************************** + * SymGetLineFromAddrW64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetLineFromAddrW64(HANDLE hProcess, DWORD64 dwAddr, + PDWORD pdwDisplacement, PIMAGEHLP_LINEW64 Line) +{ + struct process* pcs = process_find_by_handle(hProcess); + IMAGEHLP_LINE line32; + + if (!pcs) return FALSE; + if (Line->SizeOfStruct < sizeof(*Line)) return FALSE; + if (!validate_addr64(dwAddr)) return FALSE; + line32.SizeOfStruct = sizeof(line32); + if (!SymGetLineFromAddr(hProcess, (DWORD)dwAddr, pdwDisplacement, &line32)) + return FALSE; + copy_line_W64_from_32(pcs, Line, &line32); return TRUE; } @@ -1092,8 +1394,7 @@ BOOL WINAPI SymGetLineFromAddr(HANDLE hProcess, DWORD dwAddr, */ BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; + struct module_pair pair; struct line_info* li; BOOL in_search = FALSE; @@ -1101,15 +1402,16 @@ BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line) if (Line->SizeOfStruct < sizeof(*Line)) return FALSE; - if (!pcs) return FALSE; - module = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, Line->Address, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; if (Line->Key == 0) return FALSE; li = (struct line_info*)Line->Key; /* things are a bit complicated because when we encounter a DLIT_SOURCEFILE * element we have to go back until we find the prev one to get the real - * source file name for the DLIT_OFFSET element just before + * source file name for the DLIT_OFFSET element just before * the first DLIT_SOURCEFILE */ while (!li->is_first) @@ -1126,7 +1428,7 @@ BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line) { if (in_search) { - Line->FileName = (char*)source_get(module, li->u.source_file); + Line->FileName = (char*)source_get(pair.effective, li->u.source_file); return TRUE; } in_search = TRUE; @@ -1136,7 +1438,22 @@ BOOL WINAPI SymGetLinePrev(HANDLE hProcess, PIMAGEHLP_LINE Line) return FALSE; } -BOOL symt_get_func_line_next(struct module* module, PIMAGEHLP_LINE line) +/****************************************************************** + * SymGetLinePrev64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetLinePrev64(HANDLE hProcess, PIMAGEHLP_LINE64 Line) +{ + IMAGEHLP_LINE line32; + + line32.SizeOfStruct = sizeof(line32); + copy_line_32_from_64(&line32, Line); + if (!SymGetLinePrev(hProcess, &line32)) return FALSE; + copy_line_64_from_32(Line, &line32); + return TRUE; +} + +BOOL symt_get_func_line_next(const struct module* module, PIMAGEHLP_LINE line) { struct line_info* li; @@ -1163,37 +1480,60 @@ BOOL symt_get_func_line_next(struct module* module, PIMAGEHLP_LINE line) */ BOOL WINAPI SymGetLineNext(HANDLE hProcess, PIMAGEHLP_LINE Line) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; + struct module_pair pair; TRACE("(%p %p)\n", hProcess, Line); if (Line->SizeOfStruct < sizeof(*Line)) return FALSE; - if (!pcs) return FALSE; - module = module_find_by_addr(pcs, Line->Address, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, Line->Address, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; - if (symt_get_func_line_next(module, Line)) return TRUE; + if (symt_get_func_line_next(pair.effective, Line)) return TRUE; SetLastError(ERROR_NO_MORE_ITEMS); /* FIXME */ return FALSE; } +/****************************************************************** + * SymGetLineNext64 (DBGHELP.@) + * + */ +BOOL WINAPI SymGetLineNext64(HANDLE hProcess, PIMAGEHLP_LINE64 Line) +{ + IMAGEHLP_LINE line32; + + line32.SizeOfStruct = sizeof(line32); + copy_line_32_from_64(&line32, Line); + if (!SymGetLineNext(hProcess, &line32)) return FALSE; + copy_line_64_from_32(Line, &line32); + return TRUE; +} + /*********************************************************************** * SymFunctionTableAccess (DBGHELP.@) */ PVOID WINAPI SymFunctionTableAccess(HANDLE hProcess, DWORD AddrBase) { - FIXME("(%p, 0x%08lx): stub\n", hProcess, AddrBase); - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; + WARN("(%p, 0x%08x): stub\n", hProcess, AddrBase); + return NULL; +} + +/*********************************************************************** + * SymFunctionTableAccess64 (DBGHELP.@) + */ +PVOID WINAPI SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) +{ + WARN("(%p, %s): stub\n", hProcess, wine_dbgstr_longlong(AddrBase)); + return NULL; } /*********************************************************************** * SymUnDName (DBGHELP.@) */ -BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL sym, LPSTR UnDecName, DWORD UnDecNameLength) +BOOL WINAPI SymUnDName(PIMAGEHLP_SYMBOL sym, PSTR UnDecName, DWORD UnDecNameLength) { - TRACE("(%p %s %lu): stub\n", sym, UnDecName, UnDecNameLength); + TRACE("(%p %s %u)\n", sym, UnDecName, UnDecNameLength); return UnDecorateSymbolName(sym->Name, UnDecName, UnDecNameLength, UNDNAME_COMPLETE) != 0; } @@ -1204,14 +1544,14 @@ static void und_free (void* ptr) { HeapFree(GetProcessHeap(), 0, ptr); } /*********************************************************************** * UnDecorateSymbolName (DBGHELP.@) */ -DWORD WINAPI UnDecorateSymbolName(LPCSTR DecoratedName, LPSTR UnDecoratedName, +DWORD WINAPI UnDecorateSymbolName(PCSTR DecoratedName, PSTR UnDecoratedName, DWORD UndecoratedLength, DWORD Flags) { /* undocumented from msvcrt */ static char* (*p_undname)(char*, const char*, int, void* (*)(size_t), void (*)(void*), unsigned short); - static WCHAR szMsvcrt[] = {'m','s','v','c','r','t','.','d','l','l',0}; + static const WCHAR szMsvcrt[] = {'m','s','v','c','r','t','.','d','l','l',0}; - TRACE("(%s, %p, %ld, 0x%08lx): stub\n", + TRACE("(%s, %p, %d, 0x%08x)\n", debugstr_a(DecoratedName), UnDecoratedName, UndecoratedLength, Flags); if (!p_undname) @@ -1222,8 +1562,92 @@ DWORD WINAPI UnDecorateSymbolName(LPCSTR DecoratedName, LPSTR UnDecoratedName, } if (!UnDecoratedName) return 0; - if (!p_undname(UnDecoratedName, DecoratedName, UndecoratedLength, + if (!p_undname(UnDecoratedName, DecoratedName, UndecoratedLength, und_alloc, und_free, Flags)) return 0; return strlen(UnDecoratedName); } + +/****************************************************************** + * SymMatchString (DBGHELP.@) + * + */ +BOOL WINAPI SymMatchString(PCSTR string, PCSTR re, BOOL _case) +{ + regex_t preg; + BOOL ret; + + TRACE("%s %s %c\n", string, re, _case ? 'Y' : 'N'); + + compile_regex(re, -1, &preg, _case); + ret = regexec(&preg, string, 0, NULL, 0) == 0; + regfree(&preg); + return ret; +} + +/****************************************************************** + * SymSearch (DBGHELP.@) + */ +BOOL WINAPI SymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, + DWORD SymTag, PCSTR Mask, DWORD64 Address, + PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, + PVOID UserContext, DWORD Options) +{ + struct sym_enum se; + + TRACE("(%p %s %u %u %s %s %p %p %x)\n", + hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, Mask, + wine_dbgstr_longlong(Address), EnumSymbolsCallback, + UserContext, Options); + + if (Options != SYMSEARCH_GLOBALSONLY) + { + FIXME("Unsupported searching with options (%x)\n", Options); + SetLastError(ERROR_INVALID_PARAMETER); + return FALSE; + } + + se.cb = EnumSymbolsCallback; + se.user = UserContext; + se.index = Index; + se.tag = SymTag; + se.addr = Address; + se.sym_info = (PSYMBOL_INFO)se.buffer; + + return sym_enum(hProcess, BaseOfDll, Mask, &se); +} + +/****************************************************************** + * SymSearchW (DBGHELP.@) + */ +BOOL WINAPI SymSearchW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index, + DWORD SymTag, PCWSTR Mask, DWORD64 Address, + PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, + PVOID UserContext, DWORD Options) +{ + struct sym_enumW sew; + BOOL ret = FALSE; + char* maskA = NULL; + + TRACE("(%p %s %u %u %s %s %p %p %x)\n", + hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, debugstr_w(Mask), + wine_dbgstr_longlong(Address), EnumSymbolsCallback, + UserContext, Options); + + sew.ctx = UserContext; + sew.cb = EnumSymbolsCallback; + sew.sym_info = (PSYMBOL_INFOW)sew.buffer; + + if (Mask) + { + unsigned len = WideCharToMultiByte(CP_ACP, 0, Mask, -1, NULL, 0, NULL, NULL); + maskA = HeapAlloc(GetProcessHeap(), 0, len); + if (!maskA) return FALSE; + WideCharToMultiByte(CP_ACP, 0, Mask, -1, maskA, len, NULL, NULL); + } + ret = SymSearch(hProcess, BaseOfDll, Index, SymTag, maskA, Address, + sym_enumW, &sew, Options); + HeapFree(GetProcessHeap(), 0, maskA); + + return ret; +} diff --git a/reactos/dll/win32/dbghelp/type.c b/reactos/dll/win32/dbghelp/type.c index 8d36157cea3..a8c6778ed90 100644 --- a/reactos/dll/win32/dbghelp/type.c +++ b/reactos/dll/win32/dbghelp/type.c @@ -16,7 +16,7 @@ * * 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 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * * Note: This really doesn't do much at the moment, but it forms the framework * upon which full support for datatype handling will eventually be built. @@ -28,7 +28,6 @@ #include "windef.h" #include "winbase.h" -#include "winreg.h" #include "winnls.h" #include "wine/debug.h" #include "dbghelp_private.h" @@ -100,8 +99,8 @@ const char* symt_get_name(const struct symt* sym) } } -static struct symt* symt_find_type_by_name(struct module* module, - enum SymTagEnum sym_tag, +static struct symt* symt_find_type_by_name(const struct module* module, + enum SymTagEnum sym_tag, const char* typename) { void* ptr; @@ -132,7 +131,7 @@ static void symt_add_type(struct module* module, struct symt* symt) *p = symt; } -struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt, +struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt, const char* typename, unsigned size) { struct symt_basic* sym; @@ -159,12 +158,13 @@ struct symt_basic* symt_new_basic(struct module* module, enum BasicType bt, return sym; } -struct symt_udt* symt_new_udt(struct module* module, const char* typename, +struct symt_udt* symt_new_udt(struct module* module, const char* typename, unsigned size, enum UdtKind kind) { struct symt_udt* sym; - TRACE_(dbghelp_symt)("Adding udt %s:%s\n", module->module.ModuleName, typename); + TRACE_(dbghelp_symt)("Adding udt %s:%s\n", + debugstr_w(module->module.ModuleName), typename); if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { sym->symt.tag = SymTagUDT; @@ -187,7 +187,7 @@ BOOL symt_set_udt_size(struct module* module, struct symt_udt* udt, unsigned siz if (vector_length(&udt->vchildren) != 0) { if (udt->size != size) - FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n", + FIXME_(dbghelp_symt)("Changing size for %s from %u to %u\n", udt->hash_elt.name, udt->size, size); return TRUE; } @@ -213,28 +213,30 @@ BOOL symt_add_udt_element(struct module* module, struct symt_udt* udt_type, assert(udt_type->symt.tag == SymTagUDT); TRACE_(dbghelp_symt)("Adding %s to UDT %s\n", name, udt_type->hash_elt.name); - p = NULL; - while ((p = vector_iter_up(&udt_type->vchildren, p))) + if (name) { - m = (struct symt_data*)*p; - assert(m); - assert(m->symt.tag == SymTagData); - if (m->hash_elt.name[0] == name[0] && strcmp(m->hash_elt.name, name) == 0) - return TRUE; + int i; + for (i=0; ivchildren); i++) + { + m = *(struct symt_data**)vector_at(&udt_type->vchildren, i); + assert(m); + assert(m->symt.tag == SymTagData); + if (strcmp(m->hash_elt.name, name) == 0) + return TRUE; + } } if ((m = pool_alloc(&module->pool, sizeof(*m))) == NULL) return FALSE; memset(m, 0, sizeof(*m)); m->symt.tag = SymTagData; - m->hash_elt.name = pool_strdup(&module->pool, name); + m->hash_elt.name = name ? pool_strdup(&module->pool, name) : ""; m->hash_elt.next = NULL; - m->kind = DataIsMember; - m->container = &udt_type->symt; - m->type = elt_type; - m->u.s.offset = offset; - m->u.s.length = ((offset & 7) || (size & 7)) ? size : 0; - m->u.s.reg_id = 0; + m->kind = DataIsMember; + m->container = &udt_type->symt; + m->type = elt_type; + m->u.member.offset = offset; + m->u.member.length = ((offset & 7) || (size & 7)) ? size : 0; p = vector_add(&udt_type->vchildren, &module->pool); *p = &m->symt; @@ -281,24 +283,26 @@ BOOL symt_add_enum_element(struct module* module, struct symt_enum* enum_type, return TRUE; } -struct symt_array* symt_new_array(struct module* module, int min, int max, - struct symt* base) +struct symt_array* symt_new_array(struct module* module, int min, int max, + struct symt* base, struct symt* index) { struct symt_array* sym; if ((sym = pool_alloc(&module->pool, sizeof(*sym)))) { - sym->symt.tag = SymTagArrayType; - sym->start = min; - sym->end = max; - sym->basetype = base; + sym->symt.tag = SymTagArrayType; + sym->start = min; + sym->end = max; + sym->base_type = base; + sym->index_type = index; symt_add_type(module, &sym->symt); } return sym; } -struct symt_function_signature* symt_new_function_signature(struct module* module, - struct symt* ret_type) +struct symt_function_signature* symt_new_function_signature(struct module* module, + struct symt* ret_type, + enum CV_call_e call_conv) { struct symt_function_signature* sym; @@ -307,6 +311,7 @@ struct symt_function_signature* symt_new_function_signature(struct module* modul sym->symt.tag = SymTagFunctionType; sym->rettype = ret_type; vector_init(&sym->vchildren, sizeof(struct symt*), 4); + sym->call_conv = call_conv; symt_add_type(module, &sym->symt); } return sym; @@ -316,12 +321,18 @@ BOOL symt_add_function_signature_parameter(struct module* module, struct symt_function_signature* sig_type, struct symt* param) { - struct symt** p; + struct symt** p; + struct symt_function_arg_type* arg; assert(sig_type->symt.tag == SymTagFunctionType); + arg = pool_alloc(&module->pool, sizeof(*arg)); + if (!arg) return FALSE; + arg->symt.tag = SymTagFunctionArgType; + arg->arg_type = param; + arg->container = &sig_type->symt; p = vector_add(&sig_type->vchildren, &module->pool); - if (!p) return FALSE; /* FIXME we leak e */ - *p = param; + if (!p) return FALSE; /* FIXME we leak arg */ + *p = &arg->symt; return TRUE; } @@ -339,7 +350,7 @@ struct symt_pointer* symt_new_pointer(struct module* module, struct symt* ref_ty return sym; } -struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref, +struct symt_typedef* symt_new_typedef(struct module* module, struct symt* ref, const char* name) { struct symt_typedef* sym; @@ -363,32 +374,33 @@ BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll, PSYM_ENUMERATESYMBOLS_CALLBACK EnumSymbolsCallback, PVOID UserContext) { - struct process* pcs; - struct module* module; + struct module_pair pair; char buffer[sizeof(SYMBOL_INFO) + 256]; SYMBOL_INFO* sym_info = (SYMBOL_INFO*)buffer; const char* tmp; struct symt* type; - void* pos = NULL; + DWORD64 size; + int i; TRACE("(%p %s %p %p)\n", hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback, UserContext); - if (!(pcs = process_find_by_handle(hProcess))) return FALSE; - module = module_find_by_addr(pcs, BaseOfDll, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) return FALSE; + if (!(pair.pcs = process_find_by_handle(hProcess))) return FALSE; + pair.requested = module_find_by_addr(pair.pcs, BaseOfDll, DMT_UNKNOWN); + if (!module_get_debug(&pair)) return FALSE; sym_info->SizeOfStruct = sizeof(SYMBOL_INFO); sym_info->MaxNameLen = sizeof(buffer) - sizeof(SYMBOL_INFO); - while ((pos = vector_iter_up(&module->vtypes, pos))) + for (i=0; ivtypes); i++) { - type = *(struct symt**)pos; + type = *(struct symt**)vector_at(&pair.effective->vtypes, i); sym_info->TypeIndex = (DWORD)type; sym_info->info = 0; /* FIXME */ - symt_get_info(type, TI_GET_LENGTH, &sym_info->Size); - sym_info->ModBase = module->module.BaseOfImage; + symt_get_info(type, TI_GET_LENGTH, &size); + sym_info->Size = size; + sym_info->ModBase = pair.requested->module.BaseOfImage; sym_info->Flags = 0; /* FIXME */ sym_info->Value = 0; /* FIXME */ sym_info->Address = 0; /* FIXME */ @@ -398,22 +410,55 @@ BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll, tmp = symt_get_name(type); if (tmp) { - sym_info->NameLen = strlen(tmp) + 1; - strncpy(sym_info->Name, tmp, min(sym_info->NameLen, sym_info->MaxNameLen)); - sym_info->Name[sym_info->MaxNameLen - 1] = '\0'; + sym_info->NameLen = min(strlen(tmp),sym_info->MaxNameLen-1); + memcpy(sym_info->Name, tmp, sym_info->NameLen); + sym_info->Name[sym_info->NameLen] = '\0'; } - else sym_info->Name[sym_info->NameLen = 0] = '\0'; + else + sym_info->Name[sym_info->NameLen = 0] = '\0'; if (!EnumSymbolsCallback(sym_info, sym_info->Size, UserContext)) break; } return TRUE; } +struct enum_types_AtoW +{ + char buffer[sizeof(SYMBOL_INFOW) + 256 * sizeof(WCHAR)]; + void* user; + PSYM_ENUMERATESYMBOLS_CALLBACKW callback; +}; + +BOOL CALLBACK enum_types_AtoW(PSYMBOL_INFO si, ULONG addr, PVOID _et) +{ + struct enum_types_AtoW* et = _et; + SYMBOL_INFOW* siW = (SYMBOL_INFOW*)et->buffer; + + copy_symbolW(siW, si); + return et->callback(siW, addr, et->user); +} + +/****************************************************************** + * SymEnumTypesW (DBGHELP.@) + * + */ +BOOL WINAPI SymEnumTypesW(HANDLE hProcess, ULONG64 BaseOfDll, + PSYM_ENUMERATESYMBOLS_CALLBACKW EnumSymbolsCallback, + PVOID UserContext) +{ + struct enum_types_AtoW et; + + et.callback = EnumSymbolsCallback; + et.user = UserContext; + + return SymEnumTypes(hProcess, BaseOfDll, enum_types_AtoW, &et); +} + /****************************************************************** * symt_get_info * - * Retrieves inforamtion about a symt (either symbol or type) + * Retrieves information about a symt (either symbol or type) */ -BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, +BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, void* pInfo) { unsigned len; @@ -439,7 +484,7 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, case SymTagFunctionType: v = &((const struct symt_function_signature*)type)->vchildren; break; case SymTagFunction: v = &((const struct symt_function*)type)->vchildren; break; default: - FIXME("Unsupported sym-tag %s for find-children\n", + FIXME("Unsupported sym-tag %s for find-children\n", symt_get_tag_str(type->tag)); return FALSE; } @@ -459,7 +504,7 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, { case DataIsGlobal: case DataIsFileStatic: - X(ULONG64) = ((const struct symt_data*)type)->u.address; + X(ULONG64) = ((const struct symt_data*)type)->u.var.offset; break; default: return FALSE; } @@ -473,14 +518,17 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, case SymTagFuncDebugStart: case SymTagFuncDebugEnd: case SymTagLabel: - X(ULONG64) = ((const struct symt_function_point*)type)->parent->address + - ((const struct symt_function_point*)type)->offset; + X(ULONG64) = ((const struct symt_function_point*)type)->parent->address + + ((const struct symt_function_point*)type)->loc.offset; break; case SymTagThunk: X(ULONG64) = ((const struct symt_thunk*)type)->address; break; + case SymTagCompiland: + X(ULONG64) = ((const struct symt_compiland*)type)->address; + break; default: - FIXME("Unsupported sym-tag %s for get-address\n", + FIXME("Unsupported sym-tag %s for get-address\n", symt_get_tag_str(type->tag)); return FALSE; } @@ -501,11 +549,11 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, break; case TI_GET_BITPOSITION: - if (type->tag != SymTagData || - ((const struct symt_data*)type)->kind != DataIsMember || - ((const struct symt_data*)type)->u.s.length == 0) - return FALSE; - X(DWORD) = ((const struct symt_data*)type)->u.s.offset & 7; + if (type->tag == SymTagData && + ((const struct symt_data*)type)->kind == DataIsMember && + ((const struct symt_data*)type)->u.member.length != 0) + X(DWORD) = ((const struct symt_data*)type)->u.member.offset & 7; + else return FALSE; break; case TI_GET_CHILDRENCOUNT: @@ -529,7 +577,7 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, X(DWORD) = 0; break; default: - FIXME("Unsupported sym-tag %s for get-children-count\n", + FIXME("Unsupported sym-tag %s for get-children-count\n", symt_get_tag_str(type->tag)); /* fall through */ case SymTagData: @@ -540,13 +588,20 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, break; case TI_GET_COUNT: - /* it seems that FunctionType also react to GET_COUNT (same value as - * GET_CHILDREN_COUNT ?, except for C++ methods, where it seems to - * also include 'this' (GET_CHILDREN_COUNT+1) - */ - if (type->tag != SymTagArrayType) return FALSE; - X(DWORD) = ((const struct symt_array*)type)->end - - ((const struct symt_array*)type)->start + 1; + switch (type->tag) + { + case SymTagArrayType: + X(DWORD) = ((const struct symt_array*)type)->end - + ((const struct symt_array*)type)->start + 1; + break; + case SymTagFunctionType: + /* this seems to be wrong for (future) C++ methods, where 'this' parameter + * should be included in this value (and not in GET_CHILDREN_COUNT) + */ + X(DWORD) = vector_length(&((const struct symt_function_signature*)type)->vchildren); + break; + default: return FALSE; + } break; case TI_GET_DATAKIND: @@ -558,44 +613,43 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, switch (type->tag) { case SymTagBaseType: - X(DWORD) = ((const struct symt_basic*)type)->size; + X(DWORD64) = ((const struct symt_basic*)type)->size; break; case SymTagFunction: - X(DWORD) = ((const struct symt_function*)type)->size; + X(DWORD64) = ((const struct symt_function*)type)->size; break; case SymTagPointerType: - X(DWORD) = sizeof(void*); + X(DWORD64) = sizeof(void*); break; case SymTagUDT: - X(DWORD) = ((const struct symt_udt*)type)->size; + X(DWORD64) = ((const struct symt_udt*)type)->size; break; case SymTagEnum: - X(DWORD) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */ + X(DWORD64) = sizeof(int); /* FIXME: should be size of base-type of enum !!! */ break; case SymTagData: if (((const struct symt_data*)type)->kind != DataIsMember || - !((const struct symt_data*)type)->u.s.length) + !((const struct symt_data*)type)->u.member.length) return FALSE; - X(DWORD) = ((const struct symt_data*)type)->u.s.length; + X(DWORD64) = ((const struct symt_data*)type)->u.member.length; break; - case SymTagArrayType: - if (!symt_get_info(((const struct symt_array*)type)->basetype, + case SymTagArrayType: + if (!symt_get_info(((const struct symt_array*)type)->base_type, TI_GET_LENGTH, pInfo)) return FALSE; - X(DWORD) *= ((const struct symt_array*)type)->end - + X(DWORD64) *= ((const struct symt_array*)type)->end - ((const struct symt_array*)type)->start + 1; break; case SymTagPublicSymbol: - X(DWORD) = ((const struct symt_public*)type)->size; + X(DWORD64) = ((const struct symt_public*)type)->size; break; case SymTagTypedef: return symt_get_info(((const struct symt_typedef*)type)->type, TI_GET_LENGTH, pInfo); - break; case SymTagThunk: - X(DWORD) = ((const struct symt_thunk*)type)->size; + X(DWORD64) = ((const struct symt_thunk*)type)->size; break; default: - FIXME("Unsupported sym-tag %s for get-length\n", + FIXME("Unsupported sym-tag %s for get-length\n", symt_get_tag_str(type->tag)); /* fall through */ case SymTagFunctionType: @@ -618,8 +672,11 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, case SymTagThunk: X(DWORD) = (DWORD)((const struct symt_thunk*)type)->container; break; + case SymTagFunctionArgType: + X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->container; + break; default: - FIXME("Unsupported sym-tag %s for get-lexical-parent\n", + FIXME("Unsupported sym-tag %s for get-lexical-parent\n", symt_get_tag_str(type->tag)); return FALSE; } @@ -645,17 +702,19 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, { case DataIsParam: case DataIsLocal: + X(ULONG) = ((const struct symt_data*)type)->u.var.offset; + break; case DataIsMember: - X(ULONG) = ((const struct symt_data*)type)->u.s.offset >> 3; + X(ULONG) = ((const struct symt_data*)type)->u.member.offset >> 3; break; default: - FIXME("Unknown kind (%u) for get-offset\n", + FIXME("Unknown kind (%u) for get-offset\n", ((const struct symt_data*)type)->kind); return FALSE; } break; default: - FIXME("Unsupported sym-tag %s for get-offset\n", + FIXME("Unsupported sym-tag %s for get-offset\n", symt_get_tag_str(type->tag)); return FALSE; } @@ -682,7 +741,7 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, { /* hierarchical => hierarchical */ case SymTagArrayType: - X(DWORD) = (DWORD)((const struct symt_array*)type)->basetype; + X(DWORD) = (DWORD)((const struct symt_array*)type)->base_type; break; case SymTagPointerType: X(DWORD) = (DWORD)((const struct symt_pointer*)type)->pointsto; @@ -695,15 +754,19 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, break; /* lexical => hierarchical */ case SymTagData: - X(DWORD) = (DWORD)((const struct symt_data*)type)->type; + X(DWORD) = (DWORD)((const struct symt_data*)type)->type; break; case SymTagFunction: X(DWORD) = (DWORD)((const struct symt_function*)type)->type; break; - /* FIXME: should also work for enums and FunctionArgType */ + /* FIXME: should also work for enums */ + case SymTagFunctionArgType: + X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type; + break; default: - FIXME("Unsupported sym-tag %s for get-type\n", + FIXME("Unsupported sym-tag %s for get-type\n", symt_get_tag_str(type->tag)); + case SymTagPublicSymbol: case SymTagThunk: return FALSE; } @@ -720,11 +783,23 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, X(VARIANT) = ((const struct symt_data*)type)->u.value; break; + case TI_GET_CALLING_CONVENTION: + if (type->tag != SymTagFunctionType) return FALSE; + if (((const struct symt_function_signature*)type)->call_conv == -1) + { + FIXME("No support for calling convention for this signature\n"); + X(DWORD) = CV_CALL_FAR_C; /* FIXME */ + } + else X(DWORD) = ((const struct symt_function_signature*)type)->call_conv; + break; + case TI_GET_ARRAYINDEXTYPEID: + if (type->tag != SymTagArrayType) return FALSE; + X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type; + break; + #undef X case TI_GET_ADDRESSOFFSET: - case TI_GET_ARRAYINDEXTYPEID: - case TI_GET_CALLING_CONVENTION: case TI_GET_CLASSPARENTID: case TI_GET_SYMINDEX: case TI_GET_THISADJUST: @@ -734,6 +809,9 @@ BOOL symt_get_info(const struct symt* type, IMAGEHLP_SYMBOL_TYPE_INFO req, case TI_IS_EQUIV_TO: FIXME("Unsupported GetInfo request (%u)\n", req); return FALSE; + default: + FIXME("Unknown GetInfo request (%u)\n", req); + return FALSE; } return TRUE; @@ -747,13 +825,13 @@ BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase, ULONG TypeId, IMAGEHLP_SYMBOL_TYPE_INFO GetType, PVOID pInfo) { - struct process* pcs = process_find_by_handle(hProcess); - struct module* module; + struct module_pair pair; - if (!pcs) return FALSE; + pair.pcs = process_find_by_handle(hProcess); + if (!pair.pcs) return FALSE; - module = module_find_by_addr(pcs, ModBase, DMT_UNKNOWN); - if (!(module = module_get_debug(pcs, module))) + pair.requested = module_find_by_addr(pair.pcs, ModBase, DMT_UNKNOWN); + if (!module_get_debug(&pair)) { FIXME("Someone didn't properly set ModBase (%s)\n", wine_dbgstr_longlong(ModBase)); return FALSE; @@ -767,7 +845,7 @@ BOOL WINAPI SymGetTypeInfo(HANDLE hProcess, DWORD64 ModBase, * */ BOOL WINAPI SymGetTypeFromName(HANDLE hProcess, ULONG64 BaseOfDll, - LPSTR Name, PSYMBOL_INFO Symbol) + PCSTR Name, PSYMBOL_INFO Symbol) { struct process* pcs = process_find_by_handle(hProcess); struct module* module; diff --git a/reactos/dll/win32/dbghelp/wdbgexts.h b/reactos/dll/win32/dbghelp/wdbgexts.h new file mode 100644 index 00000000000..91bcbf55597 --- /dev/null +++ b/reactos/dll/win32/dbghelp/wdbgexts.h @@ -0,0 +1,63 @@ +/* + * File wdbgexts.h: definition of windbg extensions + * (dbghelp.dll is seen as a windbg extension) + * + * Copyright (C) 2005, Eric Pouech + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +typedef struct EXT_API_VERSION +{ + USHORT MajorVersion; + USHORT MinorVersion; + USHORT Revision; + USHORT Reserved; +} EXT_API_VERSION, *LPEXT_API_VERSION; + +typedef void (*PWINDBG_OUTPUT_ROUTINE)(PCSTR, ...); +typedef ULONG_PTR (WINAPI *PWINDBG_GET_EXPRESSION)(PCSTR); +typedef void (WINAPI *PWINDBG_GET_SYMBOL)(void*, char*, ULONG_PTR*); +typedef ULONG (WINAPI *PWINDBG_DISASM)(ULONG_PTR*, PCSTR, ULONG); +typedef ULONG (WINAPI *PWINDBG_CHECK_CONTROL_C)(void); +typedef ULONG (WINAPI *PWINDBG_READ_PROCESS_MEMORY_ROUTINE)(ULONG_PTR, void*, ULONG, PULONG); +typedef ULONG (WINAPI *PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE)(ULONG_PTR, const void*, ULONG, PULONG); +typedef ULONG (WINAPI *PWINDBG_GET_THREAD_CONTEXT_ROUTINE)(ULONG, PCONTEXT, ULONG); +typedef ULONG (WINAPI *PWINDBG_SET_THREAD_CONTEXT_ROUTINE)(ULONG, PCONTEXT, ULONG); +typedef ULONG (WINAPI *PWINDBG_IOCTL_ROUTINE)(USHORT, void*); +typedef struct _EXTSTACKTRACE +{ + ULONG FramePointer; + ULONG ProgramCounter; + ULONG ReturnAddress; + ULONG Args[4]; +} EXTSTACKTRACE, *PEXTSTACKTRACE; +typedef ULONG (WINAPI *PWINDBG_STACKTRACE_ROUTINE)(ULONG, ULONG, ULONG, PEXTSTACKTRACE, ULONG); + +typedef struct _WINDBG_EXTENSION_APIS +{ + ULONG nSize; + PWINDBG_OUTPUT_ROUTINE lpOutputRoutine; + PWINDBG_GET_EXPRESSION lpGetExpressionRoutine; + PWINDBG_GET_SYMBOL lpGetSymbolRoutine; + PWINDBG_DISASM lpDisasmRoutine; + PWINDBG_CHECK_CONTROL_C lpCheckControlCRoutine; + PWINDBG_READ_PROCESS_MEMORY_ROUTINE lpReadProcessMemoryRoutine; + PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE lpWriteProcessMemoryRoutine; + PWINDBG_GET_THREAD_CONTEXT_ROUTINE lpGetThreadContextRoutine; + PWINDBG_SET_THREAD_CONTEXT_ROUTINE lpSetThreadContextRoutine; + PWINDBG_IOCTL_ROUTINE lpIoctlRoutine; + PWINDBG_STACKTRACE_ROUTINE lpStackTraceRoutine; +} WINDBG_EXTENSION_APIS, *PWINDBG_EXTENSION_APIS;