+++ /dev/null
-TOPSRCDIR = @top_srcdir@
-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 \
- minidump.c \
- module.c \
- msc.c \
- path.c \
- pe_module.c \
- source.c \
- stabs.c \
- stack.c \
- storage.c \
- symbol.c \
- type.c
-
-@MAKE_DLL_RULES@
-
-@DEPENDENCIES@ # everything below this line is overwritten by make depend
TRACE("(%p %s %u)\n", hProcess, debugstr_w(UserSearchPath), fInvadeProcess);
- if (process_find_by_handle(hProcess))
- FIXME("what to do ??\n");
+ if (process_find_by_handle(hProcess)){
+ WARN("the symbols for this process have already been initialized!\n");
+
+ /* MSDN says to only call this function once unless SymCleanup() has been called since the last call.
+ It also says to call SymRefreshModuleList() instead if you just want the module list refreshed.
+ Native still returns TRUE even if the process has already been initialized. */
+ return TRUE;
+ }
pcs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pcs));
if (!pcs) return FALSE;
return TRUE;
}
}
+
+ ERR("this process has not had SymInitialize() called for it!\n");
return FALSE;
}
+++ /dev/null
-; $Id: dbghelp.def 27344 2007-08-01 14:12:10Z tkreuzer $
-;
-; ReactOS Operating System
-;
-; This file contains all dbghelp.dll exports
-;
-LIBRARY dbghelp.dll
-
-EXPORTS
-;SymGetOmapBlockBase
-DbgHelpCreateUserDump@12
-DbgHelpCreateUserDumpW@12
-EnumDirTree@24
-EnumDirTreeW@24
-EnumerateLoadedModules64@12
-EnumerateLoadedModules@12
-EnumerateLoadedModulesW64@12
-ExtensionApiVersion@0
-FindDebugInfoFile@12
-FindDebugInfoFileEx@20
-;FindDebugInfoFileExW; not existent on windows, stubbed in wine spec
-FindExecutableImage@12
-FindExecutableImageEx@20
-FindExecutableImageExW@20
-FindFileInPath@32
-FindFileInSearchPath@28
-GetTimestampForLoadedLibrary@4
-ImageDirectoryEntryToData@16=ntdll.RtlImageDirectoryEntryToData
-ImageDirectoryEntryToDataEx@20
-ImageNtHeader@4=ntdll.RtlImageNtHeader
-ImageRvaToSection@12=ntdll.RtlImageRvaToSection
-ImageRvaToVa@16=ntdll.RtlImageRvaToVa
-ImagehlpApiVersion@0
-ImagehlpApiVersionEx@4
-MakeSureDirectoryPathExists@4
-MapDebugInformation@16
-MiniDumpReadDumpStream@20
-MiniDumpWriteDump@28
-SearchTreeForFile@12
-SearchTreeForFileW@12
-StackWalk64@36
-StackWalk@36
-SymAddSymbol@32
-SymAddSymbolW@32
-SymCleanup@4
-SymDeleteSymbol@28
-SymDeleteSymbolW@28
-SymEnumLines@28
-SymEnumLinesW@28
-SymEnumProcesses@8
-SymEnumSourceFiles@24
-SymEnumSourceFilesW@24
-SymEnumSourceLines@36
-SymEnumSourceLinesW@36
-SymEnumSym@20
-SymEnumSymbols@24
-SymEnumSymbolsForAddr@20
-SymEnumSymbolsForAddrW@20
-SymEnumSymbolsW@24
-SymEnumTypes@20
-SymEnumTypesW@20
-SymEnumerateModules64@12
-SymEnumerateModules@12
-SymEnumerateModulesW64@12
-SymEnumerateSymbols64@20
-SymEnumerateSymbols@16
-SymEnumerateSymbolsW64@20
-SymEnumerateSymbolsW@16
-;SymFindDebugInfoFile; not existent on windows, stubbed in wine spec
-;SymFindDebugInfoFileW; not existent on windows, stubbed in wine spec
-SymFindFileInPath@40
-SymFindFileInPathW@40
-SymFromAddr@20
-SymFromAddrW@20
-SymFromIndex@20
-SymFromIndexW@20
-SymFromName@12
-SymFromNameW@12
-SymFromToken@20
-SymFromTokenW@20
-SymFunctionTableAccess64@12
-SymFunctionTableAccess@8
-SymGetFileLineOffsets64@20
-SymGetHomeDirectory@12
-SymGetHomeDirectoryW@12
-SymGetLineFromAddr64@20
-SymGetLineFromAddr@16
-SymGetLineFromAddrW64@20
-SymGetLineFromName64@24
-SymGetLineFromName@24
-SymGetLineFromNameW64@24
-SymGetLineNext64@8
-SymGetLineNext@8
-SymGetLineNextW64@8
-SymGetLinePrev64@8
-SymGetLinePrev@8
-SymGetLinePrevW64@8
-SymGetModuleBase64@12
-SymGetModuleBase@8
-SymGetModuleInfo64@16
-SymGetModuleInfo@12
-SymGetModuleInfoW64@16
-SymGetModuleInfoW@12
-SymGetOptions@0
-SymGetScope@20
-SymGetScopeW@20
-SymGetSearchPath@12
-SymGetSearchPathW@12
-SymGetSourceFile@28
-SymGetSourceFileFromToken@20
-SymGetSourceFileFromTokenW@20
-SymGetSourceFileToken@24
-SymGetSourceFileTokenW@24
-;SymGetSourceFileW
-;SymGetSourceVarFromToken
-;SymGetSourceVarFromTokenW
-SymGetSymFromAddr64@20
-SymGetSymFromAddr@16
-SymGetSymFromName64@12
-SymGetSymFromName@12
-SymGetSymNext64@8
-SymGetSymNext@8
-SymGetSymPrev64@8
-SymGetSymPrev@8
-SymGetSymbolFile@32
-SymGetSymbolFileW@32
-SymGetTypeFromName@20
-SymGetTypeFromNameW@20
-SymGetTypeInfo@24
-SymGetTypeInfoEx@16
-SymInitialize@12
-SymInitializeW@12
-SymLoadModule64@28
-SymLoadModule@24
-SymLoadModuleEx@36
-SymLoadModuleExW@36
-SymMatchFileName@16
-SymMatchFileNameW@16
-SymMatchString@12
-SymMatchStringA@12
-SymMatchStringW@12
-SymNext@8
-SymNextW@8
-SymPrev@8
-SymPrevW@8
-;SymRefreshModuleList
-SymRegisterCallback64@16
-SymRegisterCallback@12
-SymRegisterCallbackW64@16
-SymRegisterFunctionEntryCallback64@16
-SymRegisterFunctionEntryCallback@12
-SymSearch@44
-SymSearchW@44
-SymSetContext@12
-SymSetHomeDirectory@8
-SymSetHomeDirectoryW@8
-SymSetOptions@4
-SymSetParentWindow@4
-SymSetSearchPath@8
-SymSetSearchPathW@8
-;SymSetSymWithAddr64
-SymSrvDeltaName@20
-SymSrvDeltaNameW@20
-;SymSrvGetFileIndexInfo; not existent on windows, stubbed in wine spec
-;SymSrvGetFileIndexInfoW; not existent on windows, stubbed in wine spec
-SymSrvGetFileIndexString@24
-SymSrvGetFileIndexStringW@24
-SymSrvGetFileIndexes@20
-SymSrvGetFileIndexesW@20
-SymSrvGetSupplement@16
-SymSrvGetSupplementW@16
-SymSrvIsStore@8
-SymSrvIsStoreW@8
-SymSrvStoreFile@16
-SymSrvStoreFileW@16
-SymSrvStoreSupplement@20
-SymSrvStoreSupplementW@20
-SymUnDName64@12
-SymUnDName@12
-SymUnloadModule64@12
-SymUnloadModule@8
-UnDecorateSymbolName@16
-UnDecorateSymbolNameW@16
-UnmapDebugInformation@4
-WinDbgExtensionDllInit@12
-;block
-;dbghelp
-;dh
-;fptr
-;homedir
-;lmi
-;lminfo
-;omap
-;srcfiles
-;stack_force_ebp
-;stackdbg
-;sym
-;symsrv
-;vc7fpo
+<?xml version="1.0"?>
+<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
+<group>
<module name="dbghelp" type="win32dll" baseaddress="${BASEADDRESS_DBGHELP}" installbase="system32" installname="dbghelp.dll" allowwarnings="true">
- <importlibrary definition="dbghelp.def" />
+ <importlibrary definition="dbghelp.spec.def" />
<include base="dbghelp">.</include>
<include base="ReactOS">include/reactos/wine</include>
- <define name="_WIN32_IE">0x600</define>
- <define name="_WIN32_WINNT">0x502</define>
- <define name="WINVER">0x502</define>
<define name="__WINESRC__" />
+ <define name="WINVER">0x600</define>
+ <define name="_WIN32_WINNT">0x600</define>
<define name="HAVE_REGEX_H" />
- <library>ntdll</library>
- <library>wine</library>
- <library>pseh</library>
- <library>kernel32</library>
- <library>psapi</library>
<file>coff.c</file>
<file>dbghelp.c</file>
<file>dwarf.c</file>
<file>source.c</file>
<file>stabs.c</file>
<file>stack.c</file>
- <file>stubs.c</file>
<file>storage.c</file>
<file>symbol.c</file>
<file>type.c</file>
- <file>dbghelp.rc</file>
+ <file>dbghelp.spec</file>
+ <library>wine</library>
+ <library>psapi</library>
+ <library>kernel32</library>
+ <library>version</library>
+ <library>ntdll</library>
</module>
+</group>
+++ /dev/null
-#include "wine/wine_common_ver.rc"
@ stub FindFileInPath
@ stub FindFileInSearchPath
@ stdcall GetTimestampForLoadedLibrary(long)
-@ stdcall ImageDirectoryEntryToData(ptr long long ptr) ntdll.RtlImageDirectoryEntryToData
-@ stub ImageDirectoryEntryToDataEx
+@ stdcall ImageDirectoryEntryToData(ptr long long ptr)
+@ stdcall ImageDirectoryEntryToDataEx(ptr long long ptr ptr)
@ stdcall ImageNtHeader(ptr) ntdll.RtlImageNtHeader
@ stdcall ImageRvaToSection(ptr ptr long) ntdll.RtlImageRvaToSection
@ stdcall ImageRvaToVa(ptr ptr long ptr) ntdll.RtlImageRvaToVa
@ stdcall SymEnumerateModules64(long ptr ptr)
@ stdcall SymEnumerateModulesW64(long ptr ptr)
@ stdcall SymEnumerateSymbols(long long ptr ptr)
-@ stub SymEnumerateSymbols64
+@ stdcall SymEnumerateSymbols64(long double ptr ptr)
@ stub SymEnumerateSymbolsW
@ stub SymEnumerateSymbolsW64
@ stub SymFindDebugInfoFile
void* hash_table_iter_up(struct hash_table_iter* hti);
#define GET_ENTRY(__i, __t, __f) \
- ((__t*)((char*)(__i) - (unsigned int)(&((__t*)0)->__f)))
+ ((__t*)((char*)(__i) - FIELD_OFFSET(__t,__f)))
extern unsigned dbghelp_options;
struct vector vchildren; /* locals, params, blocks, start/end, labels */
};
-struct symt_function_point
+struct symt_hierarchy_point
{
struct symt symt; /* either SymTagFunctionDebugStart, SymTagFunctionDebugEnd, SymTagLabel */
- struct symt_function* parent;
+ struct hash_table_elt hash_elt; /* if label (and in compiland's hash table if global) */
+ struct symt* parent; /* symt_function or symt_compiland */
struct location loc;
- const char* name; /* for labels */
};
struct symt_public
struct symt_enum
{
struct symt symt;
+ struct symt* base_type;
const char* name;
struct vector vchildren;
};
symt_close_func_block(struct module* module,
struct symt_function* func,
struct symt_block* block, unsigned pc);
-extern struct symt_function_point*
+extern struct symt_hierarchy_point*
symt_add_function_point(struct module* module,
struct symt_function* func,
enum SymTagEnum point,
struct symt_compiland* parent,
const char* name, struct symt* type,
const VARIANT* v);
+extern struct symt_hierarchy_point*
+ symt_new_label(struct module* module,
+ struct symt_compiland* compiland,
+ const char* name, unsigned long address);
/* type.c */
extern void symt_init_basic(struct module* module);
struct symt* elt_type, unsigned offset,
unsigned size);
extern struct symt_enum*
- symt_new_enum(struct module* module, const char* typename);
+ symt_new_enum(struct module* module, const char* typename,
+ struct symt* basetype);
extern BOOL symt_add_enum_element(struct module* module,
struct symt_enum* enum_type,
const char* name, int value);
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#define NONAMELESSUNION
+
#include "config.h"
#include <sys/types.h>
unsigned char word_size;
} dwarf2_traverse_context_t;
+/* symt_cache indexes */
+#define sc_void 0
+#define sc_int1 1
+#define sc_int2 2
+#define sc_int4 3
+#define sc_num 4
+
typedef struct dwarf2_parse_context_s
{
const dwarf2_section_t* sections;
unsigned long load_offset;
unsigned long ref_offset;
unsigned char word_size;
+ struct symt* symt_cache[sc_num]; /* void, int1, int2, int4 */
} dwarf2_parse_context_t;
/* stored in the dbghelp's module internal structure for later reuse */
struct attribute size;
struct attribute encoding;
enum BasicType bt;
-
+ int cache_idx = -1;
if (di->symt) return di->symt;
TRACE("%s, for %s\n", dwarf2_debug_ctx(ctx), dwarf2_debug_di(di));
default: bt = btNoType; break;
}
di->symt = &symt_new_basic(ctx->module, bt, name.u.string, size.u.uvalue)->symt;
+ switch (bt)
+ {
+ case btVoid:
+ assert(size.u.uvalue == 0);
+ cache_idx = sc_void;
+ break;
+ case btInt:
+ switch (size.u.uvalue)
+ {
+ case 1: cache_idx = sc_int1; break;
+ case 2: cache_idx = sc_int2; break;
+ case 4: cache_idx = sc_int4; break;
+ }
+ break;
+ default: break;
+ }
+ if (cache_idx != -1 && !ctx->symt_cache[cache_idx])
+ ctx->symt_cache[cache_idx] = di->symt;
+
if (di->abbrev->have_child) FIXME("Unsupported children\n");
return di->symt;
}
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;
-
+ {
+ ref_type = ctx->symt_cache[sc_void];
+ assert(ref_type);
+ }
di->symt = &symt_new_pointer(ctx->module, ref_type)->symt;
if (di->abbrev->have_child) FIXME("Unsupported children\n");
return di->symt;
case DW_TAG_structure_type:
case DW_TAG_class_type:
case DW_TAG_union_type:
+ case DW_TAG_typedef:
/* FIXME: we need to handle nested udt definitions */
break;
default:
{
struct attribute name;
struct attribute size;
+ struct symt_basic* basetype;
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_byte_size, &size)) size.u.uvalue = 4;
+
+ switch (size.u.uvalue) /* FIXME: that's wrong */
+ {
+ case 1: basetype = symt_new_basic(ctx->module, btInt, "char", 1); break;
+ case 2: basetype = symt_new_basic(ctx->module, btInt, "short", 2); break;
+ default:
+ case 4: basetype = symt_new_basic(ctx->module, btInt, "int", 4); break;
+ }
- di->symt = &symt_new_enum(ctx->module, name.u.string)->symt;
+ di->symt = &symt_new_enum(ctx->module, name.u.string, &basetype->symt)->symt;
if (di->abbrev->have_child) /* any interest to not have child ? */
{
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_name, &name))
+ {
+ WARN("No name for function... dropping function\n");
+ return NULL;
+ }
/* if it's an abstract representation of an inline function, there should be
* a concrete object that we'll handle
*/
is_decl.u.uvalue = 0;
if (!(ret_type = dwarf2_lookup_type(ctx, di)))
- ret_type = &symt_new_basic(ctx->module, btVoid, "void", 0)->symt;
+ {
+ ret_type = ctx->symt_cache[sc_void];
+ assert(ret_type);
+ }
/* FIXME: assuming C source code */
sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C);
symt_add_function_point(ctx->module, subpgm.func, SymTagCustom,
&subpgm.frame, NULL);
}
- symt_normalize_function(subpgm.ctx->module, subpgm.func);
+ if (subpgm.func) symt_normalize_function(subpgm.ctx->module, subpgm.func);
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;
+ {
+ ret_type = ctx->symt_cache[sc_void];
+ assert(ret_type);
+ }
/* FIXME: assuming C source code */
sig_type = symt_new_function_signature(ctx->module, ret_type, CV_CALL_FAR_C);
}
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,
+ dwarf2_traverse_context_t* mod_ctx,
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;
+ dwarf2_traverse_context_t cu_ctx;
+ const unsigned char* comp_unit_start = mod_ctx->data;
+ unsigned long cu_length;
+ unsigned short cu_version;
+ unsigned long cu_abbrev_offset;
BOOL ret = FALSE;
+ cu_length = dwarf2_parse_u4(mod_ctx);
+ cu_ctx.data = cu_ctx.start_data = mod_ctx->data;
+ cu_ctx.end_data = mod_ctx->data + cu_length;
+ mod_ctx->data += cu_length;
+ cu_version = dwarf2_parse_u2(&cu_ctx);
+ cu_abbrev_offset = dwarf2_parse_u4(&cu_ctx);
+ cu_ctx.word_size = dwarf2_parse_byte(&cu_ctx);
+
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);
+ comp_unit_start - sections[section_debug].address);
+ TRACE("- length: %lu\n", cu_length);
+ TRACE("- version: %u\n", cu_version);
+ TRACE("- abbrev_offset: %lu\n", cu_abbrev_offset);
+ TRACE("- word_size: %u\n", cu_ctx.word_size);
- if (comp_unit->version != 2)
+ if (cu_version != 2)
{
WARN("%u DWARF version unsupported. Wine dbghelp only support DWARF 2.\n",
- comp_unit->version);
+ cu_version);
return FALSE;
}
ctx.sections = sections;
ctx.section = section_debug;
ctx.module = module;
- ctx.word_size = comp_unit->word_size;
+ ctx.word_size = cu_ctx.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);
+ ctx.ref_offset = comp_unit_start - sections[section_debug].address;
+ memset(ctx.symt_cache, 0, sizeof(ctx.symt_cache));
+ ctx.symt_cache[sc_void] = &symt_new_basic(module, btVoid, "void", 0)->symt;
- abbrev_ctx.start_data = sections[section_abbrev].address + comp_unit->abbrev_offset;
+ abbrev_ctx.start_data = sections[section_abbrev].address + cu_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;
+ abbrev_ctx.word_size = cu_ctx.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);
+ dwarf2_read_one_debug_info(&ctx, &cu_ctx, &di);
if (di->abbrev->tag == DW_TAG_compile_unit)
{
psym = vector_at(&func->vchildren, i);
if ((*psym)->tag == SymTagCustom)
{
- pframe = &((struct symt_function_point*)*psym)->loc;
+ pframe = &((struct symt_hierarchy_point*)*psym)->loc;
/* First, recompute the frame information, if needed */
switch (pframe->kind)
{
dwarf2_section_t section[section_max];
unsigned char* ptr;
- const unsigned char*comp_unit_cursor = debug;
- const unsigned char*end_debug = debug + debug_size;
+ dwarf2_traverse_context_t mod_ctx;
+
+ mod_ctx.start_data = mod_ctx.data = debug;
+ mod_ctx.end_data = debug + debug_size;
module->loc_compute = dwarf2_location_compute;
module->dwarf2_info->debug_loc.size = loclist_size;
}
- while (comp_unit_cursor < end_debug)
+ while (mod_ctx.data < mod_ctx.end_data)
{
- 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);
+ dwarf2_parse_compilation_unit(section, module, thunks, &mod_ctx, load_offset);
}
module->module.SymType = SymDia;
module->module.CVSig = 'D' | ('W' << 8) | ('A' << 16) | ('R' << 24);
* 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,
void* pcs_buffer;
SYSTEM_PROCESS_INFORMATION* spi;
/* module information */
- struct dump_module* module;
- unsigned num_module;
+ struct dump_module* modules;
+ unsigned num_modules;
/* exception information */
/* output information */
MINIDUMP_TYPE type;
};
/******************************************************************
- * fetch_process_info
+ * fetch_processes_info
*
* reads system wide process information, and make spi point to the record
* for process of id 'pid'
*/
-static BOOL fetch_process_info(struct dump_context* dc)
+static BOOL fetch_processes_info(struct dump_context* dc)
{
ULONG buf_size = 0x1000;
NTSTATUS nts;
{
#ifdef __i386__
/* limiting the stack dumping to the size actually used */
- if (ctx->Esp)
- mmd->StartOfMemoryRange = (ctx->Esp - 4);
+ if (ctx->Esp){
+
+ /* make sure ESP is within the established range of the stack. It could have
+ been clobbered by whatever caused the original exception. */
+ if (ctx->Esp - 4 < (ULONG_PTR)tib.StackLimit || ctx->Esp - 4 > (ULONG_PTR)tib.StackBase)
+ mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
+ else
+ mmd->StartOfMemoryRange = (ctx->Esp - 4);
+ }
+
else
mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
#elif defined(__powerpc__)
- if (ctx->Iar)
- mmd->StartOfMemoryRange = ctx->Iar - 4;
+ if (ctx->Iar){
+
+ /* make sure IAR is within the established range of the stack. It could have
+ been clobbered by whatever caused the original exception. */
+ if (ctx->Iar - 4 < (ULONG_PTR)tib.StackLimit || ctx->Iar - 4 > (ULONG_PTR)tib.StackBase)
+ mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
+ else
+ mmd->StartOfMemoryRange = (ctx->Iar - 4);
+ }
+
else
mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
#elif defined(__x86_64__)
- if (ctx->Rsp)
- mmd->StartOfMemoryRange = (ctx->Rsp - 8);
+ if (ctx->Rsp){
+
+ /* make sure RSP is within the established range of the stack. It could have
+ been clobbered by whatever caused the original exception. */
+ if (ctx->Rsp - 8 < (ULONG_PTR)tib.StackLimit || ctx->Rsp - 8 > (ULONG_PTR)tib.StackBase)
+ mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
+ else
+ mmd->StartOfMemoryRange = (ctx->Rsp - 8);
+ }
+
else
mmd->StartOfMemoryRange = (ULONG_PTR)tib.StackLimit;
+
#else
#error unsupported CPU
#endif
if (tid != GetCurrentThreadId() &&
(mdThd->SuspendCount = SuspendThread(hThread)) != (DWORD)-1)
{
- mdThd->SuspendCount--;
ctx->ContextFlags = CONTEXT_FULL;
if (!GetThreadContext(hThread, ctx))
memset(ctx, 0, sizeof(*ctx));
else if (tid == GetCurrentThreadId() && except)
{
CONTEXT lctx, *pctx;
+ mdThd->SuspendCount = 1;
if (except->ClientPointers)
{
EXCEPTION_POINTERS ep;
pctx = &lctx;
}
else pctx = except->ExceptionPointers->ContextRecord;
+
+ *ctx = *pctx;
fetch_thread_stack(dc, tbi.TebBaseAddress, pctx, &mdThd->Stack);
}
+ else mdThd->SuspendCount = 0;
}
}
CloseHandle(hThread);
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));
+ if (!dc->modules)
+ dc->modules = HeapAlloc(GetProcessHeap(), 0,
+ ++dc->num_modules * sizeof(*dc->modules));
else
- dc->module = HeapReAlloc(GetProcessHeap(), 0, dc->module,
- ++dc->num_module * sizeof(*dc->module));
- if (!dc->module) return FALSE;
+ dc->modules = HeapReAlloc(GetProcessHeap(), 0, dc->modules,
+ ++dc->num_modules * sizeof(*dc->modules));
+ if (!dc->modules) 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;
+ dc->modules[dc->num_modules - 1].name,
+ sizeof(dc->modules[dc->num_modules - 1].name) / sizeof(WCHAR)))
+ lstrcpynW(dc->modules[dc->num_modules - 1].name, name,
+ sizeof(dc->modules[dc->num_modules - 1].name) / sizeof(WCHAR));
+ dc->modules[dc->num_modules - 1].base = base;
+ dc->modules[dc->num_modules - 1].size = size;
+ dc->modules[dc->num_modules - 1].timestamp = timestamp;
+ dc->modules[dc->num_modules - 1].checksum = checksum;
+ dc->modules[dc->num_modules - 1].is_elf = is_elf;
return TRUE;
}
return TRUE;
}
-static void fetch_module_info(struct dump_context* dc)
+static void fetch_modules_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,
elf_enum_modules(dc->hProcess, fetch_elf_module_info_cb, dc);
}
+static void fetch_module_versioninfo(LPCWSTR filename, VS_FIXEDFILEINFO* ffi)
+{
+ DWORD handle;
+ DWORD sz;
+ static const WCHAR backslashW[] = {'\\', '\0'};
+
+ memset(ffi, 0, sizeof(*ffi));
+ if ((sz = GetFileVersionInfoSizeW(filename, &handle)))
+ {
+ void* info = HeapAlloc(GetProcessHeap(), 0, sz);
+ if (info && GetFileVersionInfoW(filename, handle, sz, info))
+ {
+ VS_FIXEDFILEINFO* ptr;
+ UINT len;
+
+ if (VerQueryValueW(info, backslashW, (void*)&ptr, &len))
+ memcpy(ffi, ptr, min(len, sizeof(*ffi)));
+ }
+ HeapFree(GetProcessHeap(), 0, info);
+ }
+}
+
/******************************************************************
* add_memory_block
*
*
* Write in File the exception information from pcs
*/
-static void dump_exception_info(struct dump_context* dc,
- const MINIDUMP_EXCEPTION_INFORMATION* except,
- DWORD *size)
+static unsigned dump_exception_info(struct dump_context* dc,
+ const MINIDUMP_EXCEPTION_INFORMATION* except)
{
MINIDUMP_EXCEPTION_STREAM mdExcpt;
EXCEPTION_RECORD rec, *prec;
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.ExceptionRecord.ExceptionInformation[i] = prec->ExceptionInformation[i];
mdExcpt.ThreadContext.DataSize = sizeof(*pctx);
mdExcpt.ThreadContext.Rva = dc->rva + sizeof(mdExcpt);
append(dc, &mdExcpt, sizeof(mdExcpt));
- *size = sizeof(mdExcpt);
append(dc, pctx, sizeof(*pctx));
+ return sizeof(mdExcpt);
}
/******************************************************************
*
* Write in File the modules from pcs
*/
-static void dump_modules(struct dump_context* dc, BOOL dump_elf, DWORD *size)
+static unsigned dump_modules(struct dump_context* dc, BOOL dump_elf)
{
MINIDUMP_MODULE mdModule;
MINIDUMP_MODULE_LIST mdModuleList;
ULONG i, nmod;
RVA rva_base;
DWORD flags_out;
+ unsigned sz;
- for (i = nmod = 0; i < dc->num_module; i++)
+ for (i = nmod = 0; i < dc->num_modules; i++)
{
- if ((dc->module[i].is_elf && dump_elf) ||
- (!dc->module[i].is_elf && !dump_elf))
+ if ((dc->modules[i].is_elf && dump_elf) ||
+ (!dc->modules[i].is_elf && !dump_elf))
nmod++;
}
* size of mdModuleList
* FIXME: if we don't ask for all modules in cb, we'll get a hole in the file
*/
+
+ /* the stream size is just the size of the module index. It does not include the data for the
+ names of each module. *Technically* the names are supposed to go into the common string table
+ in the minidump file. Since each string is referenced by RVA they can all safely be located
+ anywhere between streams in the file, so the end of this stream is sufficient. */
rva_base = dc->rva;
- dc->rva += *size = sizeof(mdModuleList.NumberOfModules) + sizeof(mdModule) * nmod;
- for (i = 0; i < dc->num_module; i++)
+ dc->rva += sz = sizeof(mdModuleList.NumberOfModules) + sizeof(mdModule) * nmod;
+ for (i = 0; i < dc->num_modules; i++)
{
- if ((dc->module[i].is_elf && !dump_elf) ||
- (!dc->module[i].is_elf && dump_elf))
+ if ((dc->modules[i].is_elf && !dump_elf) ||
+ (!dc->modules[i].is_elf && dump_elf))
continue;
flags_out = ModuleWriteModule | ModuleWriteMiscRecord | ModuleWriteCvRecord;
flags_out |= ModuleWriteTlsData;
if (dc->type & MiniDumpWithCodeSegs)
flags_out |= ModuleWriteCodeSegs;
- ms->Length = (lstrlenW(dc->module[i].name) + 1) * sizeof(WCHAR);
+ ms->Length = (lstrlenW(dc->modules[i].name) + 1) * sizeof(WCHAR);
if (sizeof(ULONG) + ms->Length > sizeof(tmp))
FIXME("Buffer overflow!!!\n");
- lstrcpyW(ms->Buffer, dc->module[i].name);
+ lstrcpyW(ms->Buffer, dc->modules[i].name);
if (dc->cb)
{
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;
+ cbin.u.Module.BaseOfImage = dc->modules[i].base;
+ cbin.u.Module.SizeOfImage = dc->modules[i].size;
+ cbin.u.Module.CheckSum = dc->modules[i].checksum;
+ cbin.u.Module.TimeDateStamp = dc->modules[i].timestamp;
memset(&cbin.u.Module.VersionInfo, 0, sizeof(cbin.u.Module.VersionInfo));
cbin.u.Module.CvRecord = NULL;
cbin.u.Module.SizeOfCvRecord = 0;
}
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.BaseOfImage = dc->modules[i].base;
+ mdModule.SizeOfImage = dc->modules[i].size;
+ mdModule.CheckSum = dc->modules[i].checksum;
+ mdModule.TimeDateStamp = dc->modules[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 */
+ fetch_module_versioninfo(ms->Buffer, &mdModule.VersionInfo);
mdModule.CvRecord.DataSize = 0; /* FIXME */
mdModule.CvRecord.Rva = 0; /* FIXME */
mdModule.MiscRecord.DataSize = 0; /* FIXME */
}
writeat(dc, rva_base, &mdModuleList.NumberOfModules,
sizeof(mdModuleList.NumberOfModules));
+
+ return sz;
}
/******************************************************************
*
* Dumps into File the information about the system
*/
-static void dump_system_info(struct dump_context* dc, DWORD *size)
+static unsigned dump_system_info(struct dump_context* dc)
{
MINIDUMP_SYSTEM_INFO mdSysInfo;
SYSTEM_INFO sysInfo;
mdSysInfo.CSDVersionRva = dc->rva + sizeof(mdSysInfo);
mdSysInfo.u1.Reserved1 = 0;
+ mdSysInfo.u1.s.SuiteMask = VER_SUITE_TERMINAL;
+ FIXME("fill in CPU vendorID and feature set\n");
memset(&mdSysInfo.Cpu, 0, sizeof(mdSysInfo.Cpu));
append(dc, &mdSysInfo, sizeof(mdSysInfo));
- *size = sizeof(mdSysInfo);
+ /* write the service pack version string after this stream. It is referenced within the
+ stream by its RVA in the file. */
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;
+
+ return sizeof(mdSysInfo);
}
/******************************************************************
*
* Dumps into File the information about running threads
*/
-static void dump_threads(struct dump_context* dc,
- const MINIDUMP_EXCEPTION_INFORMATION* except,
- DWORD *size)
+static unsigned dump_threads(struct dump_context* dc,
+ const MINIDUMP_EXCEPTION_INFORMATION* except)
{
MINIDUMP_THREAD mdThd;
MINIDUMP_THREAD_LIST mdThdList;
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.Context = ctx;
cbin.u.Thread.SizeOfContext = sizeof(CONTEXT);
cbin.u.Thread.StackBase = mdThd.Stack.StartOfMemoryRange;
cbin.u.Thread.StackEnd = mdThd.Stack.StartOfMemoryRange +
}
writeat(dc, rva_base,
&mdThdList.NumberOfThreads, sizeof(mdThdList.NumberOfThreads));
- *size = dc->rva - rva_base;
+
+ return dc->rva - rva_base;
}
/******************************************************************
*
* dumps information about the memory of the process (stack of the threads)
*/
-static void dump_memory_info(struct dump_context* dc, DWORD* size)
+static unsigned dump_memory_info(struct dump_context* dc)
{
MINIDUMP_MEMORY_LIST mdMemList;
MINIDUMP_MEMORY_DESCRIPTOR mdMem;
DWORD written;
- unsigned i, pos, len;
+ unsigned i, pos, len, sz;
RVA rva_base;
char tmp[1024];
append(dc, &mdMemList.NumberOfMemoryRanges,
sizeof(mdMemList.NumberOfMemoryRanges));
rva_base = dc->rva;
- dc->rva += mdMemList.NumberOfMemoryRanges * sizeof(mdMem);
- *size = sizeof(mdMemList.NumberOfMemoryRanges) +
- mdMemList.NumberOfMemoryRanges * sizeof(mdMem);
+ sz = mdMemList.NumberOfMemoryRanges * sizeof(mdMem);
+ dc->rva += sz;
+ sz += sizeof(mdMemList.NumberOfMemoryRanges);
for (i = 0; i < dc->num_mem; i++)
{
{
len = min(dc->mem[i].size - pos, sizeof(tmp));
if (ReadProcessMemory(dc->hProcess,
- (void*)(ULONG)(dc->mem[i].base + pos),
+ (void*)(dc->mem[i].base + pos),
tmp, len, NULL))
WriteFile(dc->hFile, tmp, len, &written, NULL);
}
writeat(dc, dc->mem[i].rva, &mdMem.Memory.Rva, sizeof(mdMem.Memory.Rva));
}
}
+
+ return sz;
}
-static void dump_misc_info(struct dump_context* dc, DWORD* size)
+static unsigned dump_misc_info(struct dump_context* dc)
{
MINIDUMP_MISC_INFO mmi;
mmi.Flags1 = MINIDUMP_MISC1_PROCESS_ID;
mmi.ProcessId = dc->pid;
/* FIXME: create/user/kernel time */
+ mmi.ProcessCreateTime = 0;
+ mmi.ProcessKernelTime = 0;
+ mmi.ProcessUserTime = 0;
+
append(dc, &mmi, sizeof(mmi));
- *size = sizeof(mmi);
+ return sizeof(mmi);
}
/******************************************************************
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
PMINIDUMP_CALLBACK_INFORMATION CallbackParam)
{
+ static const MINIDUMP_DIRECTORY emptyDir = {UnusedStream, {0, 0}};
MINIDUMP_HEADER mdHead;
MINIDUMP_DIRECTORY mdDir;
DWORD i, nStreams, idx_stream;
dc.hProcess = hProcess;
dc.hFile = hFile;
dc.pid = pid;
- dc.module = NULL;
- dc.num_module = 0;
+ dc.modules = NULL;
+ dc.num_modules = 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);
+ if (!fetch_processes_info(&dc)) return FALSE;
+ fetch_modules_info(&dc);
/* 1) init */
nStreams = 6 + (ExceptionParam ? 1 : 0) +
(UserStreamParam ? UserStreamParam->UserStreamCount : 0);
+ /* pad the directory size to a multiple of 4 for alignment purposes */
+ nStreams = (nStreams + 3) & ~3;
+
if (DumpType & MiniDumpWithDataSegs)
FIXME("NIY MiniDumpWithDataSegs\n");
if (DumpType & MiniDumpWithFullMemory)
/* 2) write header */
mdHead.Signature = MINIDUMP_SIGNATURE;
- mdHead.Version = MINIDUMP_VERSION;
+ mdHead.Version = MINIDUMP_VERSION; /* NOTE: native puts in an 'implementation specific' value in the high order word of this member */
mdHead.NumberOfStreams = nStreams;
+ mdHead.CheckSum = 0; /* native sets a 0 checksum in its files */
mdHead.StreamDirectoryRva = sizeof(mdHead);
mdHead.u.TimeDateStamp = time(NULL);
mdHead.Flags = DumpType;
- mdHead.CheckSum = 0;
append(&dc, &mdHead, sizeof(mdHead));
/* 3) write stream directories */
/* must be first in minidump */
mdDir.StreamType = SystemInfoStream;
mdDir.Location.Rva = dc.rva;
- dump_system_info(&dc, &mdDir.Location.DataSize);
+ mdDir.Location.DataSize = dump_system_info(&dc);
writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir),
&mdDir, sizeof(mdDir));
mdDir.StreamType = ThreadListStream;
mdDir.Location.Rva = dc.rva;
- dump_threads(&dc, ExceptionParam, &mdDir.Location.DataSize);
+ mdDir.Location.DataSize = dump_threads(&dc, ExceptionParam);
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);
+ mdDir.Location.DataSize = dump_modules(&dc, FALSE);
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);
+ mdDir.Location.DataSize = dump_modules(&dc, TRUE);
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);
+ mdDir.Location.DataSize = dump_memory_info(&dc);
writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir),
&mdDir, sizeof(mdDir));
mdDir.StreamType = MiscInfoStream;
mdDir.Location.Rva = dc.rva;
- dump_misc_info(&dc, &mdDir.Location.DataSize);
- writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir),
- &mdDir, sizeof(mdDir));
-
- mdDir.StreamType = SystemInfoStream;
- mdDir.Location.Rva = dc.rva;
- dump_system_info(&dc, &mdDir.Location.DataSize);
+ mdDir.Location.DataSize = dump_misc_info(&dc);
writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir),
&mdDir, sizeof(mdDir));
{
mdDir.StreamType = ExceptionStream;
mdDir.Location.Rva = dc.rva;
- dump_exception_info(&dc, ExceptionParam, &mdDir.Location.DataSize);
+ mdDir.Location.DataSize = dump_exception_info(&dc, ExceptionParam);
writeat(&dc, mdHead.StreamDirectoryRva + idx_stream++ * sizeof(mdDir),
&mdDir, sizeof(mdDir));
}
}
}
+ /* fill the remaining directory entries with 0's (unused stream types) */
+ /* NOTE: this should always come last in the dump! */
+ for (i = idx_stream; i < nStreams; i++)
+ writeat(&dc, mdHead.StreamDirectoryRva + i * sizeof(emptyDir), &emptyDir, sizeof(emptyDir));
+
HeapFree(GetProcessHeap(), 0, dc.pcs_buffer);
HeapFree(GetProcessHeap(), 0, dc.mem);
- HeapFree(GetProcessHeap(), 0, dc.module);
+ HeapFree(GetProcessHeap(), 0, dc.modules);
return TRUE;
}
idslW64.CheckSum = pair->effective->module.CheckSum;
idslW64.TimeDateStamp = pair->effective->module.TimeDateStamp;
memcpy(idslW64.FileName, pair->effective->module.ImageName,
- sizeof(idslW64.FileName));
+ sizeof(pair->effective->module.ImageName));
idslW64.Reparse = FALSE;
idslW64.hFile = INVALID_HANDLE_VALUE;
if (wModuleName)
module_set_module(module, wModuleName);
lstrcpynW(module->module.ImageName, wImageName,
- sizeof(module->module.ImageName) / sizeof(CHAR));
+ sizeof(module->module.ImageName) / sizeof(WCHAR));
return module->module.BaseOfImage;
}
IMAGEHLP_MODULE64 mi64;
IMAGEHLP_MODULEW64 miw64;
- if (sizeof(mi64) < ModuleInfo->SizeOfStruct) FIXME("Wrong size\n");
+ if (sizeof(mi64) < ModuleInfo->SizeOfStruct)
+ {
+ SetLastError(ERROR_MOD_NOT_FOUND); /* NOTE: native returns this error */
+ WARN("Wrong size %u\n", ModuleInfo->SizeOfStruct);
+ return FALSE;
+ }
miw64.SizeOfStruct = sizeof(miw64);
if (!SymGetModuleInfoW64(hProcess, dwAddr, &miw64)) return FALSE;
* Add symbol size to internal symbol table.
*/
+#define NONAMELESSUNION
+
#include "config.h"
#include "wine/port.h"
cv_basic_types[T_USHORT] = &symt_new_basic(module, btUInt, "unsigned short", 2)->symt;
cv_basic_types[T_ULONG] = &symt_new_basic(module, btUInt, "unsigned long", 4)->symt;
cv_basic_types[T_UQUAD] = &symt_new_basic(module, btUInt, "unsigned long long", 8)->symt;
+ cv_basic_types[T_BOOL08] = &symt_new_basic(module, btBool, "BOOL08", 1)->symt;
+ cv_basic_types[T_BOOL16] = &symt_new_basic(module, btBool, "BOOL16", 2)->symt;
+ cv_basic_types[T_BOOL32] = &symt_new_basic(module, btBool, "BOOL32", 4)->symt;
+ cv_basic_types[T_BOOL64] = &symt_new_basic(module, btBool, "BOOL64", 8)->symt;
cv_basic_types[T_REAL32] = &symt_new_basic(module, btFloat, "float", 4)->symt;
cv_basic_types[T_REAL64] = &symt_new_basic(module, btFloat, "double", 8)->symt;
cv_basic_types[T_RCHAR] = &symt_new_basic(module, btInt, "signed char", 1)->symt;
cv_basic_types[T_WCHAR] = &symt_new_basic(module, btWChar, "wchar_t", 2)->symt;
+ cv_basic_types[T_INT2] = &symt_new_basic(module, btInt, "INT2", 2)->symt;
+ cv_basic_types[T_UINT2] = &symt_new_basic(module, btUInt, "UINT2", 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_INT8] = &symt_new_basic(module, btInt, "INT8", 8)->symt;
+ cv_basic_types[T_UINT8] = &symt_new_basic(module, btUInt, "UINT8", 8)->symt;
+ cv_basic_types[T_HRESULT]= &symt_new_basic(module, btUInt, "HRESULT", 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_32PUSHORT] = &symt_new_pointer(module, cv_basic_types[T_USHORT])->symt;
cv_basic_types[T_32PULONG] = &symt_new_pointer(module, cv_basic_types[T_ULONG])->symt;
cv_basic_types[T_32PUQUAD] = &symt_new_pointer(module, cv_basic_types[T_UQUAD])->symt;
+ cv_basic_types[T_32PBOOL08] = &symt_new_pointer(module, cv_basic_types[T_BOOL08])->symt;
+ cv_basic_types[T_32PBOOL16] = &symt_new_pointer(module, cv_basic_types[T_BOOL16])->symt;
+ cv_basic_types[T_32PBOOL32] = &symt_new_pointer(module, cv_basic_types[T_BOOL32])->symt;
+ cv_basic_types[T_32PBOOL64] = &symt_new_pointer(module, cv_basic_types[T_BOOL64])->symt;
cv_basic_types[T_32PREAL32] = &symt_new_pointer(module, cv_basic_types[T_REAL32])->symt;
cv_basic_types[T_32PREAL64] = &symt_new_pointer(module, cv_basic_types[T_REAL64])->symt;
cv_basic_types[T_32PRCHAR] = &symt_new_pointer(module, cv_basic_types[T_RCHAR])->symt;
cv_basic_types[T_32PWCHAR] = &symt_new_pointer(module, cv_basic_types[T_WCHAR])->symt;
+ cv_basic_types[T_32PINT2] = &symt_new_pointer(module, cv_basic_types[T_INT2])->symt;
+ cv_basic_types[T_32PUINT2] = &symt_new_pointer(module, cv_basic_types[T_UINT2])->symt;
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;
+ cv_basic_types[T_32PINT8] = &symt_new_pointer(module, cv_basic_types[T_INT8])->symt;
+ cv_basic_types[T_32PUINT8] = &symt_new_pointer(module, cv_basic_types[T_UINT8])->symt;
+ cv_basic_types[T_32PHRESULT]= &symt_new_pointer(module, cv_basic_types[T_HRESULT])->symt;
}
static int numeric_leaf(int* value, const unsigned short int* leaf)
}
static struct symt* codeview_fetch_type(struct codeview_type_parse* ctp,
- unsigned typeno)
+ unsigned typeno, BOOL details)
{
struct symt* symt;
const union codeview_type* p;
FIXME("Cannot locate type %x\n", typeno);
return NULL;
}
- symt = codeview_parse_one_type(ctp, typeno, p, FALSE);
+ symt = codeview_parse_one_type(ctp, typeno, p, details);
if (!symt) FIXME("Couldn't load forward type %x\n", typeno);
return symt;
}
existing = codeview_cast_symt(existing, SymTagPointerType);
return existing;
}
- pointee = codeview_fetch_type(ctp, pointee_type);
+ pointee = codeview_fetch_type(ctp, pointee_type, FALSE);
return &symt_new_pointer(ctp->module, pointee)->symt;
}
unsigned int indextype,
unsigned int arr_len)
{
- struct symt* elem = codeview_fetch_type(ctp, elemtype);
- struct symt* index = codeview_fetch_type(ctp, indextype);
+ struct symt* elem = codeview_fetch_type(ctp, elemtype, FALSE);
+ struct symt* index = codeview_fetch_type(ctp, indextype, FALSE);
DWORD arr_max = 0;
if (elem)
{
case LF_BITFIELD_V1:
symt_add_udt_element(ctp->module, symt, name,
- codeview_fetch_type(ctp, cv_type->bitfield_v1.type),
+ codeview_fetch_type(ctp, cv_type->bitfield_v1.type, FALSE),
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),
+ codeview_fetch_type(ctp, cv_type->bitfield_v2.type, FALSE),
cv_type->bitfield_v2.bitoff,
cv_type->bitfield_v2.nbits);
return;
}
}
- subtype = codeview_fetch_type(ctp, type);
+ subtype = codeview_fetch_type(ctp, type, FALSE);
if (subtype)
{
ptr += 2 + 4 + 2 + (1 + type->stmember_v2.p_name.namelen);
break;
+ case LF_STMEMBER_V3:
+ /* FIXME: ignored for now */
+ ptr += 2 + 4 + 2 + (strlen(type->stmember_v3.name) + 1);
+ break;
+
case LF_METHOD_V1:
/* FIXME: ignored for now */
ptr += 2 + 2 + 2 + (1 + type->method_v1.p_name.namelen);
ptr += 2 + 2 + 4 + (1 + type->method_v2.p_name.namelen);
break;
+ case LF_METHOD_V3:
+ /* FIXME: ignored for now */
+ ptr += 2 + 2 + 4 + (strlen(type->method_v3.name) + 1);
+ break;
+
case LF_NESTTYPE_V1:
/* FIXME: ignored for now */
ptr += 2 + 2 + (1 + type->nesttype_v1.p_name.namelen);
ptr += 2 + 2 + 4 + (1 + type->nesttype_v2.p_name.namelen);
break;
+ case LF_NESTTYPE_V3:
+ /* FIXME: ignored for now */
+ ptr += 2 + 2 + 4 + (strlen(type->nesttype_v3.name) + 1);
+ break;
+
case LF_VFUNCTAB_V1:
/* FIXME: ignored for now */
ptr += 2 + 2;
}
break;
+ case LF_ONEMETHOD_V3:
+ /* FIXME: ignored for now */
+ switch ((type->onemethod_v3.attribute >> 2) & 7)
+ {
+ case 4: case 6: /* (pure) introducing virtual method */
+ ptr += 2 + 2 + 4 + 4 + (strlen(type->onemethod_virt_v3.name) + 1);
+ break;
+
+ default:
+ ptr += 2 + 2 + 4 + (strlen(type->onemethod_v3.name) + 1);
+ break;
+ }
+ break;
+
default:
FIXME("Unsupported type %04x in STRUCT field list\n", type->generic.id);
return FALSE;
static struct symt* codeview_add_type_enum(struct codeview_type_parse* ctp,
struct symt* existing,
const char* name,
- unsigned fieldlistno)
+ unsigned fieldlistno,
+ unsigned basetype)
{
struct symt_enum* symt;
}
else
{
- symt = symt_new_enum(ctp->module, name);
+ symt = symt_new_enum(ctp->module, name,
+ codeview_fetch_type(ctp, basetype, FALSE));
if (fieldlistno)
{
const union codeview_reftype* fieldlist;
{
const union codeview_reftype* reftype;
- sym->rettype = codeview_fetch_type(ctp, ret_type);
+ sym->rettype = codeview_fetch_type(ctp, ret_type, FALSE);
if (args_list && (reftype = codeview_jump_to_type(ctp, args_list)))
{
int i;
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]));
+ codeview_fetch_type(ctp, reftype->arglist_v1.args[i], FALSE));
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]));
+ codeview_fetch_type(ctp, reftype->arglist_v2.args[i], FALSE));
break;
default:
FIXME("Unexpected leaf %x for signature's pmt\n", reftype->generic.id);
switch (type->generic.id)
{
case LF_MODIFIER_V1:
- /* FIXME: we don't handle modifiers,
- * but readd previous type on the curr_type
+ /* FIXME: we don't handle modifiers,
+ * but read previous type on the curr_type
*/
WARN("Modifier on %x: %s%s%s%s\n",
type->modifier_v1.type,
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);
+ symt = codeview_fetch_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 */
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);
+ symt = codeview_fetch_type(ctp, type->modifier_v2.type, details);
break;
case LF_POINTER_V1:
case LF_ENUM_V1:
symt = codeview_add_type_enum(ctp, existing,
terminate_string(&type->enumeration_v1.p_name),
- type->enumeration_v1.fieldlist);
+ type->enumeration_v1.fieldlist,
+ type->enumeration_v1.type);
break;
case LF_ENUM_V2:
symt = codeview_add_type_enum(ctp, existing,
terminate_string(&type->enumeration_v2.p_name),
- type->enumeration_v2.fieldlist);
+ type->enumeration_v2.fieldlist,
+ type->enumeration_v2.type);
break;
case LF_ENUM_V3:
symt = codeview_add_type_enum(ctp, existing, type->enumeration_v3.name,
- type->enumeration_v3.fieldlist);
+ type->enumeration_v3.fieldlist,
+ type->enumeration_v3.type);
break;
case LF_PROCEDURE_V1:
* 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);
+ if (!(type->generic.id & 0x8600) || (type->generic.id & 0x0100))
+ codeview_parse_one_type(ctp, curr_type, type, TRUE);
}
return TRUE;
const union codeview_symbol* sym = (const union codeview_symbol*)(root + i);
length = sym->generic.len + 2;
if (i + length > size) break;
+ if (!sym->generic.id || length < 4) break;
if (length & 3) FIXME("unpadded len %u\n", length);
switch (sym->generic.id)
codeview_get_type(sym->stack_v3.symtype, FALSE),
sym->stack_v3.name);
break;
+ case S_BPREL_XXXX_V3:
+ loc.kind = loc_regrel;
+ loc.reg = 0; /* FIXME */
+ loc.offset = sym->stack_xxxx_v3.offset;
+ WARN("Supposed stack variable %s (%d)\n", sym->stack_xxxx_v3.name, sym->stack_xxxx_v3.unknown);
+ symt_add_func_local(msc_dbg->module, curr_func,
+ sym->stack_xxxx_v3.offset > 0 ? DataIsParam : DataIsLocal,
+ &loc, block,
+ codeview_get_type(sym->stack_xxxx_v3.symtype, FALSE),
+ sym->stack_xxxx_v3.name);
+ break;
case S_REGISTER_V1:
loc.kind = loc_register;
block, codeview_get_type(sym->register_v2.type, FALSE),
terminate_string(&sym->register_v2.p_name));
break;
+ case S_REGISTER_V3:
+ loc.kind = loc_register;
+ loc.reg = sym->register_v3.reg;
+ loc.offset = 0;
+ symt_add_func_local(msc_dbg->module, curr_func,
+ DataIsLocal, &loc,
+ block, codeview_get_type(sym->register_v3.type, FALSE),
+ sym->register_v3.name);
+ break;
case S_BLOCK_V1:
block = symt_open_func_block(msc_dbg->module, curr_func, block,
while (*ptr1)
{
ptr2 = ptr1 + strlen(ptr1) + 1;
- TRACE("\t%s => %s\n", ptr1, ptr2);
+ TRACE("\t%s => %s\n", ptr1, debugstr_a(ptr2));
ptr1 = ptr2 + strlen(ptr2) + 1;
}
}
while (*ptr1)
{
ptr2 = ptr1 + strlen(ptr1) + 1;
- TRACE("\t%s => %s\n", ptr1, ptr2);
+ TRACE("\t%s => %s\n", ptr1, debugstr_a(ptr2));
ptr1 = ptr2 + strlen(ptr2) + 1;
}
}
symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel, &loc,
terminate_string(&sym->label_v1.p_name));
}
- else
- FIXME("No current function for label %s\n",
- terminate_string(&sym->label_v1.p_name));
+ else symt_new_label(msc_dbg->module, compiland,
+ terminate_string(&sym->label_v1.p_name),
+ codeview_get_address(msc_dbg, sym->label_v1.segment, sym->label_v1.offset));
break;
case S_LABEL_V3:
if (curr_func)
symt_add_function_point(msc_dbg->module, curr_func, SymTagLabel,
&loc, sym->label_v3.name);
}
- else
- FIXME("No current function for label %s\n", sym->label_v3.name);
+ else symt_new_label(msc_dbg->module, compiland, sym->label_v3.name,
+ codeview_get_address(msc_dbg, sym->label_v3.segment, sym->label_v3.offset));
break;
case S_CONSTANT_V1:
break;
case S_PUB_FUNC1_V3:
case S_PUB_FUNC2_V3: /* using a data_v3 isn't what we'd expect */
+#if 0
+ /* FIXME: this is plain wrong (from a simple test) */
if (!(dbghelp_options & SYMOPT_NO_PUBLICS))
{
symt_new_public(msc_dbg->module, compiland,
codeview_get_address(msc_dbg, sym->data_v3.segment, sym->data_v3.offset),
1, TRUE /* FIXME */, TRUE);
}
+#endif
break;
case S_MSTOOL_V3: /* just to silence a few warnings */
{
HANDLE h;
- h = CreateFileA(DebugFilePath, GENERIC_READ, FILE_SHARE_READ, NULL,
+ h = CreateFileA(FileName, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE)
{
PVOID CallerData)
{
FIXME("(%s %s %p %p %p): stub\n",
- FileName, SymbolPath, DebugFilePath, Callback, CallerData);
+ debugstr_a(FileName), debugstr_a(SymbolPath), debugstr_a(DebugFilePath), Callback, CallerData);
return NULL;
}
PCSTR fptr;
PCSTR mptr;
- TRACE("(%s %s %p %p)\n", file, match, filestop, matchstop);
+ TRACE("(%s %s %p %p)\n", debugstr_a(file), debugstr_a(match), filestop, matchstop);
fptr = file + strlen(file) - 1;
mptr = match + strlen(match) - 1;
BOOL found = FALSE;
static const WCHAR S_AllW[] = {'*','.','*','\0'};
static const WCHAR S_DotW[] = {'.','\0'};
- static const WCHAR S_DotDotW[] = {'.','\0'};
+ static const WCHAR S_DotDotW[] = {'.','.','\0'};
pos = strlenW(buffer);
if (buffer[pos - 1] != '\\') buffer[pos++] = '\\';
WCHAR* ptr;
const WCHAR* filename;
- TRACE("(%p %s %s %p %08x %08x %08x %p %p %p)\n",
+ TRACE("(hProcess = %p, searchPath = %s, full_path = %s, id = %p, two = 0x%08x, three = 0x%08x, flags = 0x%08x, buffer = %p, cb = %p, user = %p)\n",
hProcess, debugstr_w(searchPath), debugstr_w(full_path),
id, two, three, flags, buffer, cb, user);
*/
#include "config.h"
+#include "wine/port.h"
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
* its debugging information)
*/
static BOOL pe_load_stabs(const struct process* pcs, struct module* module,
- const void* mapping, IMAGE_NT_HEADERS* nth)
+ void* mapping, IMAGE_NT_HEADERS* nth)
{
IMAGE_SECTION_HEADER* section;
int i, stabsize = 0, stabstrsize = 0;
{
ret = stabs_parse(module,
module->module.BaseOfImage - nth->OptionalHeader.ImageBase,
- RtlImageRvaToVa(nth, (void*)mapping, stabs, NULL),
+ RtlImageRvaToVa(nth, mapping, stabs, NULL),
stabsize,
- RtlImageRvaToVa(nth, (void*)mapping, stabstr, NULL),
+ RtlImageRvaToVa(nth, mapping, stabstr, NULL),
stabstrsize);
}
+
+ TRACE("%s the STABS debug info\n", ret ? "successfully loaded" : "failed to load");
return ret;
}
const IMAGE_DEBUG_DIRECTORY* dbg;
BOOL ret = FALSE;
- WINE_TRACE("Processing DBG file %s\n", dbg_name);
+ WINE_TRACE("Processing DBG file %s\n", debugstr_a(dbg_name));
if (SymFindFileInPath(pcs->handle, NULL, dbg_name, NULL, 0, 0, 0, tmp, dbg_match, NULL) &&
(hFile = CreateFileA(tmp, GENERIC_READ, FILE_SHARE_READ, NULL,
if (hdr->TimeDateStamp != timestamp)
{
WINE_ERR("Warning - %s has incorrect internal timestamp\n",
- dbg_name);
+ debugstr_a(dbg_name));
/*
* Well, sometimes this happens to DBG files which ARE REALLY the
* right .DBG files but nonetheless this check fails. Anyway,
ERR("Wrong signature in .DBG file %s\n", debugstr_a(tmp));
}
else
- WINE_ERR("-Unable to peruse .DBG file %s (%s)\n", dbg_name, debugstr_a(tmp));
+ WINE_ERR("-Unable to peruse .DBG file %s (%s)\n", debugstr_a(dbg_name), debugstr_a(tmp));
if (dbg_mapping) UnmapViewOfFile(dbg_mapping);
if (hMap) CloseHandle(hMap);
*/
static BOOL pe_load_msc_debug_info(const struct process* pcs,
struct module* module,
- const void* mapping, IMAGE_NT_HEADERS* nth)
+ void* mapping, IMAGE_NT_HEADERS* nth)
{
BOOL ret = FALSE;
const IMAGE_DATA_DIRECTORY* dir;
nDbg = dir->Size / sizeof(IMAGE_DEBUG_DIRECTORY);
if (!nDbg) return FALSE;
- dbg = RtlImageRvaToVa(nth, (void*)mapping, dir->VirtualAddress, NULL);
+ dbg = RtlImageRvaToVa(nth, mapping, dir->VirtualAddress, NULL);
/* Parse debug directory */
if (nth->FileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED)
*/
static BOOL pe_load_export_debug_info(const struct process* pcs,
struct module* module,
- const void* mapping, IMAGE_NT_HEADERS* nth)
+ void* mapping, IMAGE_NT_HEADERS* nth)
{
unsigned int i;
const IMAGE_EXPORT_DIRECTORY* exports;
for (i = 0; i < nth->FileHeader.NumberOfSections; i++, section++)
{
symt_new_public(module, NULL, section->Name,
- RtlImageRvaToVa(nth, (void*)mapping, section->VirtualAddress, NULL),
+ RtlImageRvaToVa(nth, mapping, section->VirtualAddress, NULL),
1, TRUE /* FIXME */, TRUE /* FIXME */);
}
#endif
/* Add exported functions */
- if ((exports = RtlImageDirectoryEntryToData((void*)mapping, FALSE,
+ if ((exports = RtlImageDirectoryEntryToData(mapping, FALSE,
IMAGE_DIRECTORY_ENTRY_EXPORT, &size)))
{
const WORD* ordinals = NULL;
unsigned int j;
char buffer[16];
- functions = RtlImageRvaToVa(nth, (void*)mapping, exports->AddressOfFunctions, NULL);
- ordinals = RtlImageRvaToVa(nth, (void*)mapping, exports->AddressOfNameOrdinals, NULL);
- names = RtlImageRvaToVa(nth, (void*)mapping, exports->AddressOfNames, NULL);
+ functions = RtlImageRvaToVa(nth, mapping, exports->AddressOfFunctions, NULL);
+ ordinals = RtlImageRvaToVa(nth, mapping, exports->AddressOfNameOrdinals, NULL);
+ names = RtlImageRvaToVa(nth, mapping, exports->AddressOfNames, NULL);
if (functions && ordinals && names)
{
{
if (!names[i]) continue;
symt_new_public(module, NULL,
- RtlImageRvaToVa(nth, (void*)mapping, names[i], NULL),
+ RtlImageRvaToVa(nth, mapping, names[i], NULL),
base + functions[ordinals[i]],
1, TRUE /* FIXME */, TRUE /* FIXME */);
}
else
pe_load_debug_info(pcs, module);
}
+ else
+ ERR("could not load the module '%s'\n", debugstr_w(loaded_name));
}
UnmapViewOfFile(mapping);
}
}
return module;
}
+
+/***********************************************************************
+ * ImageDirectoryEntryToDataEx (DBGHELP.@)
+ *
+ * Search for specified directory in PE image
+ *
+ * PARAMS
+ *
+ * base [in] Image base address
+ * image [in] TRUE - image has been loaded by loader, FALSE - raw file image
+ * dir [in] Target directory index
+ * size [out] Receives directory size
+ * section [out] Receives pointer to section header of section containing directory data
+ *
+ * RETURNS
+ * Success: pointer to directory data
+ * Failure: NULL
+ *
+ */
+PVOID WINAPI ImageDirectoryEntryToDataEx( PVOID base, BOOLEAN image, USHORT dir, PULONG size, PIMAGE_SECTION_HEADER *section )
+{
+ const IMAGE_NT_HEADERS *nt;
+ DWORD addr;
+
+ *size = 0;
+ if (section) *section = NULL;
+
+ if (!(nt = RtlImageNtHeader( base ))) return NULL;
+ if (dir >= nt->OptionalHeader.NumberOfRvaAndSizes) return NULL;
+ if (!(addr = nt->OptionalHeader.DataDirectory[dir].VirtualAddress)) return NULL;
+
+ *size = nt->OptionalHeader.DataDirectory[dir].Size;
+ if (image || addr < nt->OptionalHeader.SizeOfHeaders) return (char *)base + addr;
+
+ return RtlImageRvaToVa( nt, (HMODULE)base, addr, section );
+}
+
+/***********************************************************************
+ * ImageDirectoryEntryToData (DBGHELP.@)
+ *
+ * NOTES
+ * See ImageDirectoryEntryToDataEx
+ */
+PVOID WINAPI ImageDirectoryEntryToData( PVOID base, BOOLEAN image, USHORT dir, PULONG size )
+{
+ return ImageDirectoryEntryToDataEx( base, image, dir, size, NULL );
+}
*/
#include "config.h"
+#include "wine/port.h"
#include <sys/types.h>
#include <fcntl.h>
PTS_ABORTIF(ptd, *ptd->ptr++ != ';'); /* ';' */
/* basically, we don't use ref... in some cases, for example, float is declared
- * as a derivated type of int... which won't help us... so we guess the types
+ * as a derived type of int... which won't help us... so we guess the types
* from the various formats
*/
if (lo.sign == 0 && hi.sign < 0)
struct symt** ret_dt)
{
int idx;
- long sz = -1;
- struct symt* new_dt = NULL; /* newly created data type */
- struct symt* ref_dt; /* referenced data type (pointer...) */
+ long sz = -1;
+ struct symt* new_dt = NULL; /* newly created data type */
+ struct symt* ref_dt; /* referenced data type (pointer...) */
long filenr1, subnr1, tmp;
/* things are a bit complicated because of the way the typedefs are stored inside
while (*ptd->ptr == '=')
{
ptd->ptr++;
- PTS_ABORTIF(ptd, new_dt != btNoType);
+ PTS_ABORTIF(ptd, new_dt != NULL);
/* first handle attribute if any */
switch (*ptd->ptr)
new_dt = &symt_new_function_signature(ptd->module, ref_dt, -1)->symt;
break;
case 'e':
- new_dt = &symt_new_enum(ptd->module, typename)->symt;
+ stabs_get_basic(ptd, 1 /* int */, &ref_dt);
+ new_dt = &symt_new_enum(ptd->module, typename, ref_dt)->symt;
PTS_ABORTIF(ptd, stabs_pts_read_enum(ptd, (struct symt_enum*)new_dt) == -1);
break;
case 's':
switch (tmp)
{
case 'e':
- new_dt = &symt_new_enum(ptd->module, ptd->buf + idx)->symt;
+ stabs_get_basic(ptd, 1 /* int */, &ref_dt);
+ new_dt = &symt_new_enum(ptd->module, ptd->buf + idx, ref_dt)->symt;
break;
case 's':
new_dt = &symt_new_udt(ptd->module, ptd->buf + idx, 0, UdtStruct)->symt;
*stabs_find_ref(filenr1, subnr1) = *ret_dt = new_dt;
- TRACE("Adding (%ld,%ld) %s\n", filenr1, subnr1, typename);
+ TRACE("Adding (%ld,%ld) %s\n", filenr1, subnr1, debugstr_a(typename));
return 0;
}
* 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 absolute 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,
+++ /dev/null
-/*
- * 16-bit and 32-bit mode stack frame layout
- *
- * Copyright 1995, 1998 Alexandre Julliard
- *
- * 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
- */
-
-#ifndef __WINE_STACKFRAME_H
-#define __WINE_STACKFRAME_H
-
-#include <string.h>
-#define NTOS_MODE_USER
-#include <ndk/umtypes.h>
-#include <ndk/extypes.h>
-#include <ndk/rtlfuncs.h>
-
-#define SELECTOROF(ptr) (HIWORD(ptr))
-#define OFFSETOF(ptr) (LOWORD(ptr))
-
-#include <pshpack1.h>
-
- /* 32-bit stack layout after CallTo16() */
-typedef struct _STACK32FRAME
-{
- DWORD restore_addr; /* 00 return address for restoring code selector */
- DWORD codeselector; /* 04 code selector to restore */
- EXCEPTION_REGISTRATION_RECORD frame; /* 08 Exception frame */
- SEGPTR frame16; /* 10 16-bit frame from last CallFrom16() */
- DWORD edi; /* 14 saved registers */
- DWORD esi; /* 18 */
- DWORD ebx; /* 1c */
- DWORD ebp; /* 20 saved 32-bit frame pointer */
- DWORD retaddr; /* 24 return address */
- DWORD target; /* 28 target address / CONTEXT86 pointer */
- DWORD nb_args; /* 2c number of 16-bit argument bytes */
-} STACK32FRAME;
-
- /* 16-bit stack layout after CallFrom16() */
-typedef struct _STACK16FRAME
-{
- STACK32FRAME *frame32; /* 00 32-bit frame from last CallTo16() */
- DWORD edx; /* 04 saved registers */
- DWORD ecx; /* 08 */
- DWORD ebp; /* 0c */
- WORD ds; /* 10 */
- WORD es; /* 12 */
- WORD fs; /* 14 */
- WORD gs; /* 16 */
- DWORD callfrom_ip; /* 18 callfrom tail IP */
- DWORD module_cs; /* 1c module code segment */
- DWORD relay; /* 20 relay function address */
- WORD entry_ip; /* 22 entry point IP */
- DWORD entry_point; /* 26 API entry point to call, reused as mutex count */
- WORD bp; /* 2a 16-bit stack frame chain */
- WORD ip; /* 2c return address */
- WORD cs; /* 2e */
-} STACK16FRAME;
-
-#include <poppack.h>
-
-static __inline int MapSL(int size)
-{
- return -1;
-}
-
-#define CURRENT_STACK16 ((STACK16FRAME*)MapSL(NtCurrentTeb()->cur_stack))
-#define CURRENT_DS (CURRENT_STACK16->ds)
-
-
-#endif /* __WINE_STACKFRAME_H */
+++ /dev/null
-/*
- * File stubs.c - stubs for exported functions
- *
- * Copyright (C) 2007, Timo Kreuzer
- *
- * 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
- */
-
-#define WIN32_NO_STATUS
-#include <windows.h>
-#include <ndk/ntndk.h>
-
-#include "dbghelp_private.h"
-
-#define UNIMPLEMENTED DbgPrint("DBGHELP: %s is unimplemented, please try again later.\n", __FUNCTION__);
-
-BOOL WINAPI
-DbgHelpCreateUserDump(LPSTR pszFileName,
- PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
- PVOID pUserData)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-DbgHelpCreateUserDumpW(LPWSTR pszFileName,
- PDBGHELP_CREATE_USER_DUMP_CALLBACK Callback,
- PVOID pUserData)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-FindFileInPath(HANDLE hProcess,
- LPSTR pszSearchPath,
- LPSTR pszFileName,
- PVOID id,
- DWORD two,
- DWORD three,
- DWORD dwFlags,
- LPSTR pszFilePath)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-FindFileInSearchPath(HANDLE hProcess,
- LPSTR pszSearchPath,
- LPSTR pszFileName,
- DWORD one,
- DWORD two,
- DWORD three,
- LPSTR pszFilePath)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-PVOID WINAPI
-ImageDirectoryEntryToDataEx(PVOID pModuleBase,
- BOOLEAN bMappedAsImage,
- USHORT DirectoryEntry,
- PULONG pulSize,
- PIMAGE_SECTION_HEADER *FoundHeader)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-BOOL WINAPI
-SymAddSymbol(HANDLE hProcess,
- ULONG64 ModBase,
- PCSTR pszName,
- DWORD64 Address,
- DWORD dwSize,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymAddSymbolW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszName,
- DWORD64 Address,
- DWORD dwSize,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymDeleteSymbol(HANDLE hProcess,
- ULONG64 ModBase,
- PCSTR pszName,
- DWORD64 Address,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymDeleteSymbolW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszName,
- DWORD64 Address,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumLinesW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszObj,
- PCWSTR pszFile,
- PSYM_ENUMLINES_CALLBACKW Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL SymEnumProcesses(PSYM_ENUMPROCESSES_CALLBACK Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSourceFilesW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszMask,
- PSYM_ENUMSOURCEFILES_CALLBACKW Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSourceLines(HANDLE hProcess,
- ULONG64 ModBase,
- PCSTR pszObject,
- PCSTR pszFile,
- DWORD dwLine,
- DWORD dwFlags,
- PSYM_ENUMLINES_CALLBACK Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSourceLinesW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszObject,
- PCWSTR pszFile,
- DWORD dwLine,
- DWORD dwFlags,
- PSYM_ENUMLINES_CALLBACKW Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSym(HANDLE hProcess,
- ULONG64 ModBase,
- PSYM_ENUMERATESYMBOLS_CALLBACK Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSymbolsForAddr(HANDLE hProcess,
- DWORD64 Address,
- PSYM_ENUMERATESYMBOLS_CALLBACK Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumSymbolsForAddrW(HANDLE hProcess,
- DWORD64 Address,
- PSYM_ENUMERATESYMBOLS_CALLBACKW Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumerateSymbols64(HANDLE hProcess,
- DWORD64 ModBase,
- PSYM_ENUMSYMBOLS_CALLBACK64 Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumerateSymbolsW64(HANDLE hProcess,
- DWORD64 ModBase,
- PSYM_ENUMSYMBOLS_CALLBACK64W Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymEnumerateSymbolsW(HANDLE hProcess,
- DWORD ModBase,
- PSYM_ENUMSYMBOLS_CALLBACKW Callback,
- PVOID pUserContext)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymFromIndex(HANDLE hProcess,
- ULONG64 ModBase,
- DWORD Index,
- PSYMBOL_INFO Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymFromIndexW(HANDLE hProcess,
- ULONG64 ModBase,
- DWORD Index,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymFromNameW(HANDLE hProcess,
- PCWSTR pszName,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymFromToken(HANDLE hProcess,
- DWORD64 ModBase,
- DWORD Token,
- PSYMBOL_INFO Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymFromTokenW(HANDLE hProcess,
- DWORD64 ModBase,
- DWORD Token,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetFileLineOffsets64(HANDLE hProcess,
- PSTR pszModuleName,
- PSTR pszFileName,
- PDWORD64 pBuffer,
- ULONG BufferLines)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-PCHAR WINAPI
-SymGetHomeDirectory(DWORD dwType,
- PSTR pszDir,
- size_t Size)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PWCHAR WINAPI
-SymGetHomeDirectoryW(DWORD dwType,
- PWSTR pszDir,
- size_t Size)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-BOOL WINAPI
-SymGetLineFromName64(HANDLE hProcess,
- PCSTR pszModuleName,
- PCSTR pszFileName,
- DWORD dwLineNumber,
- PLONG plDisplacement,
- PIMAGEHLP_LINE64 Line)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetLineFromName(HANDLE hProcess,
- PCSTR pszModuleName,
- PCSTR pszFileName,
- DWORD dwLineNumber,
- PLONG plDisplacement,
- PIMAGEHLP_LINE Line)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetLineFromNameW64(HANDLE hProcess,
- PCWSTR pszModuleName,
- PCWSTR pszFileName,
- DWORD dwLineNumber,
- PLONG lpDisplacement,
- PIMAGEHLP_LINEW64 Line)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetLineNextW64(HANDLE hProcess,
- PIMAGEHLP_LINEW64 Line)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetLinePrevW64(HANDLE hProcess,
- PIMAGEHLP_LINEW64 Line)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetScope(HANDLE hProcess,
- ULONG64 ModBase,
- DWORD Index,
- PSYMBOL_INFO Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetScopeW(HANDLE hProcess,
- ULONG64 ModBase,
- DWORD Index,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSourceFile(HANDLE hProcess,
- ULONG64 ModBase,
- PCSTR pszParams,
- PCSTR pszFileSpec,
- PSTR pszFilePath,
- DWORD Size)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSourceFileFromToken(HANDLE hProcess,
- PVOID Token,
- PCSTR pszParams,
- PSTR pszFilePath,
- DWORD Size)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-
-BOOL WINAPI
-SymGetSourceFileFromTokenW(HANDLE hProcess,
- PVOID Token,
- PCWSTR pszParams,
- PWSTR pszFilePath,
- DWORD Size)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-// SymGetSourceFileW
-// SymGetSourceVarFromToken
-// SymGetSourceVarFromTokenW
-
-BOOL WINAPI
-SymGetSymFromName64(HANDLE hProcess,
- PCSTR pszName,
- PIMAGEHLP_SYMBOL64 Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSymNext64(HANDLE hProcess,
- PIMAGEHLP_SYMBOL64 Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSymPrev64(HANDLE hProcess,
- PIMAGEHLP_SYMBOL64 Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSymbolFile(HANDLE hProcess,
- PCSTR pszSymPath,
- PCSTR pszImageFile,
- DWORD Type,
- PSTR SymbolFile,
- size_t cSymbolFile,
- PSTR DbgFile,
- size_t cDbgFile)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetSymbolFileW(HANDLE hProcess,
- PCWSTR pszSymPath,
- PCWSTR pszImageFile,
- DWORD Type,
- PWSTR pszSymbolFile,
- size_t cSymbolFile,
- PWSTR pszDbgFile,
- size_t cDbgFile)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetTypeFromNameW(HANDLE hProcess,
- ULONG64 ModBase,
- PCWSTR pszName,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymGetTypeInfoEx(HANDLE hProcess,
- DWORD64 ModBase,
- PIMAGEHLP_GET_TYPE_INFO_PARAMS Params)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymMatchStringA(PCSTR pszString,
- PCSTR pszExpression,
- BOOL bCaseSensitiv)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymMatchStringW(PCWSTR pszString,
- PCWSTR pszExpression,
- BOOL bCaseSensitiv)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymNext(HANDLE hProcess,
- PSYMBOL_INFO Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymNextW(HANDLE hProcess,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymPrev(HANDLE hProcess,
- PSYMBOL_INFO Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymPrevW(HANDLE hProcess,
- PSYMBOL_INFOW Symbol)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-// SymRefreshModuleList
-
-PCHAR WINAPI
-SymSetHomeDirectory(HANDLE hProcess,
- PCSTR pszDir)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PWCHAR WINAPI
-SymSetHomeDirectoryW(HANDLE hProcess,
- PCWSTR pszDir)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-// SymSetSymWithAddr64
-
-PCSTR WINAPI
-SymSrvDeltaName(HANDLE hProcess,
- PCSTR pszSymPath,
- PCSTR pszType,
- PCSTR pszFile1,
- PCSTR pszFile2)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PCWSTR WINAPI
-SymSrvDeltaNameW(HANDLE hProcess,
- PCWSTR pszSymPath,
- PCWSTR pszType,
- PCWSTR pszFile1,
- PCWSTR pszFile2)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-BOOL WINAPI
-SymSrvGetFileIndexString(HANDLE hProcess,
- PCSTR pszSrvPath,
- PCSTR pszFile,
- PSTR pszIndex,
- size_t Size,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymSrvGetFileIndexStringW(HANDLE hProcess,
- PCWSTR pszSrvPath,
- PCWSTR pszFile,
- PWSTR pszIndex,
- size_t Size,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymSrvGetFileIndexes(PCSTR File,
- GUID* Id,
- DWORD* Val1,
- DWORD* Val2,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymSrvGetFileIndexesW(PCWSTR File,
- GUID* Id,
- DWORD* Val1,
- DWORD* Val2,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-PCSTR WINAPI
-SymSrvGetSupplement(HANDLE hProcess,
- PCSTR pszSymPath,
- PCSTR pszNode,
- PCSTR pszFile)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PCWSTR WINAPI
-SymSrvGetSupplementW(HANDLE hProcess,
- PCWSTR pszSymPath,
- PCWSTR pszNode,
- PCWSTR pszFile)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-BOOL WINAPI
-SymSrvIsStore(HANDLE hProcess,
- PCSTR pszPath)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-BOOL WINAPI
-SymSrvIsStoreW(HANDLE hProcess,
- PCWSTR pszPath)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-PCSTR WINAPI
-SymSrvStoreFile(HANDLE hProcess,
- PCSTR pszSrvPath,
- PCSTR pszFile,
- DWORD pszFlags)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PCWSTR WINAPI
-SymSrvStoreFileW(HANDLE hProcess,
- PCWSTR pszSrvPath,
- PCWSTR pszFile,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PCSTR WINAPI
-SymSrvStoreSupplement(HANDLE hProcess,
- PCSTR pszSymPath,
- PCSTR pszNode,
- PCSTR pszFile,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-PCWSTR WINAPI
-SymSrvStoreSupplementW(HANDLE hProcess,
- PCWSTR pszSymPath,
- PCWSTR pszNode,
- PCWSTR pszFile,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
-BOOL WINAPI
-SymUnDName64(PIMAGEHLP_SYMBOL64 Symbol,
- PSTR pszUndecoratedName,
- DWORD dwUndecoratedNameLength)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
-
-DWORD WINAPI
-UnDecorateSymbolNameW(PCWSTR DecoratedName,
- PWSTR pszUnDecoratedName,
- DWORD dwUndecoratedLength,
- DWORD dwFlags)
-{
- UNIMPLEMENTED;
- return 0;
-}
-
-
GET_ENTRY(block->container, struct symt_block, symt) : NULL;
}
-struct symt_function_point* symt_add_function_point(struct module* module,
- struct symt_function* func,
- enum SymTagEnum point,
- const struct location* loc,
- const char* name)
+struct symt_hierarchy_point* symt_add_function_point(struct module* module,
+ struct symt_function* func,
+ enum SymTagEnum point,
+ const struct location* loc,
+ const char* name)
{
- struct symt_function_point* sym;
+ struct symt_hierarchy_point*sym;
struct symt** p;
if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
{
sym->symt.tag = point;
- sym->parent = func;
+ sym->parent = &func->symt;
sym->loc = *loc;
- sym->name = name ? pool_strdup(&module->pool, name) : NULL;
+ sym->hash_elt.name = name ? pool_strdup(&module->pool, name) : NULL;
p = vector_add(&func->vchildren, &module->pool);
*p = &sym->symt;
}
return sym;
}
+struct symt_hierarchy_point* symt_new_label(struct module* module,
+ struct symt_compiland* compiland,
+ const char* name, unsigned long address)
+{
+ struct symt_hierarchy_point* sym;
+
+ TRACE_(dbghelp_symt)("Adding global label value %s:%s\n",
+ debugstr_w(module->module.ModuleName), name);
+
+ if ((sym = pool_alloc(&module->pool, sizeof(*sym))))
+ {
+ sym->symt.tag = SymTagLabel;
+ sym->hash_elt.name = pool_strdup(&module->pool, name);
+ hash_table_add(&module->ht_symbols, &sym->hash_elt);
+ module->sortlist_valid = FALSE;
+ sym->loc.kind = loc_absolute;
+ sym->loc.offset = address;
+ sym->parent = compiland ? &compiland->symt : NULL;
+ 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_pair* pair,
const struct symt_function* func,
if (sym_info->MaxNameLen)
{
if (sym->tag != SymTagPublicSymbol || !(dbghelp_options & SYMOPT_UNDNAME) ||
- (sym_info->NameLen = UnDecorateSymbolName(name, sym_info->Name,
- sym_info->MaxNameLen, UNDNAME_COMPLETE) == 0))
+ (sym_info->NameLen = UnDecorateSymbolName(name, sym_info->Name,
+ sym_info->MaxNameLen, UNDNAME_NAME_ONLY) == 0))
{
sym_info->NameLen = min(strlen(name), sym_info->MaxNameLen - 1);
memcpy(sym_info->Name, name, sym_info->NameLen);
return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb, &se);
}
+struct sym_enumerate64
+{
+ void* ctx;
+ PSYM_ENUMSYMBOLS_CALLBACK64 cb;
+};
+
+static BOOL CALLBACK sym_enumerate_cb64(PSYMBOL_INFO syminfo, ULONG size, void* ctx)
+{
+ struct sym_enumerate64* se = (struct sym_enumerate64*)ctx;
+ return (se->cb)(syminfo->Name, syminfo->Address, syminfo->Size, se->ctx);
+}
+
+/***********************************************************************
+ * SymEnumerateSymbols64 (DBGHELP.@)
+ */
+BOOL WINAPI SymEnumerateSymbols64(HANDLE hProcess, DWORD64 BaseOfDll,
+ PSYM_ENUMSYMBOLS_CALLBACK64 EnumSymbolsCallback,
+ PVOID UserContext)
+{
+ struct sym_enumerate64 se;
+
+ se.ctx = UserContext;
+ se.cb = EnumSymbolsCallback;
+
+ return SymEnumSymbols(hProcess, BaseOfDll, NULL, sym_enumerate_cb64, &se);
+}
+
/******************************************************************
* SymFromAddr (DBGHELP.@)
*
+++ /dev/null
-/*
- * Thread definitions
- *
- * Copyright 1996 Alexandre Julliard
- *
- * 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
- */
-
-#ifndef __WINE_THREAD_H
-#define __WINE_THREAD_H
-
-#include <stdarg.h>
-#define WIN32_NO_STATUS
-#include <windef.h>
-#include <winbase.h>
-#include <winreg.h>
-#define WINE_NO_TEB
-#include <wine/windef16.h>
-
-struct _SECURITY_ATTRIBUTES;
-struct tagSYSLEVEL;
-struct server_buffer_info;
-struct fiber_data;
-
-struct debug_info
-{
- char *str_pos; /* current position in strings buffer */
- char *out_pos; /* current position in output buffer */
- char strings[1024]; /* buffer for temporary strings */
- char output[1024]; /* current output line */
-};
-
-#endif /* __WINE_THREAD_H */
* 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.
*/
+
+#define NONAMELESSUNION
+
#include "config.h"
#include <stdlib.h>
#include <stdarg.h>
case SymTagFunction: return ((const struct symt_function*)sym)->hash_elt.name;
case SymTagPublicSymbol: return ((const struct symt_public*)sym)->hash_elt.name;
case SymTagBaseType: return ((const struct symt_basic*)sym)->hash_elt.name;
- case SymTagLabel: return ((const struct symt_function_point*)sym)->name;
+ case SymTagLabel: return ((const struct symt_hierarchy_point*)sym)->hash_elt.name;
case SymTagThunk: return ((const struct symt_thunk*)sym)->hash_elt.name;
/* hierarchy tree */
case SymTagEnum: return ((const struct symt_enum*)sym)->name;
return TRUE;
}
-struct symt_enum* symt_new_enum(struct module* module, const char* typename)
+struct symt_enum* symt_new_enum(struct module* module, const char* typename,
+ struct symt* basetype)
{
struct symt_enum* sym;
{
sym->symt.tag = SymTagEnum;
sym->name = (typename) ? pool_strdup(&module->pool, typename) : NULL;
+ sym->base_type = basetype;
vector_init(&sym->vchildren, sizeof(struct symt*), 8);
}
return sym;
e->hash_elt.next = NULL;
e->kind = DataIsConstant;
e->container = &enum_type->symt;
- /* CV defines the underlying type for the enumeration */
- e->type = &symt_new_basic(module, btInt, "int", 4)->symt;
+ e->type = enum_type->base_type;
e->u.value.n1.n2.vt = VT_I4;
e->u.value.n1.n2.n3.lVal = value;
case SymTagFuncDebugStart:
case SymTagFuncDebugEnd:
case SymTagLabel:
- X(ULONG64) = ((const struct symt_function_point*)type)->parent->address +
- ((const struct symt_function_point*)type)->loc.offset;
+ if (!symt_get_info(((const struct symt_hierarchy_point*)type)->parent,
+ req, pInfo))
+ return FALSE;
+ X(ULONG64) += ((const struct symt_hierarchy_point*)type)->loc.offset;
break;
case SymTagThunk:
X(ULONG64) = ((const struct symt_thunk*)type)->address;
case SymTagThunk:
X(DWORD64) = ((const struct symt_thunk*)type)->size;
break;
+ case SymTagLabel:
+ X(DWORD64) = 0;
+ break;
default:
FIXME("Unsupported sym-tag %s for get-length\n",
symt_get_tag_str(type->tag));
case SymTagFunction:
X(DWORD) = (DWORD)((const struct symt_function*)type)->type;
break;
- /* FIXME: should also work for enums */
+ case SymTagEnum:
+ X(DWORD) = (DWORD)((const struct symt_enum*)type)->base_type;
+ break;
case SymTagFunctionArgType:
X(DWORD) = (DWORD)((const struct symt_function_arg_type*)type)->arg_type;
break;
symt_get_tag_str(type->tag));
case SymTagPublicSymbol:
case SymTagThunk:
+ case SymTagLabel:
return FALSE;
}
break;
X(DWORD) = (DWORD)((const struct symt_array*)type)->index_type;
break;
+ case TI_GET_CLASSPARENTID:
+ /* FIXME: we don't support properly C++ for now, pretend this symbol doesn't
+ * belong to a parent class
+ */
+ return FALSE;
+
#undef X
case TI_GET_ADDRESSOFFSET:
- case TI_GET_CLASSPARENTID:
case TI_GET_SYMINDEX:
case TI_GET_THISADJUST:
case TI_GET_VIRTUALBASECLASS:
return FALSE;
}
CloseHandle(hFile);
- if (!StrFormatByteSizeW(file_size.QuadPart, resultstr, sizeof(resultstr) / sizeof(WCHAR)))
+ if (!StrFormatByteSizeW(file_size.QuadPart, resultstr, sizeof(resultstr)/sizeof(resultstr[0])));
return FALSE;
hDlgCtrl = GetDlgItem(hwndDlg, 14011);
- TRACE("result size %u resultstr %s\n", file_size.QuadPart, debugstr_w(resultstr));
+ ERR("result size %u resultstr %s %s\n", file_size.QuadPart, debugstr_w(resultstr), resultstr);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)resultstr);
if (lpfilesize)
#define SYMF_THUNK 0x00002000
#define SYMF_TLSREL 0x00004000
-typedef enum
+typedef enum
{
SymNone = 0,
SymCoff,
#define SYMOPT_EXACT_SYMBOLS 0x00000400
#define SYMOPT_WILD_UNDERSCORE 0x00000800
#define SYMOPT_USE_DEFAULTS 0x00001000
-/* latest SDK defines: */
+/* latest SDK defines:
#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800
#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000
-
+*/
#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000
#define SYMOPT_PUBLICS_ONLY 0x00004000
#define SYMOPT_NO_PUBLICS 0x00008000
typedef DWORD RVA;
typedef ULONG64 RVA64;
-typedef enum _MINIDUMP_TYPE
+typedef enum _MINIDUMP_TYPE
{
MiniDumpNormal = 0x0000,
MiniDumpWithDataSegs = 0x0001,
ULONG64 StackEnd;
} MINIDUMP_THREAD_CALLBACK, *PMINIDUMP_THREAD_CALLBACK;
-typedef struct _MINIDUMP_THREAD_EX_CALLBACK
+typedef struct _MINIDUMP_THREAD_EX_CALLBACK
{
ULONG ThreadId;
HANDLE ThreadHandle;
ULONG ThreadId;
} MINIDUMP_INCLUDE_THREAD_CALLBACK, *PMINIDUMP_INCLUDE_THREAD_CALLBACK;
-typedef enum _THREAD_WRITE_FLAGS
+typedef enum _THREAD_WRITE_FLAGS
{
ThreadWriteThread = 0x0001,
ThreadWriteStack = 0x0002,
ThreadWriteThreadInfo = 0x0040
} THREAD_WRITE_FLAGS;
-typedef struct _MINIDUMP_MODULE_CALLBACK
+typedef struct _MINIDUMP_MODULE_CALLBACK
{
PWCHAR FullPath;
ULONG64 BaseOfImage;
ULONG SizeOfMiscRecord;
} MINIDUMP_MODULE_CALLBACK, *PMINIDUMP_MODULE_CALLBACK;
-typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
+typedef struct _MINIDUMP_INCLUDE_MODULE_CALLBACK
{
ULONG64 BaseOfImage;
} MINIDUMP_INCLUDE_MODULE_CALLBACK, *PMINIDUMP_INCLUDE_MODULE_CALLBACK;
-typedef enum _MODULE_WRITE_FLAGS
+typedef enum _MODULE_WRITE_FLAGS
{
ModuleWriteModule = 0x0001,
ModuleWriteDataSeg = 0x0002,
ModuleWriteCodeSegs = 0x0040,
} MODULE_WRITE_FLAGS;
-typedef struct _MINIDUMP_CALLBACK_INPUT
+typedef struct _MINIDUMP_CALLBACK_INPUT
{
ULONG ProcessId;
HANDLE ProcessHandle;
ULONG CallbackType;
- union
+ union
{
MINIDUMP_THREAD_CALLBACK Thread;
MINIDUMP_THREAD_EX_CALLBACK ThreadEx;
typedef struct _MINIDUMP_CALLBACK_OUTPUT
{
- union
+ union
{
ULONG ModuleWriteFlags;
ULONG ThreadWriteFlags;
typedef BOOL (WINAPI* MINIDUMP_CALLBACK_ROUTINE)(PVOID, const PMINIDUMP_CALLBACK_INPUT, PMINIDUMP_CALLBACK_OUTPUT);
-typedef struct _MINIDUMP_CALLBACK_INFORMATION
+typedef struct _MINIDUMP_CALLBACK_INFORMATION
{
MINIDUMP_CALLBACK_ROUTINE CallbackRoutine;
void* CallbackParam;
} MINIDUMP_CALLBACK_INFORMATION, *PMINIDUMP_CALLBACK_INFORMATION;
-typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
+typedef struct _MINIDUMP_LOCATION_DESCRIPTOR
{
ULONG DataSize;
RVA Rva;
} MINIDUMP_LOCATION_DESCRIPTOR;
-typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
+typedef struct _MINIDUMP_LOCATION_DESCRIPTOR64
{
ULONG64 DataSize;
RVA64 Rva;
DWORD NumberOfStreams;
RVA StreamDirectoryRva;
DWORD CheckSum;
- union
+ union
{
DWORD Reserved;
DWORD TimeDateStamp;
ULONG64 Reserved1;
} MINIDUMP_MODULE, *PMINIDUMP_MODULE;
-typedef struct _MINIDUMP_MODULE_LIST
+typedef struct _MINIDUMP_MODULE_LIST
{
ULONG NumberOfModules;
MINIDUMP_MODULE Modules[1]; /* FIXME: 0-sized array not supported */
ULONG FeatureInformation;
ULONG AMDExtendedCpuFeatures;
} X86CpuInfo;
- struct
+ struct
{
ULONG64 ProcessorFeatures[2];
} OtherCpuInfo;
#include <poppack.h>
-/*************************
- * User mode dump *
- *************************/
-typedef BOOL (WINAPI *PDBGHELP_CREATE_USER_DUMP_CALLBACK)(DWORD, PVOID*, LPDWORD, PVOID);
-BOOL WINAPI DbgHelpCreateUserDump(LPSTR, PDBGHELP_CREATE_USER_DUMP_CALLBACK, PVOID);
-BOOL WINAPI DbgHelpCreateUserDumpW(LPWSTR, PDBGHELP_CREATE_USER_DUMP_CALLBACK, PVOID);
-
/*************************
* MODULE handling *
*************************/
WCHAR name[MAX_SYM_NAME+1];
} SYMBOL_INFO_PACKAGEW, *PSYMBOL_INFO_PACKAGEW;
-typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
+typedef enum _IMAGEHLP_SYMBOL_TYPE_INFO
{
TI_GET_SYMTAG,
TI_GET_SYMNAME,
PULONG64 ReqsValid;
} IMAGEHLP_GET_TYPE_INFO_PARAMS, *PIMAGEHLP_GET_TYPE_INFO_PARAMS;
-typedef struct _TI_FINDCHILDREN_PARAMS
+typedef struct _TI_FINDCHILDREN_PARAMS
{
ULONG Count;
ULONG Start;
BOOL WINAPI SymGetLineFromName(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE);
BOOL WINAPI SymGetLineFromName64(HANDLE, PCSTR, PCSTR, DWORD, PLONG, PIMAGEHLP_LINE64);
BOOL WINAPI SymGetLineFromNameW64(HANDLE, PCWSTR, PCWSTR, DWORD, PLONG, PIMAGEHLP_LINEW64);
-BOOL WINAPI SymGetFileLineOffsets64(HANDLE, PSTR, PSTR, PDWORD64, ULONG);
+ULONG WINAPI SymGetFileLineOffsets64(HANDLE, PCSTR, PCSTR, PDWORD64, ULONG);
BOOL WINAPI SymGetSourceFile(HANDLE, ULONG64, PCSTR, PCSTR, PSTR, DWORD);
BOOL WINAPI SymGetSourceFileW(HANDLE, ULONG64, PCWSTR, PCWSTR, PWSTR, DWORD);
BOOL WINAPI SymGetSourceFileToken(HANDLE, ULONG64, PCSTR, PVOID*, DWORD*);
HANDLE WINAPI SymFindDebugInfoFileW(HANDLE, PCWSTR, PWSTR, PFIND_DEBUG_FILE_CALLBACKW, PVOID);
typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACK)(PCSTR, PVOID);
typedef BOOL (CALLBACK *PFINDFILEINPATHCALLBACKW)(PCWSTR, PVOID);
-BOOL WINAPI FindFileInPath(HANDLE, LPSTR, LPSTR, PVOID, DWORD, DWORD, DWORD, LPSTR);
+BOOL WINAPI FindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
+ PSTR, PFINDFILEINPATHCALLBACK, PVOID);
BOOL WINAPI SymFindFileInPath(HANDLE, PCSTR, PCSTR, PVOID, DWORD, DWORD, DWORD,
PSTR, PFINDFILEINPATHCALLBACK, PVOID);
BOOL WINAPI SymFindFileInPathW(HANDLE, PCWSTR, PCWSTR, PVOID, DWORD, DWORD, DWORD,
*************************/
BOOL WINAPI SymSetContext(HANDLE, PIMAGEHLP_STACK_FRAME, PIMAGEHLP_CONTEXT);
-/*************************
- * Processes *
- *************************/
-typedef BOOL (*PSYM_ENUMPROCESSES_CALLBACK)(HANDLE, PVOID);
-BOOL SymEnumProcesses(PSYM_ENUMPROCESSES_CALLBACK, PVOID);
/*************************
* Stack management *
* 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
+ * symbol size (to be greater than 256), which was likely needed for
* complex C++ types (nested + templates).
*
* It's somehow difficult to represent the layout of those types on
{
unsigned short int len;
short int id;
- unsigned this_type;
- unsigned int class_type;
unsigned int rvtype;
+ unsigned int class_type;
+ unsigned this_type;
unsigned char call;
unsigned char reserved;
unsigned short params;
* 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.
+ *
+ * Official MS documentation says that type (< 0x4000, so 12 bits) is made of:
+ * +----------+------+------+----------+------+
+ * | 11 | 10-8 | 7-4 | 3 | 2-0 |
+ * +----------+------+------+----------+------+
+ * | reserved | mode | type | reserved | size |
+ * +----------+------+------+----------+------+
+ * In recent PDB files, type 8 exists, and is seen as an HRESULT... So we've
+ * added this basic type... as if bit 3 had been integrated into the size field
*/
-#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 */
+/* the type number of a built-in type is a 16-bit value specified in the following format:
+ bit # | 11 | 10-8 | 7-4 | 3 | 2-0 |
+ field | reserved | mode | type | reserved | size |
+
+ where
+ <type> is one of the following types:
+ 0x00 Special
+ 0x01 Signed integral value
+ 0x02 Unsigned integral value
+ 0x03 Boolean
+ 0x04 Real
+ 0x05 Complex
+ 0x06 Special2
+ 0x07 Real int value
+ 0x08 Reserved
+ 0x09 Reserved
+ 0x0a Reserved
+ 0x0b Reserved
+ 0x0c Reserved
+ 0x0d Reserved
+ 0x0e Reserved
+ 0x0f Reserved for debugger expression evaluator
+
+ <size> is an enumerated value for each of the types.
+ Type = special
+ 0x00 No type
+ 0x01 Absolute symbol
+ 0x02 Segment
+ 0x03 Void
+ 0x04 Basic 8-byte currency value
+ 0x05 Near Basic string
+ 0x06 Far Basic string
+ 0x07 Untranslated type from previous Microsoft symbol formats
+ Type = signed/unsigned integral and Boolean values
+ 0x00 1 byte
+ 0x01 2 byte
+ 0x02 4 byte
+ 0x03 8 byte
+ 0x04 Reserved
+ 0x05 Reserved
+ 0x06 Reserved
+ 0x07 Reserved
+ Type = real and complex
+ 0x00 32 bit
+ 0x01 64 bit
+ 0x02 80 bit
+ 0x03 128 bit
+ 0x04 48 bit
+ 0x05 Reserved
+ 0x06 Reserved
+ 0x07 Reserved
+ Type = special2
+ 0x00 Bit
+ 0x01 Pascal CHAR
+ Type = Real int
+ 0x00 Char
+ 0x01 Wide character
+ 0x02 2-byte signed integer
+ 0x03 2-byte unsigned integer
+ 0x04 4-byte signed integer
+ 0x05 4-byte unsigned integer
+ 0x06 8-byte signed integer
+ 0x07 8-byte unsigned integer
+
+ <mode> is the pointer mode:
+ 0x00 Direct; not a pointer
+ 0x01 Near pointer
+ 0x02 Far pointer
+ 0x03 Huge pointer
+ 0x04 32-bit near pointer
+ 0x05 32-bit far pointer
+ 0x06 64-bit near pointer
+ 0x07 Reserved
+*/
+
+/* basic types */
+#define T_NOTYPE 0x0000 /* Notype */
+#define T_ABS 0x0001 /* Abs */
+#define T_SEGMENT 0x0002 /* segment type */
+#define T_VOID 0x0003 /* Void */
+#define T_CURRENCY 0x0004 /* basic 8-byte currency value */
+#define T_NBASICSTR 0x0005 /* near basic string */
+#define T_FBASICSTR 0x0006 /* far basic string */
+#define T_NOTTRANS 0x0007 /* untranslated type record from MS symbol format */
+#define T_HRESULT 0x0008 /* HRESULT - or error code ??? */
+#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_BOOL08 0x0030 /* 8-bit boolean */
+#define T_BOOL16 0x0031 /* 16-bit boolean */
+#define T_BOOL32 0x0032 /* 32-bit boolean */
+#define T_BOOL64 0x0033 /* 64-bit boolean */
+#define T_REAL32 0x0040 /* float */
+#define T_REAL64 0x0041 /* double */
+#define T_REAL80 0x0042 /* 80-bit real */
+#define T_REAL128 0x0043 /* 128-bit real */
+#define T_REAL48 0x0044 /* 48-bit real */
+#define T_CPLX32 0x0050 /* 32-bit complex number */
+#define T_CPLX64 0x0051 /* 64-bit complex number */
+#define T_CPLX80 0x0052 /* 80-bit complex number */
+#define T_CPLX128 0x0053 /* 128-bit complex number */
+#define T_BIT 0x0060 /* bit */
+#define T_PASCHAR 0x0061 /* pascal CHAR */
+#define T_RCHAR 0x0070 /* real char */
+#define T_WCHAR 0x0071 /* wide char */
+#define T_INT2 0x0072 /* real 16-bit signed int */
+#define T_UINT2 0x0073 /* real 16-bit unsigned int */
+#define T_INT4 0x0074 /* int */
+#define T_UINT4 0x0075 /* unsigned int */
+#define T_INT8 0x0076 /* 64-bit signed int */
+#define T_UINT8 0x0077 /* 64-bit unsigned int */
+
+
+/* near pointers to basic types */
+#define T_PVOID 0x0103 /* near pointer to void */
+#define T_PCHAR 0x0110 /* Near pointer to 8-bit signed */
+#define T_PSHORT 0x0111 /* Near pointer to 16-bit signed */
+#define T_PLONG 0x0112 /* Near pointer to 32-bit signed */
+#define T_PQUAD 0x0113 /* Near pointer to 64-bit signed */
+#define T_PUCHAR 0x0120 /* Near pointer to 8-bit unsigned */
+#define T_PUSHORT 0x0121 /* Near pointer to 16-bit unsigned */
+#define T_PULONG 0x0122 /* Near pointer to 32-bit unsigned */
+#define T_PUQUAD 0x0123 /* Near pointer to 64-bit unsigned */
+#define T_PBOOL08 0x0130 /* Near pointer to 8-bit Boolean */
+#define T_PBOOL16 0x0131 /* Near pointer to 16-bit Boolean */
+#define T_PBOOL32 0x0132 /* Near pointer to 32-bit Boolean */
+#define T_PBOOL64 0x0133 /* Near pointer to 64-bit Boolean */
+#define T_PREAL32 0x0140 /* Near pointer to 32-bit real */
+#define T_PREAL64 0x0141 /* Near pointer to 64-bit real */
+#define T_PREAL80 0x0142 /* Near pointer to 80-bit real */
+#define T_PREAL128 0x0143 /* Near pointer to 128-bit real */
+#define T_PREAL48 0x0144 /* Near pointer to 48-bit real */
+#define T_PCPLX32 0x0150 /* Near pointer to 32-bit complex */
+#define T_PCPLX64 0x0151 /* Near pointer to 64-bit complex */
+#define T_PCPLX80 0x0152 /* Near pointer to 80-bit complex */
+#define T_PCPLX128 0x0153 /* Near pointer to 128-bit complex */
+#define T_PRCHAR 0x0170 /* Near pointer to a real char */
+#define T_PWCHAR 0x0171 /* Near pointer to a wide char */
+#define T_PINT2 0x0172 /* Near pointer to 16-bit signed int */
+#define T_PUINT2 0x0173 /* Near pointer to 16-bit unsigned int */
+#define T_PINT4 0x0174 /* Near pointer to 32-bit signed int */
+#define T_PUINT4 0x0175 /* Near pointer to 32-bit unsigned int */
+#define T_PINT8 0x0176 /* Near pointer to 64-bit signed int */
+#define T_PUINT8 0x0177 /* Near pointer to 64-bit unsigned int */
+
+
+/* far pointers to basic types */
+#define T_PFVOID 0x0203 /* Far pointer to void */
+#define T_PFCHAR 0x0210 /* Far pointer to 8-bit signed */
+#define T_PFSHORT 0x0211 /* Far pointer to 16-bit signed */
+#define T_PFLONG 0x0212 /* Far pointer to 32-bit signed */
+#define T_PFQUAD 0x0213 /* Far pointer to 64-bit signed */
+#define T_PFUCHAR 0x0220 /* Far pointer to 8-bit unsigned */
+#define T_PFUSHORT 0x0221 /* Far pointer to 16-bit unsigned */
+#define T_PFULONG 0x0222 /* Far pointer to 32-bit unsigned */
+#define T_PFUQUAD 0x0223 /* Far pointer to 64-bit unsigned */
+#define T_PFBOOL08 0x0230 /* Far pointer to 8-bit Boolean */
+#define T_PFBOOL16 0x0231 /* Far pointer to 16-bit Boolean */
+#define T_PFBOOL32 0x0232 /* Far pointer to 32-bit Boolean */
+#define T_PFBOOL64 0x0233 /* Far pointer to 64-bit Boolean */
+#define T_PFREAL32 0x0240 /* Far pointer to 32-bit real */
+#define T_PFREAL64 0x0241 /* Far pointer to 64-bit real */
+#define T_PFREAL80 0x0242 /* Far pointer to 80-bit real */
+#define T_PFREAL128 0x0243 /* Far pointer to 128-bit real */
+#define T_PFREAL48 0x0244 /* Far pointer to 48-bit real */
+#define T_PFCPLX32 0x0250 /* Far pointer to 32-bit complex */
+#define T_PFCPLX64 0x0251 /* Far pointer to 64-bit complex */
+#define T_PFCPLX80 0x0252 /* Far pointer to 80-bit complex */
+#define T_PFCPLX128 0x0253 /* Far pointer to 128-bit complex */
+#define T_PFRCHAR 0x0270 /* Far pointer to a real char */
+#define T_PFWCHAR 0x0271 /* Far pointer to a wide char */
+#define T_PFINT2 0x0272 /* Far pointer to 16-bit signed int */
+#define T_PFUINT2 0x0273 /* Far pointer to 16-bit unsigned int */
+#define T_PFINT4 0x0274 /* Far pointer to 32-bit signed int */
+#define T_PFUINT4 0x0275 /* Far pointer to 32-bit unsigned int */
+#define T_PFINT8 0x0276 /* Far pointer to 64-bit signed int */
+#define T_PFUINT8 0x0277 /* Far pointer to 64-bit unsigned int */
+
+
+/* huge pointers to basic types */
+#define T_PHVOID 0x0303 /* Huge pointer to void */
+#define T_PHCHAR 0x0310 /* Huge pointer to 8-bit signed */
+#define T_PHSHORT 0x0311 /* Huge pointer to 16-bit signed */
+#define T_PHLONG 0x0312 /* Huge pointer to 32-bit signed */
+#define T_PHQUAD 0x0313 /* Huge pointer to 64-bit signed */
+#define T_PHUCHAR 0x0320 /* Huge pointer to 8-bit unsigned */
+#define T_PHUSHORT 0x0321 /* Huge pointer to 16-bit unsigned */
+#define T_PHULONG 0x0322 /* Huge pointer to 32-bit unsigned */
+#define T_PHUQUAD 0x0323 /* Huge pointer to 64-bit unsigned */
+#define T_PHBOOL08 0x0330 /* Huge pointer to 8-bit Boolean */
+#define T_PHBOOL16 0x0331 /* Huge pointer to 16-bit Boolean */
+#define T_PHBOOL32 0x0332 /* Huge pointer to 32-bit Boolean */
+#define T_PHBOOL64 0x0333 /* Huge pointer to 64-bit Boolean */
+#define T_PHREAL32 0x0340 /* Huge pointer to 32-bit real */
+#define T_PHREAL64 0x0341 /* Huge pointer to 64-bit real */
+#define T_PHREAL80 0x0342 /* Huge pointer to 80-bit real */
+#define T_PHREAL128 0x0343 /* Huge pointer to 128-bit real */
+#define T_PHREAL48 0x0344 /* Huge pointer to 48-bit real */
+#define T_PHCPLX32 0x0350 /* Huge pointer to 32-bit complex */
+#define T_PHCPLX64 0x0351 /* Huge pointer to 64-bit complex */
+#define T_PHCPLX80 0x0352 /* Huge pointer to 80-bit complex */
+#define T_PHCPLX128 0x0353 /* Huge pointer to 128-bit real */
+#define T_PHRCHAR 0x0370 /* Huge pointer to a real char */
+#define T_PHWCHAR 0x0371 /* Huge pointer to a wide char */
+#define T_PHINT2 0x0372 /* Huge pointer to 16-bit signed int */
+#define T_PHUINT2 0x0373 /* Huge pointer to 16-bit unsigned int */
+#define T_PHINT4 0x0374 /* Huge pointer to 32-bit signed int */
+#define T_PHUINT4 0x0375 /* Huge pointer to 32-bit unsigned int */
+#define T_PHINT8 0x0376 /* Huge pointer to 64-bit signed int */
+#define T_PHUINT8 0x0377 /* Huge pointer to 64-bit unsigned int */
+
+
+/* 32-bit near pointers to basic types */
+#define T_32PVOID 0x0403 /* 32-bit near pointer to void */
+#define T_32PHRESULT 0x0408 /* 16:32 near pointer to HRESULT - or error code ??? */
+#define T_32PCHAR 0x0410 /* 16:32 near pointer to 8-bit signed */
+#define T_32PSHORT 0x0411 /* 16:32 near pointer to 16-bit signed */
+#define T_32PLONG 0x0412 /* 16:32 near pointer to 32-bit signed */
+#define T_32PQUAD 0x0413 /* 16:32 near pointer to 64-bit signed */
+#define T_32PUCHAR 0x0420 /* 16:32 near pointer to 8-bit unsigned */
+#define T_32PUSHORT 0x0421 /* 16:32 near pointer to 16-bit unsigned */
+#define T_32PULONG 0x0422 /* 16:32 near pointer to 32-bit unsigned */
+#define T_32PUQUAD 0x0423 /* 16:32 near pointer to 64-bit unsigned */
+#define T_32PBOOL08 0x0430 /* 16:32 near pointer to 8-bit Boolean */
+#define T_32PBOOL16 0x0431 /* 16:32 near pointer to 16-bit Boolean */
+#define T_32PBOOL32 0x0432 /* 16:32 near pointer to 32-bit Boolean */
+#define T_32PBOOL64 0x0433 /* 16:32 near pointer to 64-bit Boolean */
+#define T_32PREAL32 0x0440 /* 16:32 near pointer to 32-bit real */
+#define T_32PREAL64 0x0441 /* 16:32 near pointer to 64-bit real */
+#define T_32PREAL80 0x0442 /* 16:32 near pointer to 80-bit real */
+#define T_32PREAL128 0x0443 /* 16:32 near pointer to 128-bit real */
+#define T_32PREAL48 0x0444 /* 16:32 near pointer to 48-bit real */
+#define T_32PCPLX32 0x0450 /* 16:32 near pointer to 32-bit complex */
+#define T_32PCPLX64 0x0451 /* 16:32 near pointer to 64-bit complex */
+#define T_32PCPLX80 0x0452 /* 16:32 near pointer to 80-bit complex */
+#define T_32PCPLX128 0x0453 /* 16:32 near pointer to 128-bit complex */
+#define T_32PRCHAR 0x0470 /* 16:32 near pointer to a real char */
+#define T_32PWCHAR 0x0471 /* 16:32 near pointer to a wide char */
+#define T_32PINT2 0x0472 /* 16:32 near pointer to 16-bit signed int */
+#define T_32PUINT2 0x0473 /* 16:32 near pointer to 16-bit unsigned int */
+#define T_32PINT4 0x0474 /* 16:32 near pointer to 32-bit signed int */
+#define T_32PUINT4 0x0475 /* 16:32 near pointer to 32-bit unsigned int */
+#define T_32PINT8 0x0476 /* 16:32 near pointer to 64-bit signed int */
+#define T_32PUINT8 0x0477 /* 16:32 near pointer to 64-bit unsigned int */
+
+
+/* 32-bit far pointers to basic types */
+#define T_32PFVOID 0x0503 /* 32-bit far pointer to void */
+#define T_32PFCHAR 0x0510 /* 16:32 far pointer to 8-bit signed */
+#define T_32PFSHORT 0x0511 /* 16:32 far pointer to 16-bit signed */
+#define T_32PFLONG 0x0512 /* 16:32 far pointer to 32-bit signed */
+#define T_32PFQUAD 0x0513 /* 16:32 far pointer to 64-bit signed */
+#define T_32PFUCHAR 0x0520 /* 16:32 far pointer to 8-bit unsigned */
+#define T_32PFUSHORT 0x0521 /* 16:32 far pointer to 16-bit unsigned */
+#define T_32PFULONG 0x0522 /* 16:32 far pointer to 32-bit unsigned */
+#define T_32PFUQUAD 0x0523 /* 16:32 far pointer to 64-bit unsigned */
+#define T_32PFBOOL08 0x0530 /* 16:32 far pointer to 8-bit Boolean */
+#define T_32PFBOOL16 0x0531 /* 16:32 far pointer to 16-bit Boolean */
+#define T_32PFBOOL32 0x0532 /* 16:32 far pointer to 32-bit Boolean */
+#define T_32PFBOOL64 0x0533 /* 16:32 far pointer to 64-bit Boolean */
+#define T_32PFREAL32 0x0540 /* 16:32 far pointer to 32-bit real */
+#define T_32PFREAL64 0x0541 /* 16:32 far pointer to 64-bit real */
+#define T_32PFREAL80 0x0542 /* 16:32 far pointer to 80-bit real */
+#define T_32PFREAL128 0x0543 /* 16:32 far pointer to 128-bit real */
+#define T_32PFREAL48 0x0544 /* 16:32 far pointer to 48-bit real */
+#define T_32PFCPLX32 0x0550 /* 16:32 far pointer to 32-bit complex */
+#define T_32PFCPLX64 0x0551 /* 16:32 far pointer to 64-bit complex */
+#define T_32PFCPLX80 0x0552 /* 16:32 far pointer to 80-bit complex */
+#define T_32PFCPLX128 0x0553 /* 16:32 far pointer to 128-bit complex */
+#define T_32PFRCHAR 0x0570 /* 16:32 far pointer to a real char */
+#define T_32PFWCHAR 0x0571 /* 16:32 far pointer to a wide char */
+#define T_32PFINT2 0x0572 /* 16:32 far pointer to 16-bit signed int */
+#define T_32PFUINT2 0x0573 /* 16:32 far pointer to 16-bit unsigned int */
+#define T_32PFINT4 0x0574 /* 16:32 far pointer to 32-bit signed int */
+#define T_32PFUINT4 0x0575 /* 16:32 far pointer to 32-bit unsigned int */
+#define T_32PFINT8 0x0576 /* 16:32 far pointer to 64-bit signed int */
+#define T_32PFUINT8 0x0577 /* 16:32 far pointer to 64-bit unsigned int */
+
+
+/* counts, bit masks, and shift values needed to access various parts of the built-in type numbers */
+#define T_MAXPREDEFINEDTYPE 0x0580 /* maximum type index for all built-in types */
+#define T_MAXBASICTYPE 0x0080 /* maximum type index all non-pointer built-in types */
+#define T_BASICTYPE_MASK 0x00ff /* mask of bits that can potentially identify a non-pointer basic type */
+#define T_BASICTYPE_SHIFT 8 /* shift count to push out the basic type bits from a type number */
+#define T_MODE_MASK 0x0700 /* type mode mask (ptr/non-ptr) */
+#define T_SIZE_MASK 0x0007 /* type size mask (depends on 'type' value) */
+#define T_TYPE_MASK 0x00f0 /* type type mask (data treatment mode) */
+
+/* bit patterns for the <mode> portion of a built-in type number */
+#define T_NEARPTR_BITS 0x0100
+#define T_FARPTR_BITS 0x0200
+#define T_HUGEPTR_BITS 0x0300
+#define T_NEAR32PTR_BITS 0x0400
+#define T_FAR32PTR_BITS 0x0500
+#define T_NEAR64PTR_BITS 0x0600
#define LF_MODIFIER_V1 0x0001
#define LF_POINTER_V1 0x0002
char name[1];
} stack_v3;
+ 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;
+ unsigned short unknown;
+ char name[1];
+ } stack_xxxx_v3;
+
struct
{
short int len; /* Total length of this entry */
#define S_PUB_V3 0x110E
#define S_LPROC_V3 0x110F
#define S_GPROC_V3 0x1110
-#define S_MSTOOL_V3 0x1116 /* not really understood */
+#define S_BPREL_XXXX_V3 0x1111 /* not really understood, but looks like bprel... */
+#define S_MSTOOL_V3 0x1116 /* compiler command line options and build information */
#define S_PUB_FUNC1_V3 0x1125 /* didn't get the difference between the two */
#define S_PUB_FUNC2_V3 0x1127
DWORD unknown;
DWORD hash1_file;
DWORD hash2_file;
- DWORD gsym_file;
+ WORD gsym_file;
+ WORD unknown1;
DWORD module_size;
DWORD offset_size;
DWORD hash_size;
reactos/dll/win32/cryptdll # Autosync
reactos/dll/win32/cryptnet # Autosync
reactos/dll/win32/cryptui # Autosync
-reactos/dll/win32/dbghelp # Synced to Wine-20080106
+reactos/dll/win32/dbghelp # Synced to Wine-20080802
reactos/dll/win32/dciman32 # Synced to Wine-1_0-rc2
reactos/dll/win32/gdiplus # Autosync
reactos/dll/win32/hhctrl.ocx # Autosync
projects / reactos.git / commitdiff